CSC_Digitizer Class Reference

#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)
	Old way before 10/2010.
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.
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.

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 )

Old way before 10/2010.

Definition at line 396 of file CSC_Digitizer.cxx.

                                                                                                                                    {
    // method to digitize a single hit. Must be called in a loop over hits
    // after a call to the method "StatusCode CSC_Digitize::initialize()"
    // get the step vector from the begining and end vectors of the G4 step
    Amg::Vector3D startHit = cscHit->getHitStart();
    Amg::Vector3D endHit = cscHit->getHitEnd();
 
    // decode the hit ID
    const Identifier HitId = to_identifier(cscHit);
    const int chamberLayer = m_cscHitHelper->GetChamberLayer(cscHit->CSCid());
    // find the detector descriptor
    const CscReadoutElement* descriptor = m_muonMgr->getCscReadoutElement(HitId);
    if (!descriptor) {
        std::cout << "CSC_Digitizer::ERROR : Cannot get descriptor for GeoModel = " << std::endl;
        return StatusCode::FAILURE;
    }
 
    // particle ID
    int ipart = cscHit->particleID();
 
    Amg::Vector3D stepHit = endHit - startHit;
    double step = stepHit.mag();
 
    if (step == 0) return StatusCode::SUCCESS;
 
    // get average number of interaction::one interaction for photons
    //  std::cout << "The particle ID = " << ipart << std::endl;
 
    int nInter = 0;
    if (ipart == 1)
        nInter = 1;
    else {
        double average_int = 30;  // average interactions per cm
        double pois = CLHEP::RandPoisson::shoot(rndmEngine, average_int);
        nInter = int(step * pois / 10.0 + 0.5);  //  number of interaction according to Poisson
        if (m_debug)
            std::cout << "[CSC_Digitizer::digitize_hit] nInter info from random number pois:step:nInter  " << pois << " " << step << " "
                      << nInter << std::endl;
    }
 
    if (nInter <= 0) return StatusCode::SUCCESS;
 
    double wireCharge;
    int nElectrons = 0;
 
    // loop over number of interactions and do digitization
    for (int i = 0; i < nInter; ++i) {
        double t = 0.0;
        if (ipart == 1 || ipart == 999)
            t = step * 0.50;  // one interaction for photons & geantinos
        else
            t = CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0);  // for other particles
 
        const Amg::Vector3D pos_vec = startHit + t * stepHit;
        // pileup - check if within time window
        double preDriftTime = getDriftTime(descriptor, pos_vec);  // before geant hit time addition.
        double driftTime = m_bunchTime + cscHit->meanTime() + preDriftTime;
 
        if (m_debug) {
            std::cout << "[CSC_Digitizer::digitize_hit] totTime:driftTime:hitTime:bunchTime (ns) = " << driftTime << " "
                      << cscHit->meanTime() << " " << preDriftTime << " " << m_bunchTime << std::endl;
            std::cout << "[CSC_Digitizer::digitize_hit] start hit coordinates (xc,yc,zc) / step hit and t / the hit are " << startHit
                      << "    " << stepHit << "   " << t << "    " << pos_vec << std::endl;
        }
 
        // Prompt muon case::
        // CSL 25.02ns   CSS 26.3ns :: Dec03 2009  geant hit time was not added but it's added now.
        // so previous +- 50ns time window may not work. We need to tune it. Temporally, I put -inf +inf.
 
        // it should be decided by bunchtime. -400 to +200
        if (outsideWindow(m_bunchTime)) continue;
 
        // number of electrons in this interaction
        double flat = CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0);
        double p = m_sprob[s_maxElectron - 1] * flat;
        for (int k = 0; k < s_maxElectron; ++k) {
            if (p <= m_sprob[k]) {
                nElectrons = k + 1;
                break;
            }
        }
 
        // find the charge on the wire in electron-equivalent charge
        m_Polia = 0.38;  // parmeter for charge loss:: random gamma function
        double gammaDist = CLHEP::RandGamma::shoot(rndmEngine, (1.0 + m_Polia), 1.0);
        wireCharge = qWire(nElectrons, gammaDist);
 
        if (m_debug) {
            std::cout << "[CSC_Digitizer::digitize_hit] flat:p:maxEle:nEle:gammaDist:wireCharge " << flat << " " << p << " "
                      << s_maxElectron << " " << nElectrons << " " << gammaDist << " " << wireCharge << std::endl;
        }
 
        // now digitize hits for R- and phi-strips
        for (int measuresPhi = 0; measuresPhi <= 1; ++measuresPhi) {
            float stripWidth = descriptor->cathodeReadoutPitch(chamberLayer, measuresPhi);
            const int maxStrip = descriptor->maxNumberOfStrips(measuresPhi, stripWidth);
 
            // now digitize hits for R-strips/phi-strips
 
            if (measuresPhi == 0) {                                     // R-strips :: find the charge+noise
                double zz = pos_vec.z() + maxStrip * stripWidth * 0.50;  // assuming zero offset
                int strip = int(zz / stripWidth) + 1;
                // find the charges induced on the phi strips
 
                for (int j = strip - 4; j <= strip + 4; j++) {
                    double zpos = stripWidth * j - stripWidth * 0.50;
                    if (j > 0 && j <= maxStrip) {
                        double stripCharge = wireCharge * qStripR((zpos - zz) / stripWidth, HitId) * 0.50;
 
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit] zpos = " << zpos << " zz = " << zz
                                      << " diff = " << std::abs(zz - zpos) << " strip = " << j << " charge = " << stripCharge << std::endl;
 
                        IdentifierHash hashId = getHashId(HitId, j, measuresPhi);
 
                        fillMaps(hashId, driftTime, stripCharge, hashVec, data_map);
 
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit] DriftTimeVSstripCharge " << driftTime << " " << stripCharge
                                      << std::endl;
                    }
                }
            } else {  // Phi-strips :: find the charge+noise
                double yy = 0.0;
                int strip = 0;
 
                yy = pos_vec.y() + maxStrip * stripWidth * 0.5;  // non-pointing phi-strips :: assuming zero offset
                if (m_cscHitHelper->GetZSector(cscHit->CSCid()) > 0)
                    yy = -pos_vec.y() + maxStrip * stripWidth * 0.5;  // non-pointing phi-strips :: assuming zero offset
                strip = int(yy / stripWidth) + 1;
 
                // find the charges induced on the phi strips
                for (int j = strip - 1; j <= strip + 1; ++j) {
                    if (j > 0 && j <= maxStrip) {
                        double ypos = stripWidth * (j - 0.5);
                        double stripCharge = wireCharge * qStripPhi(ypos - yy, HitId) * 0.50;
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit] ypos = " << ypos << " yy = " << yy
                                      << " diff = " << std::abs(yy - ypos) << " strip = " << j << " charge = " << stripCharge << std::endl;
 
                        IdentifierHash hashId = getHashId(HitId, j, measuresPhi);
 
                        fillMaps(hashId, driftTime, stripCharge, hashVec, data_map);
                    }
                }
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

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 )

Definition at line 235 of file CSC_Digitizer.cxx.

                                                                                                                                   {
    // method to digitize a single hit. Must be called in a loop over hits
    // after a call to the method "StatusCode CSC_Digitize::initialize()"
    // get the step vector from the begining and end vectors of the G4 step
    Amg::Vector3D startHit = cscHit->getHitStart();
    Amg::Vector3D endHit = cscHit->getHitEnd();
 
    // decode the hit ID
    const Identifier HitId = to_identifier(cscHit);
    const int chamberLayer = m_cscHitHelper->GetChamberLayer(cscHit->CSCid());
 
    // find the detector descriptor
    const CscReadoutElement* descriptor = m_muonMgr->getCscReadoutElement(HitId);
    if (!descriptor) {
        std::cout << "CSC_Digitizer::ERROR : Cannot get descriptor for GeoModel = " << std::endl;
        return StatusCode::FAILURE;
    }
 
    // particle ID
    int ipart = cscHit->particleID();
 
    Amg::Vector3D stepHit = endHit - startHit;
    double step = stepHit.mag();
 
    if (step == 0) return StatusCode::SUCCESS;
 
    // get average number of interaction::one interaction for photons
    //  std::cout << "The particle ID = " << ipart << std::endl;
 
    int nInter = 0;
    if (ipart == 1)
        nInter = 1;
    else {
        double average_int = 30;  // average interactions per cm
        double pois = CLHEP::RandPoisson::shoot(rndmEngine, average_int);
        nInter = int(step * pois / 10.0 + 0.5);  //  number of interaction according to Poisson
        if (m_debug)
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] nInter info from random number pois:step:nInter  " << pois << " " << step
                      << " " << nInter << std::endl;
    }
 
    if (nInter <= 0) return StatusCode::SUCCESS;
 
    double wireCharge{0};
    int nElectrons = 0;
 
    // loop over number of interactions and do digitization
    for (int i = 0; i < nInter; ++i) {
        double t = 0.0;
        if (ipart == 1 || ipart == 999)
            t = step * 0.50;  // one interaction for photons & geantinos
        else
            t = CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0);  // for other particles
 
        Amg::Vector3D pos_vec = startHit + t * stepHit;
 
        // pileup - check if within time window
        double preDriftTime = getDriftTime(descriptor, pos_vec);  // before geant hit time addition.
        double driftTime = m_bunchTime + cscHit->meanTime() + preDriftTime;
 
        if (m_debug) {
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] totTime:driftTime:hitTime:bunchTime (ns) = " << driftTime << " "
                      << cscHit->meanTime() << " " << preDriftTime << " " << m_bunchTime << std::endl;
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] start hit coordinates (xc,yc,zc) / step hit and t / the hit are " << startHit
                      << "    " << stepHit << "   " << t << "    " << pos_vec << std::endl;
        }
 
        // Prompt muon case::
        // CSL 25.02ns   CSS 26.3ns :: Dec03 2009  geant hit time was not added but it's added now.
        // so previous +- 50ns time window may not work. We need to tune it. Temporally, I put -inf +inf.
 
        // it should be decided by bunchtime. -400 to +200
        if (outsideWindow(m_bunchTime)) continue;
 
        // number of electrons in this interaction
        double flat = CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0);
        double p = m_sprob[s_maxElectron - 1] * flat;
        for (int k = 0; k < s_maxElectron; ++k) {
            if (p <= m_sprob[k]) {
                nElectrons = k + 1;
                break;
            }
        }
 
        // find the charge on the wire in electron-equivalent charge
 
        m_Polia = 0.38;  // parmeter for charge loss:: random gamma function
        double gammaDist = CLHEP::RandGamma::shoot(rndmEngine, (1.0 + m_Polia), 1.0);
        wireCharge = qWire(nElectrons, gammaDist);
 
        if (m_debug) {
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] flat:p:maxEle:nEle:gammaDist:wireCharge " << flat << " " << p << " "
                      << s_maxElectron << " " << nElectrons << " " << gammaDist << " " << wireCharge << std::endl;
        }
 
        // now digitize hits for R- and phi-strips
        for (int measuresPhi = 0; measuresPhi <= 1; ++measuresPhi) {
            float stripWidth = descriptor->cathodeReadoutPitch(chamberLayer, measuresPhi);
            const int maxStrip = descriptor->maxNumberOfStrips(measuresPhi, stripWidth);
 
            if (m_debug) {
                std::cout << "[CSC_Digitizer::digitize_hit(NEW)] CSC_Digitizer::digitize_hit: Chamber Parameters"
                          << " measuresPhi= " << measuresPhi << " stripWidth= " << stripWidth << " maxStrip= " << maxStrip << std::endl;
            }
 
            // now digitize hits for R-strips/phi-strips
 
            if (measuresPhi == 0) {                                     // R-strips :: find the charge+noise
                double zz = pos_vec.z() + maxStrip * stripWidth * 0.50;  // assuming zero offset
                int strip = int(zz / stripWidth) + 1;
                // find the charges induced on the phi strips
                for (int j = strip - 4; j <= strip + 4; ++j) {
                    double zpos = stripWidth * j - stripWidth * 0.50;
                    if (j > 0 && j <= maxStrip) {
                        double stripCharge = wireCharge * qStripR((zpos - zz) / stripWidth, HitId) * 0.50;
 
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] zpos = " << zpos << " zz = " << zz
                                      << " diff = " << std::abs(zz - zpos) << " strip = " << j << " charge = " << stripCharge << std::endl;
 
                        IdentifierHash hashId = getHashId(HitId, j, measuresPhi);
                        fillSampleMaps(hashId, driftTime, stripCharge, hashVec, data_SampleMap);
 
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] DriftTimeVSstripCharge " << driftTime << " " << stripCharge
                                      << std::endl;
                    }
                }
            } else {  // Phi-strips :: find the charge+noise
                double yy = 0.0;
                int strip = 0;
 
                yy = pos_vec.y() + maxStrip * stripWidth * 0.5;  // non-pointing phi-strips :: assuming zero offset
                if (m_cscHitHelper->GetZSector(cscHit->CSCid()) > 0)
                    yy = -pos_vec.y() + maxStrip * stripWidth * 0.5;  // non-pointing phi-strips :: assuming zero offset
                strip = int(yy / stripWidth) + 1;
 
                // find the charges induced on the phi strips
                for (int j = strip - 1; j <= strip + 1; j++) {
                    if (j > 0 && j <= maxStrip) {
                        double ypos = stripWidth * (j - 0.5);
                        double stripCharge = wireCharge * qStripPhi(ypos - yy, HitId) * 0.50;
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] ypos = " << ypos << " yy = " << yy
                                      << " diff = " << std::abs(yy - ypos) << " strip = " << j << " charge = " << stripCharge << std::endl;
 
                        IdentifierHash hashId = getHashId(HitId, j, measuresPhi);
                        fillSampleMaps(hashId, driftTime, stripCharge, hashVec, data_SampleMap);
                    }
                }
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

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 )

Definition at line 67 of file CSC_Digitizer.cxx.

                                                                         {
    // method to digitize a single hit. Must be called in a loop over hits
    // after a call to the method "StatusCode CSC_Digitize::initialize()"
    // get the step vector from the begining and end vectors of the G4 step
 
    Amg::Vector3D startHit = cscHit->getHitStart();
    Amg::Vector3D endHit = cscHit->getHitEnd();
 
    // decode the hit ID
    const Identifier HitId = to_identifier(cscHit);
    const int chamberLayer = m_cscHitHelper->GetChamberLayer(cscHit->CSCid());
 
    // find the detector descriptor
    const CscReadoutElement* descriptor = m_muonMgr->getCscReadoutElement(HitId);
    if (!descriptor) {
        std::cout << "CSC_Digitizer::ERROR : Cannot get descriptor for GeoModel = " << std::endl;
        return StatusCode::FAILURE;
    }
 
    // particle ID
    int ipart = cscHit->particleID();
 
    Amg::Vector3D stepHit = endHit - startHit;
    double step = stepHit.mag();  // path length in a layer
 
    if (step == 0) return StatusCode::SUCCESS;
 
    // get average number of interaction::one interaction for photons
    int nInter = 0;
    if (ipart == 1)
        nInter = 1;
    else {
        if (m_NInterFromEnergyLoss) {
            double energyLoss = cscHit->energyDeposit();  // MeV peaking at 0.001MeV for on time track (25ns from IP)
            double elecEnergy = m_electronEnergy *
                                0.000001;  // each ionized electron has 66eV (66 is from 0.001MeV/15 (average interaction per layer 0.5cm)
            nInter = energyLoss / elecEnergy;
        } else {
            double average_int = 30;  // average interactions per cm
            double pois = CLHEP::RandPoisson::shoot(rndmEngine, average_int);
            nInter = int(step * pois / 10.0 + 0.5);  //  number of interaction according to Poisson
            if (m_debug)
                std::cout << "[CSC_Digitizer::digitize_hit(NEW)] nInter info from random number pois:step:nInter  " << pois << " " << step
                          << " " << nInter << std::endl;
        }
    }
 
    if (nInter <= 0) return StatusCode::SUCCESS;
 
    double wireCharge{0.};
    int nElectrons{0};
 
    // loop over number of interactions and do digitization
    for (int i = 0; i < nInter; ++i) {
        double t = 0.0;
        if (ipart == 1 || ipart == 999)
            t = step * 0.50;  // one interaction for photons & geantinos
        else
            t = CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0);  // for other particles
 
        const Amg::Vector3D pos_vec = startHit + t * stepHit;
 
        // pileup - check if within time window
        double preDriftTime = getDriftTime(descriptor, pos_vec);  // before geant hit time addition.
        double driftTime = m_bunchTime + cscHit->meanTime() + preDriftTime;
 
        if (m_debug) {
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] totTime:driftTime:hitTime:bunchTime (ns) = " << driftTime << " "
                      << cscHit->meanTime() << " " << preDriftTime << " " << m_bunchTime << std::endl;
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] start hit coordinates (xc,yc,zc) / step hit and t / the hit are " << startHit
                      << "    " << stepHit << "   " << t << "    " << pos_vec << std::endl;
        }
 
        // Prompt muon case::
        // CSL 25.02ns   CSS 26.3ns :: Dec03 2009  geant hit time was not added but it's added now.
        // so previous +- 50ns time window may not work. We need to tune it. Temporally, I put -inf +inf.
 
        // it should be decided by bunchtime. -400 to +200
        if (outsideWindow(m_bunchTime)) continue;
 
        // number of electrons in this interaction
        double flat = CLHEP::RandFlat::shoot(rndmEngine, 0.0, 1.0);
        double p = m_sprob[s_maxElectron - 1] * flat;
        for (int k = 0; k < s_maxElectron; ++k) {
            if (p <= m_sprob[k]) {
                nElectrons = k + 1;
                break;
            }
        }
 
        // find the charge on the wire in electron-equivalent charge
 
        m_Polia = 0.38;  // parmeter for charge loss:: random gamma function
        double gammaDist = CLHEP::RandGamma::shoot(rndmEngine, (1.0 + m_Polia), 1.0);
        wireCharge = qWire(nElectrons, gammaDist);
 
        if (m_debug) {
            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] flat:p:maxEle:nEle:gammaDist:wireCharge " << flat << " " << p << " "
                      << s_maxElectron << " " << nElectrons << " " << gammaDist << " " << wireCharge << std::endl;
        }
 
        // now digitize hits for R- and phi-strips
        for (int measuresPhi = 0; measuresPhi <= 1; ++measuresPhi) {
            float stripWidth = descriptor->cathodeReadoutPitch(chamberLayer, measuresPhi);
            const int maxStrip = descriptor->maxNumberOfStrips(measuresPhi, stripWidth);
 
            if (m_debug) {
                std::cout << "[CSC_Digitizer::digitize_hit(NEW)] CSC_Digitizer::digitize_hit: Chamber Parameters"
                          << " measuresPhi= " << measuresPhi << " stripWidth= " << stripWidth << " maxStrip= " << maxStrip << std::endl;
            }
 
            // now digitize hits for R-strips/phi-strips
 
            if (measuresPhi == 0) {                                     // R-strips :: find the charge+noise
                double zz = pos_vec.z() + maxStrip * stripWidth * 0.50;  // assuming zero offset
                int strip = int(zz / stripWidth) + 1;
                // find the charges induced on the phi strips
                for (int j = strip - 4; j <= strip + 4; ++j) {
                    double zpos = stripWidth * j - stripWidth * 0.50;
                    if (j > 0 && j <= maxStrip) {
                        double stripCharge = wireCharge * qStripR((zpos - zz) / stripWidth, HitId) * 0.50;
                        //      if (stripCharge < 0) stripCharge = 0.0;
 
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] zpos = " << zpos << " zz = " << zz
                                      << " diff = " << std::abs(zz - zpos) << " strip = " << j << " charge = " << stripCharge << std::endl;
 
                        IdentifierHash hashId = getHashId(HitId, j, measuresPhi);
                        fillSampleMaps(hashId, driftTime, stripCharge, hashVec, data_SampleMap);
                        fillSampleMaps(hashId, driftTime, stripCharge, hashVec, data_SampleMapOddPhase, 1);
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] DriftTimeVSstripCharge " << driftTime << " " << stripCharge
                                      << std::endl;
                    }
                }
            } else {  // Phi-strips :: find the charge+noise
                double yy = 0.0;
                int strip = 0;
 
                yy = pos_vec.y() + maxStrip * stripWidth * 0.5;  // non-pointing phi-strips :: assuming zero offset
                if (m_cscHitHelper->GetZSector(cscHit->CSCid()) > 0)
                    yy = -pos_vec.y() + maxStrip * stripWidth * 0.5;  // non-pointing phi-strips :: assuming zero offset
                strip = int(yy / stripWidth) + 1;
 
                // find the charges induced on the phi strips
                for (int j = strip - 1; j <= strip + 1; ++j) {
                    if (j > 0 && j <= maxStrip) {
                        double ypos = stripWidth * (j - 0.5);
                        double stripCharge = wireCharge * qStripPhi(ypos - yy, HitId) * 0.50;
                        if (m_debug)
                            std::cout << "[CSC_Digitizer::digitize_hit(NEW)] ypos = " << ypos << " yy = " << yy
                                      << " diff = " << std::abs(yy - ypos) << " strip = " << j << " charge = " << stripCharge << std::endl;
 
                        IdentifierHash hashId = getHashId(HitId, j, measuresPhi);
                        fillSampleMaps(hashId, driftTime, stripCharge, hashVec, data_SampleMap);
                        fillSampleMaps(hashId, driftTime, stripCharge, hashVec, data_SampleMapOddPhase, 1);
                    }
                }
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

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.

{ m_bunchTime = bunchTime; }

setAmplification()

void CSC_Digitizer::setAmplification ( const double amplification )

inline

Definition at line 54 of file CSC_Digitizer.h.

{ m_amplification = amplification; }

setDebug()

void CSC_Digitizer::setDebug ( int debug )

inline

Definition at line 56 of file CSC_Digitizer.h.

{ m_debug = debug; }

setDriftVelocity()

void CSC_Digitizer::setDriftVelocity ( double v0 )

inline

Definition at line 58 of file CSC_Digitizer.h.

{ m_driftVelocity = v0; }

setElectronEnergy()

void CSC_Digitizer::setElectronEnergy ( double e )

inline

Definition at line 59 of file CSC_Digitizer.h.

{ m_electronEnergy = e; }  // eV

setNInterFixed()

void CSC_Digitizer::setNInterFixed ( )

inline

Definition at line 60 of file CSC_Digitizer.h.

{ 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.

{0.};

m_bunchTime

double CSC_Digitizer::m_bunchTime {0.}

private

Definition at line 106 of file CSC_Digitizer.h.

{0.};

m_cscHitHelper

const CscHitIdHelper* CSC_Digitizer::m_cscHitHelper {nullptr}

private

Definition at line 93 of file CSC_Digitizer.h.

{nullptr};

m_cscIdHelper

const CscIdHelper* CSC_Digitizer::m_cscIdHelper {nullptr}

private

Definition at line 95 of file CSC_Digitizer.h.

{nullptr};

m_debug

int CSC_Digitizer::m_debug {0}

private

Definition at line 109 of file CSC_Digitizer.h.

{0};

m_driftVelocity

double CSC_Digitizer::m_driftVelocity {60.}

private

Definition at line 108 of file CSC_Digitizer.h.

{60.};  // (1e-6 * 1e9); // 6 cm/microsecond -> mm/ns // 0.06

m_electronEnergy

double CSC_Digitizer::m_electronEnergy {66.}

private

Definition at line 100 of file CSC_Digitizer.h.

{66.};  // unit is eV

m_muonMgr

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

private

Definition at line 94 of file CSC_Digitizer.h.

{nullptr};  // cannot use ReadCondHandleKey since no athena component

m_NInterFromEnergyLoss

bool CSC_Digitizer::m_NInterFromEnergyLoss {true}

private

Definition at line 99 of file CSC_Digitizer.h.

{true};

m_pcalib

ICscCalibTool* CSC_Digitizer::m_pcalib {nullptr}

private

Definition at line 96 of file CSC_Digitizer.h.

{nullptr};

m_Polia

double CSC_Digitizer::m_Polia {0.}

private

Definition at line 102 of file CSC_Digitizer.h.

{0.};

m_sprob

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

private

Definition at line 103 of file CSC_Digitizer.h.

{0.};

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.

{0.};

m_timeWindowUpperOffset

double CSC_Digitizer::m_timeWindowUpperOffset {0.}

private

Definition at line 105 of file CSC_Digitizer.h.

{0.};

s_maxElectron

int CSC_Digitizer::s_maxElectron {21}

staticconstexprprivate

Definition at line 98 of file CSC_Digitizer.h.

{21};  // max electron per interaction :not configurable

---

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

• CSC_Digitizer.h
• CSC_Digitizer.cxx