#include <CSC_Digitizer.h>

Collaboration diagram for CSC_Digitizer:

Public Member Functions
	CSC_Digitizer (const CscHitIdHelper cscHitHelper, const MuonGM::MuonDetectorManager muonMgr, ICscCalibTool *pcalib)

	~CSC_Digitizer ()=default

StatusCode	initialize ()

void	setWindow (const double t1, const double t2)

void	set (const double bunchTime)

void	setAmplification (const double amplification)

void	setDebug (int debug)

void	setDriftVelocity (double v0)

void	setElectronEnergy (double e)

void	setNInterFixed ()

StatusCode	digitize_hit (const CSCSimHit cscHit, std::vector< IdentifierHash > &hashVec, std::map< IdentifierHash, std::pair< double, double > > &data_map, CLHEP::HepRandomEngine rndmEngine)

StatusCode	digitize_hit (const CSCSimHit cscHit, std::vector< IdentifierHash > &hashVec, std::map< IdentifierHash, std::vector< float > > &data_SampleMap, std::map< IdentifierHash, std::vector< float > > &data_SampleMapOddPhase, CLHEP::HepRandomEngine rndmEngine)

StatusCode	digitize_hit (const CSCSimHit cscHit, std::vector< IdentifierHash > &hashVec, std::map< IdentifierHash, std::vector< float > > &data_SampleMap, CLHEP::HepRandomEngine rndmEngine)

IdentifierHash	getHashId (const Identifier &input_id, const int stripId, const int measuresPhi) const

Private Member Functions
double	qWire (const int &nElectrons, const double &gammaDist) const

double	qStripR (const double x, const Identifier &id) const
	Charge sharing profile. More...

double	qStripPhi (const double x, const Identifier &id) const

double	getDriftTime (const MuonGM::CscReadoutElement *descriptor, const Amg::Vector3D &pos) const

bool	outsideWindow (double time) const

void	fillMaps (const IdentifierHash hash, const double driftTime, const double stripCharge, std::vector< IdentifierHash > &hashVec, std::map< IdentifierHash, std::pair< double, double > > &data_map)

void	fillSampleMaps (const IdentifierHash hash, const double driftTime, const double stripCharge, std::vector< IdentifierHash > &hashVec, std::map< IdentifierHash, std::vector< float > > &data_map, bool phase=0)

Identifier	to_identifier (const CSCSimHit *cscHit) const

Static Private Member Functions
static double	qStripR (const double x)

static double	fparamPhi (const double x, const std::array< double, 9 > &p)

Private Attributes
const CscHitIdHelper *	m_cscHitHelper {nullptr}

const MuonGM::MuonDetectorManager *	m_muonMgr {nullptr}

const CscIdHelper *	m_cscIdHelper {nullptr}

ICscCalibTool *	m_pcalib {nullptr}

bool	m_NInterFromEnergyLoss {true}

double	m_electronEnergy {66.}

double	m_Polia {0.}

std::array< double, s_maxElectron >	m_sprob {0.}

double	m_timeWindowLowerOffset {0.}

double	m_timeWindowUpperOffset {0.}

double	m_bunchTime {0.}

double	m_amplification {0.}

double	m_driftVelocity {60.}

int	m_debug {0}

std::map< char, int >	m_stationDict {}
	Cache the csc id dictionary. More...

Static Private Attributes
static constexpr int	s_maxElectron {21}

Detailed Description

Definition at line 37 of file CSC_Digitizer.h.

Constructor & Destructor Documentation

◆ CSC_Digitizer()

CSC_Digitizer::CSC_Digitizer	(	const CscHitIdHelper *	cscHitHelper,
		const MuonGM::MuonDetectorManager *	muonMgr,
		ICscCalibTool *	pcalib
	)

CSL / CSS

Definition at line 23 of file CSC_Digitizer.cxx.

                                                                                                                           :
     m_cscHitHelper{cscHitHelper}, m_muonMgr{muonMgr}, m_cscIdHelper{m_muonMgr->cscIdHelper()}, m_pcalib{pcalib} {
     m_stationDict['S'] = m_cscIdHelper->stationNameIndex("CSS");
     m_stationDict['L'] = m_cscIdHelper->stationNameIndex("CSL");
 }

◆ ~CSC_Digitizer()

CSC_Digitizer::~CSC_Digitizer ( )

default

Member Function Documentation

◆ digitize_hit() [1/3]

StatusCode CSC_Digitizer::digitize_hit	(	const CSCSimHit *	cscHit,
		std::vector< IdentifierHash > &	hashVec,
		std::map< IdentifierHash, std::pair< double, double > > &	data_map,
		CLHEP::HepRandomEngine *	rndmEngine
	)

◆ digitize_hit() [2/3]

StatusCode CSC_Digitizer::digitize_hit	(	const CSCSimHit *	cscHit,
		std::vector< IdentifierHash > &	hashVec,
		std::map< IdentifierHash, std::vector< float > > &	data_SampleMap,
		CLHEP::HepRandomEngine *	rndmEngine
	)

◆ digitize_hit() [3/3]

StatusCode CSC_Digitizer::digitize_hit	(	const CSCSimHit *	cscHit,
		std::vector< IdentifierHash > &	hashVec,
		std::map< IdentifierHash, std::vector< float > > &	data_SampleMap,
		std::map< IdentifierHash, std::vector< float > > &	data_SampleMapOddPhase,
		CLHEP::HepRandomEngine *	rndmEngine
	)

◆ fillMaps()

void CSC_Digitizer::fillMaps	(	const IdentifierHash	hash,
		const double	driftTime,
		const double	stripCharge,
		std::vector< IdentifierHash > &	hashVec,
		std::map< IdentifierHash, std::pair< double, double > > &	data_map
	)

private

Definition at line 709 of file CSC_Digitizer.cxx.

                                                                                                                             {
     if (stripCharge == 0.0) return;
  
     // fill the CSC specific charge map the conversion hash -. id is done later !
     if (data_map.find(hashId) != data_map.end()) {
         /*
          http://indico.cern.ch/getFile.py/access?contribId=9&resId=0&materialId=slides&confId=106902
         */
         std::pair<double, double> result = m_pcalib->addBipfunc(data_map[hashId].first, data_map[hashId].second, driftTime, stripCharge);
         //  To check out conversion is correct...
         if (m_debug)
             std::cout << "[CSC_Digitizer::fillMaps] (" << data_map[hashId].first << ":" << int(data_map[hashId].second) << ")"
                       << "+(" << driftTime << ":" << int(stripCharge) << ")"
                       << " ==> " << result.first << ":" << int(result.second) << " e-  which was "
                       << int(data_map[hashId].second + stripCharge) << std::endl;
  
         data_map[hashId].first = result.first;
         data_map[hashId].second = result.second;
  
     } else {
         data_map[hashId].first = driftTime;
         data_map[hashId].second = stripCharge;
         hashVec.push_back(hashId);
     }
 }

◆ fillSampleMaps()

void CSC_Digitizer::fillSampleMaps	(	const IdentifierHash	hash,
		const double	driftTime,
		const double	stripCharge,
		std::vector< IdentifierHash > &	hashVec,
		std::map< IdentifierHash, std::vector< float > > &	data_map,
		bool	phase = `0`
	)

private

Definition at line 556 of file CSC_Digitizer.cxx.

                                                {
     if (stripCharge == 0.0) return;
  
     // fill the CSC specific charge map the conversion hash -. id is done later !
     if (data_map.find(hashId) != data_map.end()) {
         float phaseOffset = (phase) ? +25 : 0;
         std::vector<float> samples = m_pcalib->getSamplesFromBipolarFunc(driftTime + phaseOffset, stripCharge);
         std::vector<float> existingSamples = data_map[hashId];  // assuming that there are four elements...
  
         if (m_debug) {
             std::cout << "[CSC_Digitizer::fillSampleMaps] ";
  
             for (unsigned int i = 0; i < samples.size(); ++i) std::cout << samples[i] << " ";
             std::cout << " + ";
  
             for (unsigned int i = 0; i < existingSamples.size(); ++i) std::cout << existingSamples[i] << " ";
  
             std::cout << "  ==>  ";
         }
  
         for (unsigned int i = 0; i < samples.size(); ++i) { existingSamples[i] += samples[i]; }
  
         if (m_debug) {
             for (unsigned int i = 0; i < existingSamples.size(); ++i) std::cout << existingSamples[i] << " ";
             std::cout << std::endl;
         }
  
         data_map[hashId] = existingSamples;
  
     } else {
         data_map.insert(std::pair<IdentifierHash, std::vector<float>>(hashId, m_pcalib->getSamplesFromBipolarFunc(driftTime, stripCharge)));
         hashVec.push_back(hashId);
     }
 }

◆ fparamPhi()

double CSC_Digitizer::fparamPhi	(	const double	x,
		const std::array< double, 9 > &	p
	)

staticprivate

Definition at line 667 of file CSC_Digitizer.cxx.

                                                                             {
     double fparam{0}, pow {1.};
     for (size_t i = 0; i < p.size(); ++i) {
         fparam += p[i] * pow;
         pow *= x;
     }
     return fparam;
 }

◆ getDriftTime()

double CSC_Digitizer::getDriftTime	(	const MuonGM::CscReadoutElement *	descriptor,
		const Amg::Vector3D &	pos
	)		const

private

Definition at line 681 of file CSC_Digitizer.cxx.

                                                                                                           {
     // need to be calculated correct - Garfield?
     // assumption on the field lines not good but of for pileup stuff!
     double time = -1000.0;
     // tested with 60, 45, 30 and 60 looks the best 12/7/2009
     double v0 = m_driftVelocity * 1.e-3;  // mm/microsecond   6 cm/microsecond -> mm/ns
     float anodeCathodeDist = descriptor->anodeCathodeDistance();
     float roxacellWidth = descriptor->roxacellWidth();
     float beta = std::atan((descriptor->longWidth() - descriptor->shortWidth()) / (2. * descriptor->lengthUpToMaxWidth()));
     float longWidth = descriptor->longWidth() - 2 * roxacellWidth * (1 + std::sin(beta)) / std::cos(beta);
     float yy = pos.y() + longWidth * 0.5;
     float x0 = pos.x();
     int wire = int(yy / anodeCathodeDist) + 1;
     float y0 = (yy - wire * anodeCathodeDist);
     if (std::abs(y0) > anodeCathodeDist / 2) y0 = std::abs(y0) - anodeCathodeDist * 0.5;
     float driftDist = std::hypot(x0, y0);  // Lorentz effect small
     time = driftDist / v0;
     return time;
 }

◆ getHashId()

IdentifierHash CSC_Digitizer::getHashId	(	const Identifier &	input_id,
		const int	stripId,
		const int	measuresPhi
	)		const

Definition at line 736 of file CSC_Digitizer.cxx.

                                                                                                                   {
     const int chamberLayer = m_cscIdHelper->chamberLayer(input_id);
     const int wireLayer = m_cscIdHelper->wireLayer(input_id);
     Identifier realHitId = m_cscIdHelper->channelID(input_id, chamberLayer, wireLayer, measuresPhi, stripId);
     IdentifierHash hashId;
     if (m_cscIdHelper->get_channel_hash(realHitId, hashId)) {
         throw std::runtime_error(
             Form("File: %s, Line: %d\nCSC_Digitizer::getHashId() - Failed to retrieve channel hash from identifier %llu", __FILE__,
                  __LINE__, realHitId.get_compact()));
     }
     return hashId;
 }

◆ initialize()

StatusCode CSC_Digitizer::initialize ( )

Definition at line 31 of file CSC_Digitizer.cxx.

                                      {
     // initialize random number generators
     // then initialize the CSC identifier helper
     // This method must be called before looping over the hits
     // to digitize them using the method digitize_hit below
     m_bunchTime = 0.0;
  
     // calculate the probability densities
     static constexpr std::array<double, s_maxElectron> prob{79.4, 12., 3.4,  1.6,  0.95, 0.6,   0.44,  0.34,  0.27,  0.21, 0.17,
                                                             0.13, 0.1, 0.08, 0.06, 0.05, 0.042, 0.037, 0.033, 0.029, 0.};
  
     double sump = 0;
     for (int i = 0; i < s_maxElectron; ++i) {
         sump += prob[i];
         m_sprob[i] = sump;
     }
  
     return StatusCode::SUCCESS;
 }

◆ outsideWindow()

bool CSC_Digitizer::outsideWindow ( double time ) const

private

Definition at line 676 of file CSC_Digitizer.cxx.

                                                         {
     // m_bunchTime is included already....updated one..
     return driftTime < m_timeWindowLowerOffset || driftTime > m_timeWindowUpperOffset;
 }

◆ qStripPhi()

double CSC_Digitizer::qStripPhi	(	const double	x,
		const Identifier &	id
	)		const

private

Definition at line 649 of file CSC_Digitizer.cxx.

                                                                           {
     // parameters obtained from test beam
     static constexpr std::array<double, 9> pSmall{.9092, .0634, -1.051, 8.05, -35.477, 58.883, -46.111, 17.446, -2.5824};
     static constexpr std::array<double, 9> pLarge{.98, -.36, 5.07, -27.81, 72.257, -99.456, 72.778, -26.779, 3.9054};
     double xx = std::abs(x) / 10.0;  // divide by 10 to convert to cm!
     double phiStripCharge = 0.0;
  
     if (xx < 1.75) {
         if (m_cscIdHelper->isSmall(id)) {
             phiStripCharge = fparamPhi(xx, pSmall);
         } else {
             phiStripCharge = fparamPhi(xx, pLarge);
         }
     }
  
     return phiStripCharge;
 }

◆ qStripR() [1/2]

double CSC_Digitizer::qStripR ( const double x )

staticprivate

Definition at line 618 of file CSC_Digitizer.cxx.

                                             {
     // induced charge on the r-strip
     // parametrization based on experimental data
  
     double rStripCharge = 0.0;
     static constexpr std::array<double,4> Par{0.185, 2.315, 0.48, 5.2};  // obtained from test beam
     double xx = std::abs(x) / 10.0;             // divide by 10 to convert to cm!
  
     rStripCharge = Par[0] * exp(-Par[1] * xx) + Par[2] * exp(-Par[3] * (xx * xx));
  
     return rStripCharge;
 }

◆ qStripR() [2/2]

double CSC_Digitizer::qStripR	(	const double	x,
		const Identifier &	id
	)		const

private

Charge sharing profile.

New implementation Jan 2012 from fit to segment hits in run 186049.

Parameters

x	distance between strip and hit center in strip widths
stationType	small or large chamber

Returns: the charge fraction for this strip

Definition at line 637 of file CSC_Digitizer.cxx.

                                                                         {
     double stripCharge = 0.0;
     double xx = x * x;  // distance in strip widths squared
  
     if (m_cscIdHelper->isSmall(id)) {  // small chamber
         stripCharge = 0.7001 / (1.0 + 1.38 * xx + 2.255 * xx * xx);
     } else {  // large chamber
         stripCharge = 0.7 / (1.0 + 1.381 * xx + 2.248 * xx * xx);
     }
     return stripCharge;
 }

◆ qWire()

double CSC_Digitizer::qWire	(	const int &	nElectrons,
		const double &	gammaDist
	)		const

private

Definition at line 602 of file CSC_Digitizer.cxx.

                                                                                 {
     // find the charge on the wire
  
     //  double amplification = 0.58e5;
     double amplification = m_amplification;
     double wireCharge = 0.0;
  
     for (int i = 0; i < nElectrons; ++i) {
         double RNDpol = 0.0;
         if (m_Polia > -1.0) { RNDpol = gammaDist / (1.0 + m_Polia); }
         wireCharge += amplification * RNDpol;
     }
     return wireCharge;
 }

◆ set()

void CSC_Digitizer::set ( const double bunchTime )

Definition at line 598 of file CSC_Digitizer.cxx.

598 { m_bunchTime = bunchTime; }

◆ setAmplification()

void CSC_Digitizer::setAmplification ( const double amplification )

inline

Definition at line 54 of file CSC_Digitizer.h.

54 { m_amplification = amplification; }

◆ setDebug()

void CSC_Digitizer::setDebug ( int debug )

inline

Definition at line 56 of file CSC_Digitizer.h.

56 { m_debug = debug; }

◆ setDriftVelocity()

void CSC_Digitizer::setDriftVelocity ( double v0 )

inline

Definition at line 58 of file CSC_Digitizer.h.

58 { m_driftVelocity = v0; }

◆ setElectronEnergy()

void CSC_Digitizer::setElectronEnergy ( double e )

inline

Definition at line 59 of file CSC_Digitizer.h.

59 { m_electronEnergy = e; } // eV

◆ setNInterFixed()

void CSC_Digitizer::setNInterFixed ( )

inline

Definition at line 60 of file CSC_Digitizer.h.

60 { m_NInterFromEnergyLoss = false; }

◆ setWindow()

void CSC_Digitizer::setWindow	(	const double	t1,
		const double	t2
	)

Definition at line 593 of file CSC_Digitizer.cxx.

                                                               {
     m_timeWindowLowerOffset = t1;
     m_timeWindowUpperOffset = t2;   
 }

◆ to_identifier()

Identifier CSC_Digitizer::to_identifier ( const CSCSimHit * cscHit ) const

private

Definition at line 51 of file CSC_Digitizer.cxx.

                                                                      {
     const int hitId = cscHit->CSCid();
     const std::string st_str = m_cscHitHelper->GetStationName(hitId);
     std::map<char, int>::const_iterator itr = m_stationDict.find(st_str[2]);
     if (itr == m_stationDict.end()) {
         throw std::runtime_error(Form("%s:%d Failed to convert station name %s to an valid offline identifier", __FILE__, __LINE__,
                                       st_str.c_str()));
     }
     const int stationName = itr->second;
     const int eta = m_cscHitHelper->GetZSector(hitId);
     const int phi = m_cscHitHelper->GetPhiSector(hitId);
     const int chamberLayer = m_cscHitHelper->GetChamberLayer(hitId);
     const int wireLayer = m_cscHitHelper->GetWireLayer(hitId);
     return m_cscIdHelper->channelID(stationName, eta, phi, chamberLayer, wireLayer, 0, 1);
 }

Member Data Documentation

◆ m_amplification

double CSC_Digitizer::m_amplification {0.}

private

Definition at line 107 of file CSC_Digitizer.h.

◆ m_bunchTime

double CSC_Digitizer::m_bunchTime {0.}

private

Definition at line 106 of file CSC_Digitizer.h.

◆ m_cscHitHelper

const CscHitIdHelper* CSC_Digitizer::m_cscHitHelper {nullptr}

private

Definition at line 93 of file CSC_Digitizer.h.

◆ m_cscIdHelper

const CscIdHelper* CSC_Digitizer::m_cscIdHelper {nullptr}

private

Definition at line 95 of file CSC_Digitizer.h.

◆ m_debug

int CSC_Digitizer::m_debug {0}

private

Definition at line 109 of file CSC_Digitizer.h.

◆ m_driftVelocity

double CSC_Digitizer::m_driftVelocity {60.}

private

Definition at line 108 of file CSC_Digitizer.h.

◆ m_electronEnergy

double CSC_Digitizer::m_electronEnergy {66.}

private

Definition at line 100 of file CSC_Digitizer.h.

◆ m_muonMgr

const MuonGM::MuonDetectorManager* CSC_Digitizer::m_muonMgr {nullptr}

private

Definition at line 94 of file CSC_Digitizer.h.

◆ m_NInterFromEnergyLoss

bool CSC_Digitizer::m_NInterFromEnergyLoss {true}

private

Definition at line 99 of file CSC_Digitizer.h.

◆ m_pcalib

ICscCalibTool* CSC_Digitizer::m_pcalib {nullptr}

private

Definition at line 96 of file CSC_Digitizer.h.

◆ m_Polia

double CSC_Digitizer::m_Polia {0.}

private

Definition at line 102 of file CSC_Digitizer.h.

◆ m_sprob

std::array<double, s_maxElectron> CSC_Digitizer::m_sprob {0.}

private

Definition at line 103 of file CSC_Digitizer.h.

◆ m_stationDict

std::map<char, int> CSC_Digitizer::m_stationDict {}

private

Cache the csc id dictionary.

Definition at line 111 of file CSC_Digitizer.h.

◆ m_timeWindowLowerOffset

double CSC_Digitizer::m_timeWindowLowerOffset {0.}

private

Definition at line 104 of file CSC_Digitizer.h.

◆ m_timeWindowUpperOffset

double CSC_Digitizer::m_timeWindowUpperOffset {0.}

private

Definition at line 105 of file CSC_Digitizer.h.

◆ s_maxElectron

constexpr int CSC_Digitizer::s_maxElectron {21}

staticconstexprprivate

Definition at line 98 of file CSC_Digitizer.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CSC_Digitizer()

◆ ~CSC_Digitizer()

Member Function Documentation

◆ digitize_hit() [1/3]

◆ digitize_hit() [2/3]

◆ digitize_hit() [3/3]

◆ fillMaps()

◆ fillSampleMaps()

◆ fparamPhi()

◆ getDriftTime()

◆ getHashId()

◆ initialize()

◆ outsideWindow()

◆ qStripPhi()

◆ qStripR() [1/2]

◆ qStripR() [2/2]

◆ qWire()

◆ set()

◆ setAmplification()

◆ setDebug()

◆ setDriftVelocity()

◆ setElectronEnergy()

◆ setNInterFixed()

◆ setWindow()

◆ to_identifier()

Member Data Documentation

◆ m_amplification

◆ m_bunchTime

◆ m_cscHitHelper

◆ m_cscIdHelper

◆ m_debug

◆ m_driftVelocity

◆ m_electronEnergy

◆ m_muonMgr

◆ m_NInterFromEnergyLoss

◆ m_pcalib

◆ m_Polia

◆ m_sprob

◆ m_stationDict

◆ m_timeWindowLowerOffset

◆ m_timeWindowUpperOffset

◆ s_maxElectron