RpcDigitizationTool Class Reference

#include <RpcDigitizationTool.h>

Inheritance diagram for RpcDigitizationTool:

Public Member Functions
	RpcDigitizationTool (const std::string &type, const std::string &name, const IInterface *pIID)
virtual StatusCode	initialize () override final
	Initialize.
virtual StatusCode	prepareEvent (const EventContext &ctx, const unsigned int) override final
	When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop.
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	When being run from PileUpToolsAlgs, this method is called for each active bunch-crossing to process current SubEvents bunchXing is in ns.
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop.
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Protected Attributes
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Pile up service"}
Gaudi::Property< bool >	m_onlyUseContainerName
SG::ReadHandleKey< RPCSimHitCollection >	m_hitsContainerKey {this, "InputObjectName", "RPC_Hits", "name of the input object"}
std::string	m_inputHitCollectionName {""}
SG::WriteHandleKey< RpcDigitContainer >	m_outputDigitCollectionKey
SG::WriteHandleKey< MuonSimDataCollection >	m_outputSDO_CollectionKey
SG::WriteHandleKey< RPCSimHitCollection >	m_simHitValidKey {this, "SimHitValidationKey", "InputRpcHits"}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
Gaudi::Property< std::string >	m_RPC_TimeSchema {this, "RPC_TimeSchema", "RPC_TimeSchema", "Tag info name of Rpc Time Info"}
Gaudi::Property< bool >	m_sdoAreOnlyDigits
Gaudi::Property< bool >	m_Efficiency_fromCOOL {this, "Efficiency_fromCOOL", false, "Read efficiency from CoolDB"}
Gaudi::Property< bool >	m_EfficiencyPatchForBMShighEta
Gaudi::Property< bool >	m_ClusterSize_fromCOOL {this, "ClusterSize_fromCOOL", false, "Read cluster size from CoolDB"}
Gaudi::Property< bool >	m_ClusterSize1_2uncorr
Gaudi::Property< bool >	m_BOG_BOF_DoubletR2_OFF {this, "Force_BOG_BOF_DoubletR2_OFF", false, "Turn-off BOG and BOF with DoubletR=2"}
Gaudi::Property< bool >	m_ignoreRunDepConfig
Gaudi::Property< bool >	m_Efficiency_BIS78_fromCOOL {this, "Efficiency_BIS78_fromCOOL", false, " read BIS78 Efficiency from COOL DB"}
Gaudi::Property< bool >	m_ClusterSize_BIS78_fromCOOL {this, "ClusterSize_BIS78_fromCOOL", false, " read BIS78 Cluster Size from COOL DB"}
Gaudi::Property< bool >	m_RPCInfoFromDb {this, "RPCInfoFromDb", false, ""}
Gaudi::Property< float >	m_CutMaxClusterSize {this, "CutMaxClusterSize", 5.0, ""}
Gaudi::Property< int >	m_CutProjectedTracks {this, "CutProjectedTracks", 100, ""}
int	m_BOF_id {-1}
int	m_BOG_id {-1}
int	m_BOS_id {-1}
int	m_BIL_id {-1}
int	m_BIS_id {-1}

Private Types
using	Collections_t = std::vector<std::unique_ptr<RpcDigitCollection> >

Private Member Functions
StatusCode	initializeRunDependentParameters ()
template<class CondType>
StatusCode	retrieveCondData (const EventContext &ctx, const SG::ReadCondHandleKey< CondType > &key, const CondType *&condPtr) const
StatusCode	getNextEvent (const EventContext &ctx)
	Get next event and extract collection of hit collections:
StatusCode	doDigitization (const EventContext &ctx, Collections_t &collections, MuonSimDataCollection *sdoContainer)
	Digitization functionality shared with RPC_PileUpTool.
StatusCode	fillTagInfo ()
long long int	PackMCTruth (float proptime, float tof, float posx, float posz) const
std::array< int, 3 >	physicalClusterSize (const EventContext &ctx, const MuonGM::RpcReadoutElement *reEle, const Identifier &id, const Amg::Vector3D &posAtCentre, CLHEP::HepRandomEngine *rndmEngine) const
	Cluster simulation: first step.
std::array< int, 3 >	TurnOnStrips (const MuonGM::RpcReadoutElement *reEle, std::array< int, 3 > &&pcs, const Identifier &id) const
	Cluster simulation: second step.
double	PropagationTime (const MuonGM::RpcReadoutElement *reEle, const Identifier &id, const Amg::Vector3D &globPos) const
	Calculates the propagation time along the strip.
Amg::Transform3D	fromSimHitToLayer (const MuonGM::RpcReadoutElement *readOutEle, const Identifier &layerId) const
	Returns the position of the hit expressed in the gasGap coordinate system.
bool	outsideWindow (double time) const
std::pair< bool, bool >	detectionEfficiency (const EventContext &ctx, const Identifier &ideta, const Identifier &idphi, CLHEP::HepRandomEngine *rndmEngine, const HepMcParticleLink &trkParticle) const
	Evaluate detection efficiency.
double	FCPEfficiency (const HepMC::ConstGenParticlePtr &genParticle) const
int	determineClusterSize (const EventContext &ctx, const Identifier &id, double xstripnorm, CLHEP::HepRandomEngine *rndmEngine) const

Static Private Member Functions
static void	UnPackMCTruth (double theWord, float &proptime, float &tof, float &posy, float &posz)
static double	timeOverThreshold (CLHEP::HepRandomEngine *rndmEngine)

Private Attributes
Gaudi::Property< double >	m_UncorrJitter {this, "UncorrJitter", 1.5, "jitter uncorrelated between eta and phi"}
	Calculates the position of the hit wrt to the strip panel this transformation is needed since the impact point comes from the SD int he gas gap's reference frame.
Gaudi::Property< double >	m_CorrJitter {this, "CorrJitter", 0.0, "jitter correlated between eta and phi"}
Gaudi::Property< double >	m_UncorrJitter_BIS78 {this, "UncorrJitter_BIS78", 0.3, "jitter uncorrelated between eta and phi BIS78"}
Gaudi::Property< double >	m_CorrJitter_BIS78 {this, "CorrJitter_BIS78", 0.0, "jitter correlated between eta and phi BIS78"}
Gaudi::Property< double >	m_timeWindowLowerOffset {this, "WindowLowerOffset", -100., "digitization window lower limit"}
Gaudi::Property< double >	m_timeWindowUpperOffset {this, "WindowUpperOffset", +150., "digitization window lower limit"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_detMgrKey
const RpcIdHelper *	m_idHelper {}
const RpcHitIdHelper *	m_muonHelper {}
std::vector< std::unique_ptr< RPCSimHitCollection > >	m_RPCHitCollList
std::unique_ptr< TimedHitCollection< RPCSimHit > >	m_thpcRPC {}
SG::ReadCondHandleKey< RpcCondDbData >	m_readKey {this, "ReadKey", "RpcCondDbData", "Key of RpcCondDbData"}
std::map< Identifier, std::vector< MuonSimData::Deposit > >	m_sdo_tmp_map
Gaudi::Property< int >	m_deadTime {this, "DeadTime", 100., "dead time"}
Gaudi::Property< bool >	m_patch_for_rpc_time {this, "PatchForRpcTime", false, ""}
Gaudi::Property< double >	m_rpc_time_shift
Gaudi::Property< bool >	m_validationSetup {this, "ValidationSetup", false, ""}
Gaudi::Property< bool >	m_includePileUpTruth {this, "IncludePileUpTruth", true, "pileup truth veto"}
Gaudi::Property< bool >	m_turnON_efficiency {this, "turnON_efficiency", true, ""}
Gaudi::Property< bool >	m_kill_deadstrips {this, "KillDeadStrips", false, ""}
Gaudi::Property< bool >	m_turnON_clustersize {this, "turnON_clustersize", true, ""}
Gaudi::Property< int >	m_FirstClusterSizeInTail {this, "FirstClusterSizeInTail", 3, ""}
Gaudi::Property< std::vector< float > >	m_PhiAndEtaEff_A {this, "PhiAndEtaEff_A", {}, ""}
Gaudi::Property< std::vector< float > >	m_OnlyPhiEff_A {this, "OnlyPhiEff_A", {}, ""}
Gaudi::Property< std::vector< float > >	m_OnlyEtaEff_A {this, "OnlyEtaEff_A", {}, ""}
Gaudi::Property< std::vector< float > >	m_PhiAndEtaEff_C {this, "PhiAndEtaEff_C", {}, ""}
Gaudi::Property< std::vector< float > >	m_OnlyPhiEff_C {this, "OnlyPhiEff_C", {}, ""}
Gaudi::Property< std::vector< float > >	m_OnlyEtaEff_C {this, "OnlyEtaEff_C", {}, ""}
Gaudi::Property< float >	m_PhiAndEtaEff_BIS78 {this, "PhiAndEtaEff_BIS78", 0.93, ""}
Gaudi::Property< float >	m_OnlyEtaEff_BIS78 {this, "OnlyEtaEff_BIS78", 0.96, ""}
Gaudi::Property< float >	m_OnlyPhiEff_BIS78 {this, "OnlyPhiEff_BIS78", 0.96, ""}
Gaudi::Property< std::vector< double > >	m_FracClusterSize1_A {this, "FracClusterSize1_A", {}, ""}
Gaudi::Property< std::vector< double > >	m_FracClusterSize2_A {this, "FracClusterSize2_A", {}, ""}
Gaudi::Property< std::vector< double > >	m_FracClusterSizeTail_A {this, "FracClusterSizeTail_A", {}, ""}
Gaudi::Property< std::vector< double > >	m_MeanClusterSizeTail_A {this, "MeanClusterSizeTail_A", {}, ""}
Gaudi::Property< std::vector< double > >	m_FracClusterSize1_C {this, "FracClusterSize1_C", {}, ""}
Gaudi::Property< std::vector< double > >	m_FracClusterSize2_C {this, "FracClusterSize2_C", {}, ""}
Gaudi::Property< std::vector< double > >	m_FracClusterSizeTail_C {this, "FracClusterSizeTail_C", {}, ""}
Gaudi::Property< std::vector< double > >	m_MeanClusterSizeTail_C {this, "MeanClusterSizeTail_C", {}, ""}
Gaudi::Property< float >	m_FracClusterSize1_BIS78 {this, "FracClusterSize1_BIS78", 0.60, ""}
Gaudi::Property< float >	m_FracClusterSize2_BIS78 {this, "FracClusterSize2_BIS78", 0.35, ""}
Gaudi::Property< float >	m_FracClusterSizeTail_BIS78 {this, "FracClusterSizeTail_BIA78", 0.05, ""}
Gaudi::Property< float >	m_MeanClusterSizeTail_BIS78 {this, "MeanClusterSizeTail_BIA78", 3.5, ""}
Gaudi::Property< bool >	m_muonOnlySDOs {this, "MuonOnlySDOs", true, ""}

structors and AlgTool implementation
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset

Detailed Description

Class methods and properties

In the initialize() method, the PileUpMerge and StoreGate services are initialized, and a pointer to an instance of the class MuonDetectorManager is retrieved from the detector store and used to obtain an rpcIdHelper. The ASCII file G4RPC_Digitizer.txt is read and its contents are used by the algorithm in order to simulate clusters. Random numbers are obtained in the code from a dedicated stream via AtRndmSvc, which is also initialized in the initialize() method. The execute() has responsibility for steering the digitization/cluster simulation process. A loop over the RPCHits is performed, converting each SimID to OID. The method physicalClusterSize is hence called, which creates a cluster of size 1 or two according to the impact point of the particle along the strip. The final size of the cluster is decided by the method TurnOnStrips. The last step in the creation of the digitization is the calculation of the propagation time of the electrical signal along the strip length. This is done in the PropagationTime method. In the hit collections coming from the RPCSensitiveDetector, it sometimes happen that many hits are produced by the same crossing particle, which are very close both in space and time. This is related to ionization and production of secondaries in the gas, and it is thus safe, and also recommended, to eliminate these multiple hits before proceeding to reconstruction. The execute() method provides this functionality using a dead time: once a hit is found on a given strip, every other hit coming from the same strip before the dead time is ignored.

Definition at line 64 of file RpcDigitizationTool.h.

Member Typedef Documentation

Collections_t

using RpcDigitizationTool::Collections_t = std::vector<std::unique_ptr<RpcDigitCollection> >

private

Definition at line 94 of file RpcDigitizationTool.h.

Constructor & Destructor Documentation

RpcDigitizationTool()

RpcDigitizationTool::RpcDigitizationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pIID )

Definition at line 95 of file RpcDigitizationTool.cxx.

                                                                                                             :
    PileUpToolBase(type, name, pIID) {}

Member Function Documentation

detectionEfficiency()

std::pair< bool, bool > RpcDigitizationTool::detectionEfficiency ( const EventContext & ctx, const Identifier & ideta, const Identifier & idphi, CLHEP::HepRandomEngine * rndmEngine, const HepMcParticleLink & trkParticle ) const

private

Evaluate detection efficiency.

Definition at line 1091 of file RpcDigitizationTool.cxx.

                                                                                                          {
    
    
 
    ATH_MSG_DEBUG("RpcDigitizationTool::in DetectionEfficiency");
 
    ATH_MSG_DEBUG("EtaPanelId to look for Eff is " << m_idHelper->show_to_string(IdEta));
    ATH_MSG_DEBUG("PhiPanelId to look for Eff is " << m_idHelper->show_to_string(IdPhi));
 
 
    // dead spacers are not simulated in GEANT4  => their effect must be emulated in the digitizer as an effective max. efficiency = 99%
    // (spacers are 1x1cm^2 over a grid of 10x10cm^2 =? geometrical ineff. introduced is 1% for normal incidence)
    float maxGeomEff{0.99}, PhiAndEtaEff{0.99}, OnlyEtaEff{0.f}, OnlyPhiEff{0.f};
 
    // 2=BML,3=BMS,4=BOL,5=BOS,8=BMF,9=BOF,10=BOG
    int stationName = m_idHelper->stationName(IdEta);
    int stationEta = m_idHelper->stationEta(IdEta);
    int doubletR = m_idHelper->doubletR(IdEta);
 
    // remove feet extension. driven by joboption
    if (m_BOG_BOF_DoubletR2_OFF && (stationName == m_BOF_id || stationName == m_BOG_id) && doubletR == 2) {
        return std::make_pair(false, false);
    }
 
 
    if (!m_turnON_efficiency) {
        return std::make_pair(true, true);
    }
    bool etaStripOn{true}, phiStripOn{true};
 
    // int stripetadead = 0 ; // not used
    // int stripphidead = 0 ; // not used
 
    unsigned int index = stationName - 2;
    // BML and BMS, BOL and BOS  come first (stationName= 2 and 3, 4 and 5 -> index 0-3)
    if (stationName > 5 && stationName < 50) index = index - 2;
    // BMF, BOF and BOG are 8,9,10 => must be 4,5 and 6
    else if (stationName > 50)
        index = index - 44;
    // BME and BOE 53 and 54 are at indices 7 and 8
 
    if (!m_Efficiency_fromCOOL && stationName >= 2) {
        if (index > m_PhiAndEtaEff_A.size() || index > m_OnlyEtaEff_A.size() || index > m_OnlyPhiEff_A.size()) {
            THROW_EXCEPTION("Index out of array in Detection Efficiency SideA " << index << " stationName = " << stationName);
        }
 
        PhiAndEtaEff = m_PhiAndEtaEff_A[index];
        OnlyEtaEff = m_OnlyEtaEff_A[index];
        OnlyPhiEff = m_OnlyPhiEff_A[index];
 
        if (stationEta < 0) {
            if (index > m_PhiAndEtaEff_C.size() || index > m_OnlyEtaEff_C.size() || index > m_OnlyPhiEff_C.size()) {
                THROW_EXCEPTION("Index out of array in Detection Efficiency SideC " << index << " stationName = " << stationName);
            }
            PhiAndEtaEff = m_PhiAndEtaEff_C[index];
            OnlyEtaEff = m_OnlyEtaEff_C[index];
            OnlyPhiEff = m_OnlyPhiEff_C[index];
        }
    } else if (stationName < 2 && (!m_Efficiency_fromCOOL || !m_Efficiency_BIS78_fromCOOL)) {  // BIS
        PhiAndEtaEff = m_PhiAndEtaEff_BIS78;
        OnlyEtaEff = m_OnlyEtaEff_BIS78;
        OnlyPhiEff = m_OnlyPhiEff_BIS78;
    } else {  // Efficiency from Cool
 
        const RpcCondDbData* readCdo{nullptr};                        
        if(!retrieveCondData(ctx, m_readKey, readCdo).isSuccess()){
            THROW_EXCEPTION("Failed to retrieve conditions object");
        }
 
        ATH_MSG_DEBUG("Efficiencies and cluster size + dead strips will be extracted from COOL");
 
        double FracDeadStripEta{0.}, FracDeadStripPhi{0.};
        double EtaPanelEfficiency{1.}, PhiPanelEfficiency{1.}, GapEfficiency{1.};
        int RPC_ProjectedTracksEta = 0;
        
        std::optional<double> fracDeadStripEtaFromCOOL = readCdo->getFracDeadStrip(IdEta);
        std::optional<double> fracDeadStripPhiFromCOOL = readCdo->getFracDeadStrip(IdPhi);
        
        bool noEntryInDb = !fracDeadStripEtaFromCOOL || !fracDeadStripPhiFromCOOL;
 
        FracDeadStripEta = fracDeadStripEtaFromCOOL.value_or(0.);
        FracDeadStripPhi = fracDeadStripPhiFromCOOL.value_or(0.);
        RPC_ProjectedTracksEta = readCdo->getProjectedTrack(IdEta).value_or(0);
        
        EtaPanelEfficiency = readCdo->getEfficiency(IdEta).value_or(1.);
        PhiPanelEfficiency = readCdo->getEfficiency(IdPhi).value_or(1.);
        GapEfficiency = readCdo->getGapEfficiency(IdEta).value_or(1.);
 
        if (std::abs(FracDeadStripEta - 1.) < 0.001) {
            ATH_MSG_DEBUG("Watch out: SPECIAL CASE: Read from Cool: FracDeadStripEta/Phi "
                          << FracDeadStripEta << "/" << FracDeadStripPhi << " RPC_ProjectedTracksEta " << RPC_ProjectedTracksEta
                          << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency << "/" << PhiPanelEfficiency << " gapEff " << GapEfficiency
                          << " for gas gap " << m_idHelper->show_to_string(IdEta) << " id " << IdEta.get_identifier32().get_compact());
            // dead eta panel => cannot determine the strip status for phi strips
            // FracDeadStripPhi must be reset to 0. and undefinedPhiStripStatus = true
            FracDeadStripPhi = 0.;
            ATH_MSG_VERBOSE("Watch out: SPECIAL CASE: Resetting FracDeadStripPhi " << FracDeadStripPhi << " ignoring phi dead strips ");
        }
 
        // special test
        // here redefining the efficiencies:
        // EtaPanelEfficiency = 0.92;
        // PhiPanelEfficiency = 0.85;
        // GapEfficiency      = 0.97;
        bool changing = false;
        ATH_MSG_DEBUG("Read from Cool: FracDeadStripEta/Phi " << FracDeadStripEta << "/" << FracDeadStripPhi << " RPC_ProjectedTracksEta "
                                                              << RPC_ProjectedTracksEta << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency
                                                              << "/" << PhiPanelEfficiency << " gapEff " << GapEfficiency);
        // if ((1.-FracDeadStripEta)<EtaPanelEfficiency)
        if ((maxGeomEff - FracDeadStripEta) - EtaPanelEfficiency < -0.011) {
            ATH_MSG_DEBUG("Ineff. from dead strips on Eta Panel larger that measured efficiency: deadFrac="
                          << FracDeadStripEta << " Panel Eff=" << EtaPanelEfficiency << " for Panel " << m_idHelper->show_to_string(IdEta));
            ATH_MSG_DEBUG("... see the corresponding report from RpcDetectorStatusDbTool");
            // EtaPanelEfficiency = 1.-FracDeadStripEta;
            EtaPanelEfficiency = maxGeomEff - FracDeadStripEta;
            changing = true;
        }
        // if ((1.-FracDeadStripPhi)<PhiPanelEfficiency)
        if ((maxGeomEff - FracDeadStripPhi) - PhiPanelEfficiency < -0.011) {
            ATH_MSG_DEBUG("Ineff. from dead strips on Phi Panel larger that measured efficiency: deadFrac="
                          << FracDeadStripPhi << " Panel Eff=" << PhiPanelEfficiency << " for Panel " << m_idHelper->show_to_string(IdPhi));
            ATH_MSG_DEBUG("... see the corresponding report among the warnings of RpcDetectorStatusDbTool");
            // PhiPanelEfficiency = 1.-FracDeadStripPhi;
            PhiPanelEfficiency = maxGeomEff - FracDeadStripPhi;
            changing = true;
        }
        // if ((1.-FracDeadStripEta*FracDeadStripPhi)<GapEfficiency)
        if ((maxGeomEff - FracDeadStripEta * FracDeadStripPhi) - GapEfficiency < -0.011) {
            ATH_MSG_DEBUG("Ineff. from dead strips on Eta/Phi Panels larger that measured EtaORPhi efficiency: deadFrac="
                          << FracDeadStripEta * FracDeadStripPhi << " EtaORPhi Eff=" << GapEfficiency << " for GasGap "
                          << m_idHelper->show_to_string(IdEta));
            ATH_MSG_DEBUG("... see the corresponding report among the warnings of RpcDetectorStatusDbTool");
            // GapEfficiency = 1.-FracDeadStripEta*FracDeadStripPhi;
            GapEfficiency = maxGeomEff - FracDeadStripEta * FracDeadStripPhi;
            changing = true;
        }
        if (changing)
            ATH_MSG_DEBUG("Rinormalized Values from Cool: FracDeadStripEta/Phi "
                          << FracDeadStripEta << "/" << FracDeadStripPhi << " RPC_ProjectedTracksEta " << RPC_ProjectedTracksEta
                          << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency << "/" << PhiPanelEfficiency << " gapEff " << GapEfficiency);
 
        // gabriele //..stefania - if there are dead strips renormalize the eff. to the active area
        if (m_kill_deadstrips) {
            if ((FracDeadStripEta > 0.0 && FracDeadStripEta < 1.0) || (FracDeadStripPhi > 0.0 && FracDeadStripPhi < 1.0) || (noEntryInDb)) {
                EtaPanelEfficiency = EtaPanelEfficiency / (maxGeomEff - FracDeadStripEta);
                PhiPanelEfficiency = PhiPanelEfficiency / (maxGeomEff - FracDeadStripPhi);
                GapEfficiency = GapEfficiency / (maxGeomEff - FracDeadStripEta * FracDeadStripPhi);
 
                if (EtaPanelEfficiency > maxGeomEff) EtaPanelEfficiency = maxGeomEff;
                if (PhiPanelEfficiency > maxGeomEff) PhiPanelEfficiency = maxGeomEff;
                if (GapEfficiency > maxGeomEff) GapEfficiency = maxGeomEff;
 
                if (EtaPanelEfficiency > GapEfficiency) GapEfficiency = EtaPanelEfficiency;
                if (PhiPanelEfficiency > GapEfficiency) GapEfficiency = PhiPanelEfficiency;
                ATH_MSG_DEBUG("Eff Redefined (to correct for deadfrac): FracDeadStripEta/Phi "
                              << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency << "/" << PhiPanelEfficiency << " gapEff "
                              << GapEfficiency);
            }
        }
 
        // values from COOLDB (eventually overwritten later)
        PhiAndEtaEff = float(EtaPanelEfficiency + PhiPanelEfficiency - GapEfficiency);
        if (PhiAndEtaEff < 0.) PhiAndEtaEff = 0.;
        OnlyEtaEff = float(EtaPanelEfficiency - PhiAndEtaEff);
        if (OnlyEtaEff < 0.) OnlyEtaEff = 0.;
        OnlyPhiEff = float(PhiPanelEfficiency - PhiAndEtaEff);
        if (OnlyPhiEff < 0.) OnlyPhiEff = 0.;
 
        //  special patch to be true only when m_Efficiency_fromCOOL=true and /RPC/DQMF/ELEMENT_STATUS tag is
        //  RPCDQMFElementStatus_2012_Jaunuary_26
        bool applySpecialPatch = false;
        if (m_EfficiencyPatchForBMShighEta && m_Efficiency_fromCOOL) {
            if (m_idHelper->stationName(IdEta) == 3)  
            {
                if (std::abs(m_idHelper->stationEta(IdEta)) == 6 && m_idHelper->doubletR(IdEta) == 1 &&
                    m_idHelper->doubletZ(IdEta) == 2 && m_idHelper->doubletPhi(IdEta) == 1) {
                    applySpecialPatch = true;
                    ATH_MSG_WARNING(
                        "Applying special patch for BMS at |eta|=6 lowPt plane -dbbZ=2 and dbPhi=1 ... will use default eff. for Id "
                        << m_idHelper->show_to_string(IdEta));
                    ATH_MSG_WARNING(
                        "Applying special patch: THIS HAS TO BE DONE IF /RPC/DQMF/ELEMENT_STATUS tag is "
                        "RPCDQMFElementStatus_2012_Jaunuary_2");
                }
            }
        }
 
        // if projected tracks number too low or inconsistent values get efficiencies from joboption and overwrite previous values
        if (applySpecialPatch || RPC_ProjectedTracksEta < m_CutProjectedTracks || RPC_ProjectedTracksEta > 10000000 ||
            EtaPanelEfficiency > 1 || EtaPanelEfficiency < 0 || PhiPanelEfficiency > 1 || PhiPanelEfficiency < 0 || GapEfficiency > 1 ||
            GapEfficiency < 0) {
            if (index > m_PhiAndEtaEff_A.size() || index > m_OnlyEtaEff_A.size() || index > m_OnlyPhiEff_A.size()) {
                THROW_EXCEPTION("Index out of array in Detection Efficiency SideA COOLDB" << index << " stationName = " << stationName);
            }
            if (RPC_ProjectedTracksEta < m_CutProjectedTracks)
                ATH_MSG_DEBUG("# of proj tracks = " << RPC_ProjectedTracksEta << " < cut = " << m_CutProjectedTracks
                                                    << " resetting eff. from cool with default(python) values ");
 
            PhiAndEtaEff = m_PhiAndEtaEff_A[index];
            OnlyEtaEff = m_OnlyEtaEff_A[index];
            OnlyPhiEff = m_OnlyPhiEff_A[index];
 
            if (stationEta < 0) {
                if (index > m_PhiAndEtaEff_C.size() || index > m_OnlyEtaEff_C.size() || index > m_OnlyPhiEff_C.size()) {
                    THROW_EXCEPTION("Index out of array in Detection Efficiency SideC COOLDB" << index << " stationName = " << stationName);
                }
                PhiAndEtaEff = m_PhiAndEtaEff_C[index];
                OnlyEtaEff = m_OnlyEtaEff_C[index];
                OnlyPhiEff = m_OnlyPhiEff_C[index];
            }
 
            // if (m_applyEffThreshold) {
            // gabriele Set efficiency from dead strip fraction instead of nominal value
            float effgap = PhiAndEtaEff + OnlyEtaEff + OnlyPhiEff;
            float s_EtaPanelEfficiency = 1. - FracDeadStripEta;
            float s_PhiPanelEfficiency = 1. - FracDeadStripPhi;
            float s_PhiAndEtaEff = s_EtaPanelEfficiency * s_PhiPanelEfficiency / effgap;
            if (s_PhiAndEtaEff < PhiAndEtaEff) PhiAndEtaEff = s_PhiAndEtaEff;
            float s_OnlyEtaEff = s_EtaPanelEfficiency - PhiAndEtaEff;
            float s_OnlyPhiEff = s_PhiPanelEfficiency - PhiAndEtaEff;
 
            if (s_OnlyEtaEff < OnlyEtaEff) OnlyEtaEff = s_OnlyEtaEff;
            if (s_OnlyPhiEff < OnlyPhiEff) OnlyPhiEff = s_OnlyPhiEff;
            //      }
        }
 
        float VolEff = PhiAndEtaEff + OnlyEtaEff + OnlyPhiEff;
        if (VolEff > maxGeomEff) {
            PhiAndEtaEff = (PhiAndEtaEff / VolEff) * maxGeomEff;
            OnlyEtaEff = (OnlyEtaEff / VolEff) * maxGeomEff;
            OnlyPhiEff = (OnlyPhiEff / VolEff) * maxGeomEff;
        }
 
    }  // End eff from COOL
 
    // Efficiency correction factor for fractional-charged particles(added by Quanyin Li: quli@cern.ch)
    // link to truth particles and calculate the charge and betagamma
    HepMC::ConstGenParticlePtr genparticle = trkParticle.cptr();
    if (genparticle) {
        // only apply efficiency correction to fractional-charged particles based on pdgId betagamma
        if (MC::isGenericMultichargedParticle(genparticle)) {
            const double eff_sf = FCPEfficiency(genparticle);
            // Apply scale factor to the 3 Eff.
            PhiAndEtaEff = PhiAndEtaEff * eff_sf;
            OnlyEtaEff = OnlyEtaEff * eff_sf;
            OnlyPhiEff = OnlyPhiEff * eff_sf;
        }
    }
 
    float I0 = PhiAndEtaEff;
    float I1 = PhiAndEtaEff + OnlyEtaEff;
    float ITot = PhiAndEtaEff + OnlyEtaEff + OnlyPhiEff;
 
    float GapEff = ITot ;
    float PhiEff = PhiAndEtaEff + OnlyPhiEff;
    float EtaEff = PhiAndEtaEff + OnlyEtaEff;
 
    ATH_MSG_DEBUG("DetectionEfficiency: Final Efficiency Values applied for "
                  << m_idHelper->show_to_string(IdEta) << " are " << PhiAndEtaEff << "=PhiAndEtaEff " << OnlyEtaEff
                  << "=OnlyEtaEff " << OnlyPhiEff << "=OnlyPhiEff " << GapEff << "=GapEff " << EtaEff << "=EtaEff " << PhiEff
                  << "=PhiEff ");
 
    float rndmEff = CLHEP::RandFlat::shoot(rndmEngine, 1);
 
    if (rndmEff < I0) {
        phiStripOn = true;
        etaStripOn = true;
    } else if ((I0 <= rndmEff) && (rndmEff < I1)) {
        phiStripOn = false;
        etaStripOn = true;
    } else if ((I1 <= rndmEff) && (rndmEff <= ITot)) {
        phiStripOn = true;
        etaStripOn = false;
    } else {
        phiStripOn = false;
        etaStripOn = false;
    }
 
    return std::make_pair(etaStripOn, phiStripOn);
}

determineClusterSize()

int RpcDigitizationTool::determineClusterSize ( const EventContext & ctx, const Identifier & id, double xstripnorm, CLHEP::HepRandomEngine * rndmEngine ) const

private

Definition at line 1377 of file RpcDigitizationTool.cxx.

                                                                                      {
    ATH_MSG_DEBUG("RpcDigitizationTool::in determineClusterSize");
 
    ATH_MSG_DEBUG("Digit Id = " << m_idHelper->show_to_string(idRpcStrip));
 
    int ClusterSize = 1;
 
    double FracClusterSize1{1.}, FracClusterSize2{0.}, MeanClusterSize{1.}, 
          FracClusterSizeTail{0.}, MeanClusterSizeTail{1.},
          FracClusterSize2norm{0.};
 
    // 2=BML,3=BMS,4=BOL,5=BOS,8=BMF,9=BOF,10=BOG
    int stationName = m_idHelper->stationName(idRpcStrip);
    int stationEta = m_idHelper->stationEta(idRpcStrip);
    int measuresPhi = m_idHelper->measuresPhi(idRpcStrip);
 
    unsigned int index = stationName - 2;
    // BML and BMS, BOL and BOS  come first (stationName= 2 and 3, 4 and 5 -> index 0-3)
    if (stationName > 5 && stationName < 50) index = index - 2;
    // BMF, BOF and BOG are 8,9,10 => must be 4,5 and 6
    else if (stationName > 50)
        index = index - 44;
    // BME and BOE 53 and 54 are at indices 7 and 8
 
    if (!m_ClusterSize_fromCOOL && stationName >= 2) {
        index += m_FracClusterSize1_A.size() / 2 * measuresPhi;
        if (index >= m_FracClusterSize1_A.size() || 
            index >= m_FracClusterSize2_A.size() || 
            index >= m_FracClusterSizeTail_A.size() ||
            index >= m_MeanClusterSizeTail_A.size()) {
            ATH_MSG_ERROR("Index out of array in determineClusterSize SideA " << index << " statName " << stationName);
            return 1;
        }
        FracClusterSize1 = m_FracClusterSize1_A[index];
        FracClusterSize2 = m_FracClusterSize2_A[index];
        FracClusterSizeTail = m_FracClusterSizeTail_A[index];
        MeanClusterSizeTail = m_MeanClusterSizeTail_A[index];
 
        if (stationEta < 0) {
            index += m_FracClusterSize1_C.size() / 2 * measuresPhi - m_FracClusterSize1_A.size() / 2 * measuresPhi;
            if (index >= m_FracClusterSize1_C.size() || 
                index >= m_FracClusterSize2_C.size() || 
                index >= m_FracClusterSizeTail_C.size() ||
                index >= m_MeanClusterSizeTail_C.size()) {
                ATH_MSG_ERROR("Index out of array in determineClusterSize SideC " << index << " statName " << stationName);
                return 1;
            }
            FracClusterSize1 = m_FracClusterSize1_C[index];
            FracClusterSize2 = m_FracClusterSize2_C[index];
            FracClusterSizeTail = m_FracClusterSizeTail_C[index];
            MeanClusterSizeTail = m_MeanClusterSizeTail_C[index];
        }
    } else if (stationName < 2 && (!m_ClusterSize_fromCOOL || !m_ClusterSize_BIS78_fromCOOL)) {  // BIS78
        FracClusterSize1 = m_FracClusterSize1_BIS78;
        FracClusterSize2 = m_FracClusterSize2_BIS78;
        FracClusterSizeTail = m_FracClusterSizeTail_BIS78;
        MeanClusterSizeTail = m_MeanClusterSizeTail_BIS78;
    } else {  // Cluster size from COOL
        const RpcCondDbData* readCdo{nullptr};                        
        retrieveCondData(ctx, m_readKey, readCdo).ignore();
 
        Identifier Id = m_idHelper->panelID(idRpcStrip);
 
        int RPC_ProjectedTracks = readCdo->getProjectedTrack(Id).value_or(0);
        FracClusterSize1 = readCdo->getFracClusterSize1(Id).value_or(1.);
        FracClusterSize2 = readCdo->getFracClusterSize2(Id).value_or(0.);
        MeanClusterSize = readCdo->getMeanClusterSize(Id).value_or(1.);
 
      
        ATH_MSG_DEBUG("FracClusterSize1 and 2 " << FracClusterSize1 << " " << FracClusterSize2);
 
        FracClusterSizeTail = 1. - FracClusterSize1 - FracClusterSize2;
 
        MeanClusterSizeTail = MeanClusterSize - FracClusterSize1 - 2 * FracClusterSize2;
 
        ATH_MSG_DEBUG("MeanClusterSizeTail and FracClusterSizeTail " << MeanClusterSizeTail << " " << FracClusterSizeTail);
 
        // if clustersize have anomalous values set to the average cluster size from joboption
        if (RPC_ProjectedTracks < m_CutProjectedTracks || RPC_ProjectedTracks > 10000000 || MeanClusterSize > m_CutMaxClusterSize ||
            MeanClusterSize <= 1 || FracClusterSizeTail < 0 || FracClusterSize1 < 0 || FracClusterSize2 < 0 || FracClusterSizeTail > 1 ||
            FracClusterSize1 > 1 || FracClusterSize2 > 1) {
            if (stationName >= 2) {
                index += m_FracClusterSize1_A.size() / 2 * measuresPhi;
                if (index >= m_FracClusterSize1_A.size() || 
                    index >= m_FracClusterSize2_A.size() || 
                    index >= m_FracClusterSizeTail_A.size() ||
                    index >= m_MeanClusterSizeTail_A.size()) {
                    ATH_MSG_ERROR("Index out of array in determineClusterSize SideA " << index << " statName " << stationName);
                    return 1;
                }
                FracClusterSize1 = m_FracClusterSize1_A[index];
                FracClusterSize2 = m_FracClusterSize2_A[index];
                FracClusterSizeTail = m_FracClusterSizeTail_A[index];
                MeanClusterSizeTail = m_MeanClusterSizeTail_A[index];
 
                if (stationEta < 0) {
                    index += m_FracClusterSize1_C.size() / 2 * measuresPhi - m_FracClusterSize1_A.size() / 2 * measuresPhi;
                    if (index > m_FracClusterSize1_C.size() || index > m_FracClusterSize2_C.size() ||
                        index > m_FracClusterSizeTail_C.size() || index > m_MeanClusterSizeTail_C.size()) {
                        ATH_MSG_ERROR("Index out of array in determineClusterSize SideC " << index << " statName " << stationName);
                        return 1;
                    }
 
                    FracClusterSize1 = m_FracClusterSize1_C[index];
                    FracClusterSize2 = m_FracClusterSize2_C[index];
                    FracClusterSizeTail = m_FracClusterSizeTail_C[index];
                    MeanClusterSizeTail = m_MeanClusterSizeTail_C[index];
                }
            } else {
                FracClusterSize1 = m_FracClusterSize1_BIS78;
                FracClusterSize2 = m_FracClusterSize2_BIS78;
                FracClusterSizeTail = m_FracClusterSizeTail_BIS78;
                MeanClusterSizeTail = m_MeanClusterSizeTail_BIS78;
            }
        }
    }
    FracClusterSize1 = std::min(FracClusterSize1, 1.);
    FracClusterSize2 = std::min(FracClusterSize2, 1.);
    FracClusterSizeTail = std::min(FracClusterSizeTail, 1.);
    float FracTot = FracClusterSize1 + FracClusterSize2 + FracClusterSizeTail;
    if (FracTot != 1. && FracTot > 0) {
        FracClusterSize1 = FracClusterSize1 / FracTot;
        FracClusterSize2 = FracClusterSize2 / FracTot;
        FracClusterSizeTail = FracClusterSizeTail / FracTot;
    }
    if (MeanClusterSizeTail < 0 || MeanClusterSizeTail > 10) MeanClusterSizeTail = 1;
 
    ATH_MSG_VERBOSE("ClusterSize Final " << FracClusterSize1 << " FracClusterSize1 " << FracClusterSize2 << " FracClusterSize2  "
                                         << FracClusterSizeTail << "   " << FracClusterSizeTail << " MeanClusterSizeTail  "
                                         << MeanClusterSizeTail);
 
    float FracClusterSize1plus2 = FracClusterSize1 + FracClusterSize2;
    float ITot = FracClusterSize1 + FracClusterSize2 + FracClusterSizeTail;
 
    if (FracClusterSize1plus2 != 0) {
        // FracClusterSize1norm = FracClusterSize1 / FracClusterSize1plus2 ; // not used
        FracClusterSize2norm = FracClusterSize2 / FracClusterSize1plus2;
    }
 
    float rndmCS = CLHEP::RandFlat::shoot(rndmEngine, ITot);
 
    if (stationName >= 2) {  // Legacy RPCs
        // Expanded CS2 of 1.3 to match average CS1 and CS2 (to be investigate)
        if (rndmCS < FracClusterSize1plus2) {
            // deterministic assignment of CS 1 or 2
            if (xstripnorm <= FracClusterSize2norm / 2. * 1.3) {
                ClusterSize = -2;
            } else if ((1.0 - FracClusterSize2norm / 2. * 1.3) <= xstripnorm) {
                ClusterSize = 2;
            } else {
                ClusterSize = 1;
            }
            if (m_ClusterSize1_2uncorr) {
                float rndmCS1_2 = CLHEP::RandFlat::shoot(rndmEngine, 1);
                ClusterSize = 1 + (rndmCS1_2 < FracClusterSize2norm);
            }
 
        } else if ((FracClusterSize1plus2 <= rndmCS) && (rndmCS <= ITot)) {
            ClusterSize = m_FirstClusterSizeInTail;
            ClusterSize += int(CLHEP::RandExponential::shoot(rndmEngine, MeanClusterSizeTail));
            float rndmLR = CLHEP::RandFlat::shoot(rndmEngine, 1.0);
            if (rndmLR > 0.5) ClusterSize = -ClusterSize;
        } else {
            ClusterSize = 1;
        }
 
    } else {  // NRPCs
        if (rndmCS < FracClusterSize1) {
            ClusterSize = 1;
        } else if (rndmCS < FracClusterSize1 + FracClusterSize2) {
            ClusterSize = 2;
        } else {
            ClusterSize = int(CLHEP::RandExponential::shoot(rndmEngine, MeanClusterSizeTail));
        }
        ClusterSize = std::max(ClusterSize, 1);
        if (ClusterSize > 1) {
            float rndmLR = CLHEP::RandFlat::shoot(rndmEngine, 1.0);
            if (rndmLR > 0.5) ClusterSize = -ClusterSize;
        }
    }
 
    // negative CS correspond to left asymmetric cluster with respect to nstrip
    return ClusterSize;
}

doDigitization()

StatusCode RpcDigitizationTool::doDigitization ( const EventContext & ctx, Collections_t & collections, MuonSimDataCollection * sdoContainer )

private

Digitization functionality shared with RPC_PileUpTool.

Let's pray that we will never discover that BIS78 is mounted upside down

Use special jitter consant for BIS & BIL chambers.

If a jitter constant has been defined smear it!

Definition at line 484 of file RpcDigitizationTool.cxx.

                                                                                    {
    ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
    rngWrapper->setSeed(name(), ctx);
    CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);
 
    const MuonGM::MuonDetectorManager* detMgr{nullptr};
    ATH_CHECK(retrieveCondData(ctx, m_detMgrKey, detMgr));
 
 
    std::unique_ptr<RPCSimHitCollection> inputSimHitColl{std::make_unique<RPCSimHitCollection>("RPC_Hits")};
 
 
    // get the iterator pairs for this DetEl
    // iterate over hits
    TimedHitCollection<RPCSimHit>::const_iterator i, e;
 
    // Perform null check on m_thpcRPC
    if (!m_thpcRPC) {
        ATH_MSG_ERROR("m_thpcRPC is null");
        return StatusCode::FAILURE;
    }
 
    struct SimDataContent {
        Identifier channelId{};
        std::vector<MuonSimData::Deposit> deposits;
        Amg::Vector3D gpos{Amg::Vector3D::Zero()};
        double simTime{0.};
    };
 
    while (m_thpcRPC->nextDetectorElement(i, e)) {
        // to store the a single
 
        std::map<Identifier, SimDataContent> channelSimDataMap;
 
        // Loop over the hits:
        while (i != e) {
            ATH_MSG_DEBUG("RpcDigitizationTool::loop over the hits");
 
            TimedHitPtr<RPCSimHit> phit(*i++);
 
            // the hit
            const RPCSimHit& hit(*phit);
            // the hit id
            const int idHit = hit.RPCid();
            // the global time (G4 time + bunch time)
            const double globalHitTime{hitTime(phit)};
            // the G4 time or TOF from IP
            const double G4Time{hit.globalTime()};
            // the bunch time
            const double bunchTime{globalHitTime - hit.globalTime()};
 
            ATH_MSG_DEBUG("Global time " << globalHitTime << " G4 time " << G4Time << " Bunch time " << bunchTime);
 
            if (!m_simHitValidKey.empty()) {
                ATH_MSG_VERBOSE("Validation:  globalHitTime, G4Time, BCtime = " << globalHitTime << " " << G4Time << " " << bunchTime);
                inputSimHitColl->Emplace(idHit, globalHitTime, hit.localPosition(),
                                         HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx), // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
                                         hit.postLocalPosition(),
                                         hit.energyDeposit(), hit.stepLength(), hit.particleEncoding(), hit.kineticEnergy());
            }
 
            // convert sim id helper to offline id
            const std::string stationName = m_muonHelper->GetStationName(idHit);
            const int stationEta = m_muonHelper->GetZSector(idHit);
            const int stationPhi = m_muonHelper->GetPhiSector(idHit);
            const int doubletR = m_muonHelper->GetDoubletR(idHit);
            const int doubletZ = m_muonHelper->GetDoubletZ(idHit);
            const int doubletPhi = m_muonHelper->GetDoubletPhi(idHit);
            int gasGap = m_muonHelper->GetGasGapLayer(idHit);
            
            if (m_muonHelper->GetMeasuresPhi(idHit)) continue;  // Skip phi strip . To be created after efficiency evaluation
 
 
            bool isValid{false};
            const Identifier elementID = m_idHelper->elementID(stationName,stationEta,stationPhi,doubletR, isValid);
            if (!isValid) {
                ATH_MSG_WARNING("Failed to construct the element ID from "<<stationName
                            <<", stationEta: "<<stationEta<<", stationPhi: "<<stationPhi<<", doubletR: "<<doubletR);
                continue;
            }
            // construct Atlas identifier from components
            ATH_MSG_DEBUG("creating id for hit in element:"
                          << " stationName " << stationName << " stationEta " << stationEta << " stationPhi " << stationPhi << " doubletR "
                          << doubletR << " doubletZ " << doubletZ << " doubletPhi " << doubletPhi << " gasGap " << gasGap);
            const Identifier detElId{m_idHelper->channelID(elementID, doubletZ, doubletPhi, 1,0, 1, isValid)};
            if (!isValid) {
                continue;
            }
            const RpcReadoutElement* reEle = detMgr->getRpcReadoutElement(detElId);
            if (false && reEle->rotatedRpcModule()) {
                gasGap = gasGap == 1 ? 2 : 1;
            } 
 
            
            bool isValidEta{false}, isValidPhi{false};
            const Identifier idpaneleta = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 0, 1, isValidEta);
            const Identifier idpanelphi = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 1, 1, isValidPhi);
            if (!isValidEta || !isValidPhi) {
                ATH_MSG_WARNING("Found an invalid identifier "
                                << " stationName " << stationName << " stationEta " << stationEta << " stationPhi " << stationPhi
                                << " doubletR " << doubletR << " doubletZ " << doubletZ << " doubletPhi " << doubletPhi << " gasGap "
                                << gasGap);
                continue;
            }
            // loop on eta and phi to apply correlated efficiency between the two views

            const double tmp_CorrJitter = m_idHelper->stationName(idpaneleta) < 2 ? m_CorrJitter_BIS78 : m_CorrJitter;
            const double corrtimejitter = tmp_CorrJitter > 0.01 ? 
                                                CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0., tmp_CorrJitter) : 0.;  // correlated jitter
            // handle here the special case where eta panel is dead => phi strip status (dead or eff.) cannot be resolved;
            // measured panel eff. will be used in that case and no phi strip killing will happen
 
 
            // Extrapolate the hit to the gas gap centre located at x=0 
            const Amg::Vector3D hitDir{(hit.postLocalPosition() - hit.localPosition()).unit()};
            const Amg::Vector3D gapCentre = hit.localPosition() + 
                                            Amg::intersect<3>(hit.localPosition(), hitDir, Amg::Vector3D::UnitX(), 0).value_or(0) * hitDir;
 
            std::array<int, 3> pcseta = physicalClusterSize(ctx, reEle, idpaneleta, gapCentre, rndmEngine);  // set to one for new algorithms
            ATH_MSG_VERBOSE("Simulated cluster on eta panel: size/first/last= " << pcseta[0] << "/" << pcseta[1] << "/" << pcseta[2]);
            std::array<int, 3> pcsphi = physicalClusterSize(ctx, reEle, idpanelphi, gapCentre, rndmEngine);  // set to one for new algorithms
            ATH_MSG_VERBOSE("Simulated cluster on phi panel: size/first/last= " << pcsphi[0] << "/" << pcsphi[1] << "/" << pcsphi[2]);
 
            
 
            // create Identifiers
            const Identifier atlasRpcIdeta = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 0, pcseta[1], isValidEta);
            const Identifier atlasRpcIdphi = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 1, pcsphi[1], isValidPhi);
 
            const HepMcParticleLink particleLink = HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
            const auto [etaStripOn, phiStripOn] = detectionEfficiency(ctx, idpaneleta, idpanelphi, rndmEngine, particleLink);
            ATH_MSG_DEBUG("SetPhiOn " << phiStripOn << " SetEtaOn " << etaStripOn);
 
            for (bool  imeasphi : {false, true}) {
                if (!imeasphi &&  (!etaStripOn || !isValidEta)) continue;
                if (imeasphi && (!phiStripOn || !isValidPhi)) continue;
 
 
                // get Identifier and list of clusters for this projection
                const Identifier& atlasId = !imeasphi ? atlasRpcIdeta : atlasRpcIdphi;
                std::array<int, 3> pcs{!imeasphi ? pcseta : pcsphi};
 
                ATH_MSG_DEBUG("SetOn: stationName " << stationName << " stationEta " << stationEta << " stationPhi " << stationPhi
                                                    << " doubletR " << doubletR << " doubletZ " << doubletZ << " doubletPhi " << doubletPhi
                                                    << " gasGap " << gasGap << " measphi " << imeasphi);
 
                // pcs contains the cluster size, the first strip number and the last strip number of the cluster
                pcs = TurnOnStrips(reEle, std::move(pcs), atlasId);
                if (pcs[2] < 0){
                    continue;
                } 
 
                ATH_MSG_DEBUG("Simulated cluster1: size/first/last= " << pcs[0] << "/" << pcs[1] << "/" << pcs[2]);
 
                
                const Amg::Vector3D pos = fromSimHitToLayer(reEle, atlasId) * hit.localPosition();
                const Amg::Vector3D gpos = reEle->transform(atlasId) * pos;
                
                ATH_MSG_VERBOSE(" evt: "<<ctx.eventID().event_number()
                                <<" hit  "<<m_idHelper->print_to_string(atlasId)
                                <<" local simHit "<<Amg::toString(hit.localPosition())
                                <<" corrected: "<<Amg::toString(pos)
                                <<" transform: "<<GeoTrf::toString(fromSimHitToLayer(reEle, atlasId))
                                <<" local strip: "<<Amg::toString(reEle->localToGlobalTransf(atlasId).inverse()*reEle->stripPos(atlasId))
                                <<" local strip (II): "<<Amg::toString(reEle->transform(atlasId).inverse()*reEle->stripPos(atlasId))
                                <<" global: "<<Amg::toString(gpos)
                                <<" strip Pos: "<<Amg::toString(reEle->stripPos(atlasId)));
 
                // Calculate propagation time along readout strip in seconds
                double proptime = PropagationTime(reEle, atlasId, gpos);
 
                double tns = G4Time + proptime + corrtimejitter;  // the time is in nanoseconds
                ATH_MSG_VERBOSE("TOF+propagation time  " << tns << " /s where proptime " << proptime << "/s");
 
                double time = tns + bunchTime;
                ATH_MSG_VERBOSE("final time in ns: BC+TOF+prop " << time << " /ns");
 
                // pack propagation time along strip, bunch time and local hit position
                long long int packedMCword = PackMCTruth(proptime, bunchTime, pos.y(), pos.z());
                //cppcheck-suppress invalidPointerCast
                double* b = reinterpret_cast<double*>(&packedMCword);

                // create here deposit for MuonSimData
                // MuonMCData first  word is the packing of    : proptime, bunchTime, posy, posz
                // MuonMCData second word is the total hit time: bunchcTime+tof+proptime+correlatedJitter / ns
                MuonSimData::Deposit deposit(particleLink, MuonMCData((*b), time));  // store tof+strip_propagation+corr.jitter
                //                     MuonMCData((*b),G4Time+bunchTime+proptime          )); // store tof+strip_propagation
 
                // Do not store pile-up truth information
                if (m_includePileUpTruth || !HepMC::ignoreTruthLink(phit->particleLink(), m_vetoPileUpTruthLinks)) {
                  if (std::abs(hit.particleEncoding()) == 13 || hit.particleEncoding() == 0) {
                    if (channelSimDataMap.find(atlasId) == channelSimDataMap.end()) {
                      SimDataContent& content = channelSimDataMap[atlasId];
                      content.channelId = atlasId;
                      content.deposits.push_back(deposit);
                      content.gpos =  reEle->transform(atlasId)* 
                                      fromSimHitToLayer(reEle,atlasId) * gapCentre;
                      content.simTime = hitTime(phit);
                      ATH_MSG_VERBOSE("adding SDO entry: r " << content.gpos.perp() << " z " << content.gpos.z());
                    }
                  }
                }
 
 
                //---------------------------------------------------------------------
                // construct new digit and store it in the respective digit collection
                // --------------------------------------------------------------------
 
                // we create one digit-vector/deposit for each strip in the cluster
                bool isValid{false};
                for (int clus = pcs[1]; clus <= pcs[2]; ++clus) {
                    Identifier newId = m_idHelper->channelID(stationName, stationEta, stationPhi, doubletR, doubletZ,
                                                             doubletPhi, gasGap, imeasphi, clus, isValid);
                    if (!isValid) {
                        ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<< "Channel "<< stationName<<" "<<stationEta<<" "<<stationPhi<<" "<< doubletR<<" "<<doubletZ
                                        <<" "<< doubletPhi<<" "<< gasGap <<" "<< imeasphi<<" "<< clus<<" is invalid");
                        continue;
                    }
                    
                    if (!m_idHelper->valid(newId)) {
                        if (stationName.find("BI") != std::string::npos) {
                            ATH_MSG_WARNING("Temporary skipping creation of RPC digit for stationName="
                                            << stationName << ", eta=" << stationEta << ", phi=" << stationPhi << ", doubletR=" << doubletR
                                            << ", doubletZ=" << doubletZ << ", doubletPhi=" << doubletPhi << ", gasGap=" << gasGap
                                            << ", measuresPhi=" << imeasphi << ", strip=" << clus << ", cf. ATLASRECTS-6124");
                            return StatusCode::SUCCESS;
                        } else {
                            ATH_MSG_ERROR("Created an invalid id, aborting!");
                            m_idHelper->print(newId);
                            return StatusCode::FAILURE;
                        }
                    }

                    // One identifier but several deposits // name m_sdo_tmp_map is wrong call it m_sdo_map
                    if (m_sdo_tmp_map.find(newId) == m_sdo_tmp_map.end()) {
                        std::vector<MuonSimData::Deposit> newdeps;
                        newdeps.push_back(deposit);
                        m_sdo_tmp_map.insert(std::map<Identifier, std::vector<MuonSimData::Deposit>>::value_type(newId, newdeps));
                    } else {
                        m_sdo_tmp_map[newId].push_back(deposit);
                    }
                }  // end for cluster
            }      // loop on eta and phi
        }          // end loop hits
 
        if (m_muonOnlySDOs) {
            for (auto it = channelSimDataMap.begin(); it != channelSimDataMap.end(); ++it) {
                MuonSimData simData(it->second.deposits, 0);
                simData.setPosition(it->second.gpos);
                simData.setTime(it->second.simTime);
                auto insertResult = sdoContainer->insert(std::make_pair(it->first, simData));
                if (!insertResult.second)
                    ATH_MSG_WARNING("Attention: this sdo is not recorded, since the identifier already exists in the sdoContainer map");
            }
        }
 
    }  // end loop detector elements

 
    std::map<Identifier, std::vector<MuonSimData::Deposit>>::iterator map_iter = m_sdo_tmp_map.begin();
    ATH_MSG_DEBUG("Start the digit map loop");
 
    for (; map_iter != m_sdo_tmp_map.end(); ++map_iter) {
        // Identifier
        const Identifier theId = (*map_iter).first;
        ATH_MSG_DEBUG("in the map loop: id " << m_idHelper->show_to_string(theId));
        // Deposit
        const std::vector<MuonSimData::Deposit> theDeps = (*map_iter).second;
 
        // store the SDO from the muon
        MuonSimData::Deposit theMuon;                       // useful beacuse it sorts the digits in ascending time.
        std::multimap<double, MuonSimData::Deposit> times;  // extract here time info from deposits.
 
        // loop on the vector deposit
        for (unsigned int k = 0; k < theDeps.size(); k++) {
            double time = theDeps[k].second.secondEntry();
            times.insert(std::multimap<double, MuonSimData::Deposit>::value_type(time, theDeps[k]));
        }
 
        // now iterate again over the multimap entries and store digits after dead time applied
 
        IdContext rpcContext = m_idHelper->module_context();  // work on chamber context
 
        std::multimap<double, MuonSimData::Deposit>::iterator map_dep_iter = times.begin();
 
        // loop to suppress digits too close in time (emulate Front-End and CMA dead time)
        double last_time = -10000;  // init to high value
        for (; map_dep_iter != times.end(); ++map_dep_iter) {
            double currTime = (*map_dep_iter).first;
            ATH_MSG_VERBOSE("deposit with time " << currTime);
 
            if (!m_muonOnlySDOs && !m_sdoAreOnlyDigits) {
                // store (before any cut: all G4 hits) in the SDO container
                // Identifier sdo and digit are the same
                if (sdoContainer->find(theId) != sdoContainer->end())  // Identifier exist -> increase deposit
                {
                    std::map<Identifier, MuonSimData>::const_iterator it = sdoContainer->find(theId);
                    std::vector<MuonSimData::Deposit> deps = ((*it).second).getdeposits();
                    deps.push_back((*map_dep_iter).second);
                } else  // Identifier does not exist -> create (Id,deposit)
                {
                    std::vector<MuonSimData::Deposit> deposits;
                    deposits.push_back((*map_dep_iter).second);
                    std::pair<std::map<Identifier, MuonSimData>::iterator, bool> insertResult =
                        sdoContainer->insert(std::make_pair(theId, MuonSimData(deposits, 0)));
                    if (!insertResult.second)
                        ATH_MSG_ERROR(
                            "Attention TEMP: this sdo is not recorded, since the identifier already exists in the sdoContainer map");
                }
            }
            // apply dead time
            if (std::abs(currTime - last_time) > (m_deadTime)) {
                ATH_MSG_DEBUG("deposit with time " << currTime << " is distant enough from previous (if any) hit on teh same strip");
                last_time = (*map_dep_iter).first;
 
                // first add time jitter to the time:
                double uncorrjitter = 0;
                double tmp_UncorrJitter = m_UncorrJitter;
                if (m_idHelper->stationName(theId) < 2) tmp_UncorrJitter = m_UncorrJitter_BIS78;
                if (tmp_UncorrJitter > 0.01) uncorrjitter = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0., tmp_UncorrJitter);
                // Historically patch for the cavern background
                // Now we subtract TOF from IP to assume full time calibrated detector (t=0 for particle from IP at light speed)
                // We add a time shift to emulate FE global offset
 
                const RpcReadoutElement* ele = detMgr->getRpcReadoutElement(theId);
                Amg::Vector3D posi = ele->stripPos(theId);
                double tp = m_patch_for_rpc_time ? posi.mag() / Gaudi::Units::c_light : 0.;
                // Calculate propagation time for a hit at the center of the strip, to be subtructed as well as the nominal TOF
                double propTimeFromStripCenter = PropagationTime(ele, theId, posi);
                double newDigit_time = currTime + uncorrjitter + m_rpc_time_shift - tp - propTimeFromStripCenter;
        
                double digi_ToT = -1.;  // Time over threshold, for Narrow-gap RPCs only
                if (m_idHelper->stationName(theId) < 2) digi_ToT = timeOverThreshold(rndmEngine);  //mn 
 
                ATH_MSG_VERBOSE("last_time=currTime " << last_time << " jitter " << uncorrjitter << " TOFcorrection " << tp << " shift "
                                                      << m_rpc_time_shift << "  newDigit_time " << newDigit_time);
 
                // Apply readout window (sensitive detector time window)
                bool outsideDigitizationWindow = outsideWindow(newDigit_time);
                if (outsideDigitizationWindow) {
                    ATH_MSG_VERBOSE("hit outside digitization window - do not produce digits");
                    ATH_MSG_DEBUG("Hit outside time window!!"
                                  << " hit time (ns) = " << newDigit_time << " timeWindow  = " << m_timeWindowLowerOffset << " / "
                                  << m_timeWindowUpperOffset);
 
                    continue;
                }
                // ok, let's store this digit
                // this is an accepted hit to become digit
                last_time = (*map_dep_iter).first;
 
                std::unique_ptr<RpcDigit> newDigit = std::make_unique<RpcDigit>(theId, newDigit_time, digi_ToT, false);  
                
                Identifier elemId = m_idHelper->elementID(theId);
                RpcDigitCollection* digitCollection = nullptr;
 
                IdentifierHash coll_hash;
                if (m_idHelper->get_hash(elemId, coll_hash, &rpcContext)) {
                    ATH_MSG_ERROR("Unable to get RPC hash id from RPC Digit collection "
                                  << "context begin_index = " << rpcContext.begin_index()
                                  << " context end_index  = " << rpcContext.end_index() << " the identifier is \n"<<elemId);
                }
 
                // make new digit
                ATH_MSG_DEBUG("Digit Id = " << m_idHelper->show_to_string(theId) << " digit time " << newDigit_time);
 
                // remember new collection.
                if (coll_hash >= collections.size()) {
                  collections.resize (coll_hash+1);
                }
                digitCollection = collections[coll_hash].get();
                if (!digitCollection) {
                    collections[coll_hash] = std::make_unique<RpcDigitCollection>(elemId, coll_hash);
                    digitCollection = collections[coll_hash].get();
                }
                digitCollection->push_back(std::move(newDigit));
 
                if (!m_muonOnlySDOs && m_sdoAreOnlyDigits) {
                    // put SDO collection in StoreGate
                    if (sdoContainer->find(theId) != sdoContainer->end()) {
                        std::map<Identifier, MuonSimData>::const_iterator it = sdoContainer->find(theId);
                        std::vector<MuonSimData::Deposit> deps = ((*it).second).getdeposits();
                        deps.push_back((*map_dep_iter).second);
                    } else {
                        std::vector<MuonSimData::Deposit> deposits;
                        deposits.push_back((*map_dep_iter).second);
                        std::pair<std::map<Identifier, MuonSimData>::iterator, bool> insertResult =
                            sdoContainer->insert(std::make_pair(theId, MuonSimData(deposits, 0)));
                        if (!insertResult.second)
                            ATH_MSG_ERROR(
                                "Attention: this sdo is not recorded, since teh identifier already exists in the sdoContainer map");
                    }
                }
 
            } else
                ATH_MSG_DEBUG("discarding digit due to dead time: " << (*map_dep_iter).first << " " << last_time);
        }
 
    }  // loop to suppress digits too close in time ended
 
    // reset the pointer if it not null
    m_thpcRPC.reset();
    if (!m_simHitValidKey.empty()) {
        SG::WriteHandle<RPCSimHitCollection> validHandle{m_simHitValidKey, ctx};
        ATH_CHECK(validHandle.record(std::move(inputSimHitColl)));
    }
 
    return StatusCode::SUCCESS;
}

FCPEfficiency()

double RpcDigitizationTool::FCPEfficiency ( const HepMC::ConstGenParticlePtr & genParticle ) const

private

Definition at line 1564 of file RpcDigitizationTool.cxx.

                                                                                           {
    double qcharge = 1.;
    const int particlePdgId = genParticle->pdg_id();
    // charge calculation
    qcharge = (static_cast<double>((std::abs(particlePdgId) / 1000) % 100)) / (static_cast<double>((std::abs(particlePdgId) / 10) % 100));
    qcharge = ((static_cast<double>((static_cast<int>(qcharge * 100))))) / 100;
    if (particlePdgId < 0.0) qcharge = -qcharge;
    // BetaGamma calculation
    const double QPx = genParticle->momentum().px();
    const double QPy = genParticle->momentum().py();
    const double QPz = genParticle->momentum().pz();
    const double QE = genParticle->momentum().e();
    const double QM2 = std::pow(QE, 2) - std::pow(QPx, 2) - std::pow(QPy, 2) - std::pow(QPz, 2);
    const double QP = std::hypot(QPx, QPy, QPz);
    const double QM  = QM2 >=0 ? std::sqrt(QM2) : -1.;
 
    const double qbetagamma = QM > 0. ? QP / QM :  -1.;
 
    // find the i in the array
    int i_e = -1;
    for (int i = 0; i < 12; i++) {
        if (Charge[i] == std::abs(qcharge)) {
            i_e = i;
            break;
        }
    }
    int i_v = -99, j_v = 99;
    if (qbetagamma != -1) {
        for (int i = 0; i < 15; i++) {
            if (Velocity[i] <= qbetagamma) { i_v = i; }
        }
        for (int i = 14; i >= 0; i--) {
            if (Velocity[i] >= qbetagamma) { j_v = i; }
        }
    }
    // calculate the efficiency according to charge and velocity. Using linear function to calculate efficiency of a specific velocity
    // between velocity1 and velocity2
    double eff_fcp = 1.0, eff_muon = 1.0;
    if (i_e >= 0 && i_e <= 11) {
        if (validIndex(j_v, N_Velocity) && validIndex(i_v, N_Velocity) && (j_v - i_v) == 1) {
            const double delta_v = Velocity[i_v] - Velocity[j_v];
            eff_fcp = (Eff_garfield[i_e][i_v] - Eff_garfield[i_e][j_v]) / delta_v * qbetagamma +
                      (Eff_garfield[i_e][j_v] * Velocity[i_v] - Eff_garfield[i_e][i_v] * Velocity[j_v]) / delta_v;
            eff_muon = (Eff_garfield[11][i_v] - Eff_garfield[11][j_v]) / delta_v * qbetagamma +
                       (Eff_garfield[11][j_v] * Velocity[i_v] - Eff_garfield[11][i_v] * Velocity[j_v]) / delta_v;
        } else if (i_v == 14 && j_v == 99) {
            eff_fcp = Eff_garfield[i_e][14];
            eff_muon = Eff_garfield[11][14];
        } else if (i_v == -99 && j_v == 0) {
            eff_fcp = Eff_garfield[i_e][0];
            eff_muon = Eff_garfield[11][0];
        } else {
            ATH_MSG_WARNING("Wrong particle with unknown velocity! Scale factor is set to be 1.");
        }
    } else {
        ATH_MSG_WARNING("Wrong particle with unknown charge! Scale factor is set to be 1.");
    }
    // A scale factor is calculated by efficiency of fcp / efficiency of muon(charge==1.0
    const double eff_SF = eff_fcp / eff_muon;
    return eff_SF;
}

fillTagInfo()

StatusCode RpcDigitizationTool::fillTagInfo ( )

private

Definition at line 1062 of file RpcDigitizationTool.cxx.

                                            {
    // get TagInfoMgr
    SmartIF<ITagInfoMgr> tagInfoMgr{Gaudi::svcLocator()->service("TagInfoMgr")};  // Tag Info Manager
    if (!tagInfoMgr) { return StatusCode::FAILURE; }
 
    std::string RpctimeSchema = "";
    std::stringstream RpctimeShift;
    RpctimeShift << (int)m_rpc_time_shift;
 
    if (m_patch_for_rpc_time) {
        RpctimeSchema = "Datalike_TOFoff_TimeShift" + RpctimeShift.str() + "nsec";
    } else {
        RpctimeSchema = "G4like_TOFon_TimeShift" + RpctimeShift.str() + "nsec";
    }
 
    StatusCode sc = tagInfoMgr->addTag(m_RPC_TimeSchema, RpctimeSchema);
 
    if (sc.isFailure()) {
        ATH_MSG_WARNING(m_RPC_TimeSchema << " " << RpctimeSchema << " not added to TagInfo ");
        return sc;
    }
 
    ATH_MSG_DEBUG(m_RPC_TimeSchema << " " << RpctimeSchema << " added to TagInfo ");
 
    return StatusCode::SUCCESS;
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

fromSimHitToLayer()

Amg::Transform3D RpcDigitizationTool::fromSimHitToLayer ( const MuonGM::RpcReadoutElement * readOutEle, const Identifier & layerId ) const

private

Returns the position of the hit expressed in the gasGap coordinate system.

Yep. The second gas gap is upside down. But only for the rotated modules. If you're asking yourself why that's the case, my fellow reader I've not even the glimpse of a clue about this beauty

Definition at line 903 of file RpcDigitizationTool.cxx.

                                                                                         {
    
    Amg::Vector3D lGasGapPos = reEle->localGasGapPos(layerId);
    if (reEle->NphiStripPanels() != reEle->nGasGapPerLay()) {
        lGasGapPos.y() =0.;
    }
    
    const bool flip = reEle->numberOfLayers() == 2 &&  
                      (m_idHelper->gasGap(layerId) == 2) != reEle->rotatedRpcModule();
    const Amg::Transform3D fromHitToGap{reEle->transform(layerId).inverse() *
                                        reEle->absTransform() * Amg::getTranslate3D(lGasGapPos) *
                                        (flip ? Amg::getRotateY3D(180.*Gaudi::Units::deg) : Amg::Transform3D::Identity())};
    ATH_MSG_VERBOSE("Transformation to go from hit to gap restframe "<<m_idHelper->print_to_string(layerId)
                <<" "<<Amg::toString(fromHitToGap));
    return fromHitToGap;
}

getNextEvent()

StatusCode RpcDigitizationTool::getNextEvent ( const EventContext & ctx )

private

Get next event and extract collection of hit collections:

Definition at line 354 of file RpcDigitizationTool.cxx.

                                                                    {
    ATH_MSG_DEBUG("RpcDigitizationTool::getNextEvent()");
 
    // initialize pointer
    m_thpcRPC.reset();
 
    //  get the container(s)
    using TimedHitCollList = PileUpMergeSvc::TimedList<RPCSimHitCollection>::type;
 
    // In case of single hits container just load the collection using read handles
    if (!m_onlyUseContainerName) {
        SG::ReadHandle<RPCSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
        if (!hitCollection.isValid()) {
            ATH_MSG_ERROR("Could not get RPCSimHitCollection container " << hitCollection.name() << " from store "
                                                                         << hitCollection.store());
            return StatusCode::FAILURE;
        }
 
        // create a new hits collection
        m_thpcRPC = std::make_unique<TimedHitCollection<RPCSimHit>>(1);
        m_thpcRPC->insert(0, hitCollection.cptr());
        ATH_MSG_DEBUG("RPCSimHitCollection found with " << hitCollection->size() << " hits");
 
        return StatusCode::SUCCESS;
    }
    // this is a list<pair<time_t, DataLink<RPCSimHitCollection> > >
    TimedHitCollList hitCollList;
 
    if (!(m_mergeSvc->retrieveSubEvtsData(m_inputHitCollectionName, hitCollList).isSuccess())) {
        ATH_MSG_ERROR("Could not fill TimedHitCollList");
        return StatusCode::FAILURE;
    }
    if (hitCollList.empty()) {
        ATH_MSG_ERROR("TimedHitCollList has size 0");
        return StatusCode::FAILURE;
    } else {
        ATH_MSG_DEBUG(hitCollList.size() << " RPCSimHitCollections with key " << m_inputHitCollectionName << " found");
    }
 
    // create a new hits collection
    m_thpcRPC = std::make_unique<TimedHitCollection<RPCSimHit>>();
    // now merge all collections into one
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
    while (iColl != endColl) {
        const RPCSimHitCollection* p_collection(iColl->second);
        m_thpcRPC->insert(iColl->first, p_collection);
        // if ( m_debug ) ATH_MSG_DEBUG ( "RPCSimHitCollection found with "
        //   << p_collection->size() << " hits" );    // loop on the hit collections
        ++iColl;
    }
    return StatusCode::SUCCESS;
}

initialize()

StatusCode RpcDigitizationTool::initialize ( )

finaloverridevirtual

Initialize.

Reimplemented from PileUpToolBase.

Definition at line 100 of file RpcDigitizationTool.cxx.

                                           {
    ATH_MSG_DEBUG("RpcDigitizationTool:: in initialize()");
    ATH_MSG_DEBUG("Configuration  RpcDigitizationTool ");
 
    ATH_MSG_DEBUG("InputObjectName        " << m_inputHitCollectionName);
    ATH_MSG_DEBUG("OutputObjectName       " << m_outputDigitCollectionKey.key());
    ATH_MSG_DEBUG("OutputSDOName          " << m_outputSDO_CollectionKey.key());
    ATH_MSG_DEBUG("WindowLowerOffset      " << m_timeWindowLowerOffset);
    ATH_MSG_DEBUG("WindowUpperOffset      " << m_timeWindowUpperOffset);
    ATH_MSG_DEBUG("DeadTime               " << m_deadTime);
    ATH_MSG_DEBUG("RndmSvc                " << m_rndmSvc);
    ATH_MSG_DEBUG("PatchForRpcTime        " << m_patch_for_rpc_time);
    ATH_MSG_DEBUG("RpcTimeShift           " << m_rpc_time_shift);
    ATH_MSG_DEBUG("RPC_TimeSchema         " << m_RPC_TimeSchema);
    ATH_MSG_DEBUG("RPCSDOareRPCDigits     " << m_sdoAreOnlyDigits);
 
    ATH_MSG_DEBUG("IgnoreRunDependentConfig " << m_ignoreRunDepConfig);
    ATH_MSG_DEBUG("turnON_efficiency      " << m_turnON_efficiency);
    ATH_MSG_DEBUG("Efficiency_fromCOOL    " << m_Efficiency_fromCOOL);
    ATH_MSG_DEBUG("Efficiency_BIS78_fromCOOL" << m_Efficiency_BIS78_fromCOOL);
    ATH_MSG_DEBUG("turnON_clustersize     " << m_turnON_clustersize);
    ATH_MSG_DEBUG("ClusterSize_fromCOOL   " << m_ClusterSize_fromCOOL);
    ATH_MSG_DEBUG("ClusterSize_BIS78_fromCOOL" << m_ClusterSize_BIS78_fromCOOL);
    ATH_MSG_DEBUG("FirstClusterSizeInTail " << m_FirstClusterSizeInTail);
    ATH_MSG_DEBUG("ClusterSize1_2uncorr   " << m_ClusterSize1_2uncorr);
    ATH_MSG_DEBUG("BOG_BOF_DoubletR2_OFF  " << m_BOG_BOF_DoubletR2_OFF);
    ATH_MSG_DEBUG("CutMaxClusterSize      " << m_CutMaxClusterSize);
    ATH_MSG_DEBUG("CutProjectedTracks     " << m_CutProjectedTracks);
    ATH_MSG_DEBUG("ValidationSetup        " << m_validationSetup);
    ATH_MSG_DEBUG("IncludePileUpTruth     " << m_includePileUpTruth);
    ATH_MSG_DEBUG("VetoPileUpTruthLinks   " << m_vetoPileUpTruthLinks);
 
    ATH_CHECK(m_detMgrKey.initialize());
    if (m_onlyUseContainerName) { ATH_CHECK(m_mergeSvc.retrieve()); }
    ATH_CHECK(detStore()->retrieve(m_idHelper));
    // check the identifiers
 
    ATH_MSG_INFO("Max Number of RPC Gas Gaps for these Identifiers = " << m_idHelper->gasGapMax());
 
    // check the input object name
    if (m_hitsContainerKey.key().empty()) {
        ATH_MSG_FATAL("Property InputObjectName not set !");
        return StatusCode::FAILURE;
    }
    if (m_onlyUseContainerName) m_inputHitCollectionName = m_hitsContainerKey.key();
    ATH_MSG_DEBUG("Input objects in container : '" << m_inputHitCollectionName << "'");
 
    // Initialize ReadHandleKey
    ATH_CHECK(m_hitsContainerKey.initialize());
 
    // initialize the output WriteHandleKeys
    ATH_CHECK(m_outputDigitCollectionKey.initialize());
    ATH_CHECK(m_outputSDO_CollectionKey.initialize());
    ATH_CHECK(m_simHitValidKey.initialize(m_validationSetup));
    ATH_MSG_DEBUG("Output digits: '" << m_outputDigitCollectionKey.key() << "'");
 
    // set the configuration based on run1/run2
    ATH_CHECK(initializeRunDependentParameters());
    
    ATH_MSG_DEBUG("Ready to read parameters for cluster simulation from file");
 
    ATH_CHECK(m_rndmSvc.retrieve());
 
    // fill the taginfo information
    ATH_CHECK(fillTagInfo());
 
    ATH_CHECK(m_readKey.initialize(m_RPCInfoFromDb));

    //  m_turnON_clustersize=false;
    m_BOF_id = m_idHelper->stationNameIndex("BOF");
    m_BOG_id = m_idHelper->stationNameIndex("BOG");
    m_BOS_id = m_idHelper->stationNameIndex("BOS");
    m_BIL_id = m_idHelper->stationNameIndex("BIL");
    m_BIS_id = m_idHelper->stationNameIndex("BIS");
    m_muonHelper = RpcHitIdHelper::GetHelper(m_idHelper->gasGapMax());
 
    return StatusCode::SUCCESS;
}

initializeRunDependentParameters()

StatusCode RpcDigitizationTool::initializeRunDependentParameters ( )

private

Definition at line 180 of file RpcDigitizationTool.cxx.

                                                                 {
  // TODO This should all be in a conditions Alg
  // Retrieve geometry config information from the database (RUN1, RUN2, etc...)
  SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
  if ( !geoModel ) {
    ATH_MSG_ERROR("Could not locate GeoModelSvc");
    return StatusCode::FAILURE;
  }
 
  // check the DetDescr version
  std::string atlasVersion = geoModel->atlasVersion();
 
  SmartIF<IRDBAccessSvc> rdbAccess{Gaudi::svcLocator()->service("RDBAccessSvc")};
  if ( !rdbAccess ) {
    ATH_MSG_ERROR("Could not locate RDBAccessSvc");
    return StatusCode::FAILURE;
  }
 
  enum DataPeriod {Unknown, Run1, Run2, Run3, Run4 };
  DataPeriod run = Unknown;
 
  std::string configVal = "";
 
  IRDBRecordset_ptr atlasCommonRec = rdbAccess->getRecordsetPtr("AtlasCommon", atlasVersion, "ATLAS");
  if (atlasCommonRec->size() == 0) {
    run = Run1;
  } else {
    configVal = (*atlasCommonRec)[0]->getString("CONFIG");
    ATH_MSG_INFO("From DD Database, Configuration is " << configVal);
    if (configVal == "RUN1") {
      run = Run1;
    } else if (configVal == "RUN2") {
      run = Run2;
    } else if (configVal == "RUN3") {
      run = Run3;
    } else if (configVal == "RUN4") {
      run = Run4;
    }
    if (run == DataPeriod::Unknown) {
      ATH_MSG_FATAL("Unexpected value for geometry config read from the database: " << configVal);
      return StatusCode::FAILURE;
    }
  }
  if (run == Run3 && m_idHelper->gasGapMax() < 3)
    ATH_MSG_WARNING("Run3,  configVal = " << configVal << " and GasGapMax =" << m_idHelper->gasGapMax());
 
  if (run == Run1)
    ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN1 or MuonGeometry = R.06");
  else if (run == Run2)
    ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN2 or MuonGeometry = R.07");
  else if (run == Run3)
    ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN3 or MuonGeometry = R.09");
  else if (run == Run4)
    ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN4 or MuonGeometry = R.10");
 
  if (m_ignoreRunDepConfig == false) {
        m_BOG_BOF_DoubletR2_OFF = false;
        m_Efficiency_fromCOOL = false;
        m_ClusterSize_fromCOOL = false;
        m_RPCInfoFromDb = false;
        m_kill_deadstrips = false;
        if (run == Run1) {
            // m_BOG_BOF_DoubletR2_OFF = true
            // m_Efficiency_fromCOOL   = true
            // m_ClusterSize_fromCOOL  = true
            m_BOG_BOF_DoubletR2_OFF = true;
            if (configVal == "RUN1") {  // MC12 setup
                m_Efficiency_fromCOOL = true;
                m_ClusterSize_fromCOOL = true;
                m_RPCInfoFromDb = true;
                m_kill_deadstrips = true;
                m_CutProjectedTracks = 50;
            }
        } else {
            // m_BOG_BOF_DoubletR2_OFF = false # do not turn off at digitization the hits in the dbR=2 chambers in the feet
            // m_Efficiency_fromCOOL   = false # use common average values in python conf.
            // m_ClusterSize_fromCOOL  = false # use common average values in python conf.
            m_BOG_BOF_DoubletR2_OFF = false;
            if (run == Run2) {  // MC15c setup
                m_Efficiency_fromCOOL = true;
                m_ClusterSize_fromCOOL = true;
                m_RPCInfoFromDb = true;
                m_kill_deadstrips = false;
                m_CutProjectedTracks = 100;
            } else {
                ATH_MSG_INFO("Run3/4: configuration parameter not from COOL");
                m_Efficiency_fromCOOL = false;
                m_ClusterSize_fromCOOL = false;
                m_RPCInfoFromDb = false;
                m_kill_deadstrips = false;
            }
        }
        ATH_MSG_INFO("RPC Run1/2/3-dependent configuration is enforced");
    } else {
        ATH_MSG_WARNING("Run1/2/3-dependent configuration is bypassed; be careful with option settings");
    }
 
    ATH_MSG_DEBUG("......RPC Efficiency_fromCOOL    " << m_Efficiency_fromCOOL);
    ATH_MSG_DEBUG("......RPC ClusterSize_fromCOOL   " << m_ClusterSize_fromCOOL);
    ATH_MSG_DEBUG("......RPC BOG_BOF_DoubletR2_OFF  " << m_BOG_BOF_DoubletR2_OFF);
    ATH_MSG_DEBUG("......RPC RPCInfoFromDb          " << m_RPCInfoFromDb);
    ATH_MSG_DEBUG("......RPC KillDeadStrips         " << m_kill_deadstrips);
    ATH_MSG_DEBUG("......RPC CutProjectedTracks     " << m_CutProjectedTracks);
 
 
    return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode RpcDigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 409 of file RpcDigitizationTool.cxx.

                                                                  {
    StatusCode status = StatusCode::SUCCESS;
 
    ATH_MSG_DEBUG("RpcDigitizationTool::in mergeEvent()");
    // create and record the Digit container in StoreGate
    SG::WriteHandle<RpcDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
    ATH_CHECK(digitContainer.record(std::make_unique<RpcDigitContainer>(m_idHelper->module_hash_max())));
    ATH_MSG_DEBUG("RpcDigitContainer recorded in StoreGate.");
 
    // Create and record the SDO container in StoreGate
    SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDO_CollectionKey, ctx);
    ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
    ATH_MSG_DEBUG("RpcSDOCollection recorded in StoreGate.");

    m_sdo_tmp_map.clear();
 
    Collections_t collections;
    status = doDigitization(ctx, collections, sdoContainer.ptr());
    if (status.isFailure()) { ATH_MSG_ERROR("doDigitization Failed"); }
    for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
      if (collections[coll_hash]) {
        ATH_CHECK( digitContainer->addCollection (collections[coll_hash].release(), coll_hash) );
      }
    }
 
    // Clean-up
    m_RPCHitCollList.clear();
 
    return status;
}

outsideWindow()

bool RpcDigitizationTool::outsideWindow ( double time ) const

inlineprivate

Definition at line 257 of file RpcDigitizationTool.h.

                                                                {
    return time < m_timeWindowLowerOffset || time > m_timeWindowUpperOffset;
}

PackMCTruth()

long long int RpcDigitizationTool::PackMCTruth ( float proptime, float tof, float posx, float posz ) const

private

Definition at line 1011 of file RpcDigitizationTool.cxx.

                                                                                                         {
    // start with proptime: it is usually ~ns. It comes in ns. We express it in ns/10. use only 8 bits
    if (proptime < 0) {
        ATH_MSG_WARNING("A poblem: packing a propagation time <0 " << proptime << " redefine it as 0");
        proptime = 0.;
    }
    long long int new_proptime = int(proptime * 10) & 0xff;
 
    // now tof. it is ~100ns. comes in ns. express it in ns/10. 16 bits needed (0-32768)
    // now BC time: it is ~100ns. comes in ns. express it in ns/10. 16 bits needed (0-32768)
    // can be negative (=> add 300 ns)
 
    long long int new_bctime = int((bctime + 300.) * 10.) & 0xffff;
 
    // posy: ~1000mm comes in mm, write it in mm*10. need 16 bits (0-32768)
    // can be negative (=>add 1500 mm)
 
    long long int new_posy = int((posy + 1500.) * 10.) & 0xffff;
 
    // posz: ~1000mm comes in mm, write it in mm*10. need 16 bits (0-32768)
    // can be negative (=>add 1500 mm)
 
    long long int new_posz = int((posz + 1500.) * 10.) & 0xffff;
 
    return (new_proptime + (new_bctime << 8) + (new_posy << 24) + (new_posz << 40));
}

physicalClusterSize()

std::array< int, 3 > RpcDigitizationTool::physicalClusterSize ( const EventContext & ctx, const MuonGM::RpcReadoutElement * reEle, const Identifier & id, const Amg::Vector3D & posAtCentre, CLHEP::HepRandomEngine * rndmEngine ) const

private

Cluster simulation: first step.

The impact point of the particle across the strip is used to decide whether the cluster size should be 1 or 2

Definition at line 925 of file RpcDigitizationTool.cxx.

                                                                                                    {
    
 
    std::array<int, 3> result{};
 
    const Amg::Vector3D position = fromSimHitToLayer(ele, id) * gapCentre;
 
    const int doubletPhi = m_idHelper->doubletPhi(id);
    const int gasGap = m_idHelper->gasGap(id);
    const bool measuresPhi = m_idHelper->measuresPhi(id);
    const double pitch= ele->StripPitch(measuresPhi);
 
 
    const int nstrip = ele->stripNumber(position.block<2,1>(0,0), id);
    const int numStrips = ele->Nstrips(measuresPhi);
 
    result[1] = nstrip;
    result[2] = nstrip;
 
    if (nstrip < 1 || nstrip > numStrips) {
        return make_array<int, 3>(-1);
    }    
    const Amg::Vector3D locStripPos = ele->transform(id).inverse()*ele->stripPos(doubletPhi, gasGap, measuresPhi, nstrip); 
    float xstripnorm = (locStripPos -position).x() / pitch ;
    result[0] = determineClusterSize(ctx, id, xstripnorm, rndmEngine);
 
    //
    
 
    if (m_turnON_clustersize == false) result[0] = 1;
 
    return result;
}

prepareEvent()

StatusCode RpcDigitizationTool::prepareEvent ( const EventContext & ctx, const unsigned int  )

finaloverridevirtual

When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop.

Not able to access SubEvents

Definition at line 308 of file RpcDigitizationTool.cxx.

                                                                                {
    ATH_MSG_DEBUG("RpcDigitizationTool::in prepareEvent()");
 
    // John's Hacks START
    m_RPCHitCollList.clear();
    m_thpcRPC = std::make_unique<TimedHitCollection<RPCSimHit>>();
    // John's Hacks END
 
    return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode RpcDigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Reimplemented from PileUpToolBase.

Definition at line 443 of file RpcDigitizationTool.cxx.

                                                                           {
    StatusCode status = StatusCode::SUCCESS;
 
    // merging of the hit collection in getNextEvent method
 
    ATH_MSG_DEBUG("RpcDigitizationTool::in digitize()");
 
    // create and record the Digit container in StoreGate
    SG::WriteHandle<RpcDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
    ATH_CHECK(digitContainer.record(std::make_unique<RpcDigitContainer>(m_idHelper->module_hash_max())));
    ATH_MSG_DEBUG("RpcDigitContainer recorded in StoreGate.");
 
    // Create and record the SDO container in StoreGate
    SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDO_CollectionKey, ctx);
    ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
    ATH_MSG_DEBUG("RpcSDOCollection recorded in StoreGate.");

    m_sdo_tmp_map.clear();
 
    if (!m_thpcRPC) {
        status = getNextEvent(ctx);
        if (StatusCode::FAILURE == status) {
            ATH_MSG_INFO("There are no RPC hits in this event");
            return status;  // there are no hits in this event
        }
    }
 
    Collections_t collections;
    ATH_CHECK(doDigitization(ctx, collections, sdoContainer.ptr()));
    for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
      if (collections[coll_hash]) {
        ATH_CHECK( digitContainer->addCollection (collections[coll_hash].release(), coll_hash) );
      }
    }
 
    return status;
}

processBunchXing()

StatusCode RpcDigitizationTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtual

When being run from PileUpToolsAlgs, this method is called for each active bunch-crossing to process current SubEvents bunchXing is in ns.

Reimplemented from PileUpToolBase.

Definition at line 320 of file RpcDigitizationTool.cxx.

                                                                                                                        {
    ATH_MSG_DEBUG("RpcDigitizationTool::in processBunchXing()");
 
    typedef PileUpMergeSvc::TimedList<RPCSimHitCollection>::type TimedHitCollList;
    TimedHitCollList hitCollList;
 
    if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputHitCollectionName, hitCollList, bunchXing, bSubEvents, eSubEvents).isSuccess()) &&
        hitCollList.empty()) {
        ATH_MSG_ERROR("Could not fill TimedHitCollList");
        return StatusCode::FAILURE;
    } else {
        ATH_MSG_VERBOSE(hitCollList.size() << " RPCSimHitCollection with key " << m_inputHitCollectionName << " found");
    }
 
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
 
    // Iterating over the list of collections
    for (; iColl != endColl; ++iColl) {
        RPCSimHitCollection* hitCollPtr = new RPCSimHitCollection(*iColl->second);
        PileUpTimeEventIndex timeIndex(iColl->first);
 
        ATH_MSG_DEBUG("RPCSimHitCollection found with " << hitCollPtr->size() << " hits");
        ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time() << " index: " << timeIndex.index() << " type: " << timeIndex.type());
 
        m_thpcRPC->insert(timeIndex, hitCollPtr);
        m_RPCHitCollList.emplace_back(hitCollPtr);
    }
 
    return StatusCode::SUCCESS;
}

PropagationTime()

double RpcDigitizationTool::PropagationTime ( const MuonGM::RpcReadoutElement * reEle, const Identifier & id, const Amg::Vector3D & globPos ) const

private

Calculates the propagation time along the strip.

Definition at line 995 of file RpcDigitizationTool.cxx.

                                                                              {
 
    double distance{0.};
    if (m_idHelper->measuresPhi(id)) {
        distance = ele->distanceToPhiReadout(globPos);
    } else {
        distance = ele->distanceToEtaReadout(globPos);
    }
 
    // distance in mm, SIG_VEL in ns/m
    return std::abs(distance * SIG_VEL * 1.e-3);
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

retrieveCondData()

template<class CondType>

StatusCode RpcDigitizationTool::retrieveCondData ( const EventContext & ctx, const SG::ReadCondHandleKey< CondType > & key, const CondType *& condPtr ) const

private

Definition at line 289 of file RpcDigitizationTool.cxx.

                                                                                  {
 
    if (key.empty()) {
       ATH_MSG_DEBUG("No key has been configured for object "<<typeid(CondType).name()<<". Clear pointer");
       condPtr = nullptr;
       return StatusCode::SUCCESS;
    }
    SG::ReadCondHandle<CondType> readHandle{key, ctx};
    if (!readHandle.isValid()){
        ATH_MSG_FATAL("Failed to load conditions object "<<key.fullKey()<<".");
        return StatusCode::FAILURE;
    }
    condPtr = readHandle.cptr();
    return StatusCode::SUCCESS;
 
}

timeOverThreshold()

double RpcDigitizationTool::timeOverThreshold ( CLHEP::HepRandomEngine * rndmEngine )

staticprivate

Definition at line 1626 of file RpcDigitizationTool.cxx.

                                                                              {
    //mn Time-over-threshold modeled as a narrow and a wide gaussian
    //mn based on the fit documented in https://its.cern.ch/jira/browse/ATLASRECTS-7820
    constexpr double tot_mean_narrow = 16.;
    constexpr double tot_sigma_narrow = 2.;
    constexpr double tot_mean_wide = 15.;
    constexpr double tot_sigma_wide = 4.5;
 
    double thetot = 0.;
    
    if (CLHEP::RandFlat::shoot(rndmEngine)<0.75) {
      thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_narrow, tot_sigma_narrow);
    } else {
      thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_wide, tot_sigma_wide);
    }
 
    return (thetot > 0.) ? thetot : 0.;
}

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

TurnOnStrips()

std::array< int, 3 > RpcDigitizationTool::TurnOnStrips ( const MuonGM::RpcReadoutElement * reEle, std::array< int, 3 > && pcs, const Identifier & id ) const

private

Cluster simulation: second step.

Additional strips are turned on in order to reproduce the observed cluster size distribution

Definition at line 964 of file RpcDigitizationTool.cxx.

                                                                                 {
 
 
    const int nstrips = ele->Nstrips(m_idHelper->measuresPhi(id));
 
    if (pcs[0] == -2) {
        pcs[1] = pcs[2] - 1;
    } else if (pcs[0] == 2) {
        pcs[2] = pcs[1] + 1;
    } else if (pcs[0] > 2) {
        pcs[1] = pcs[1] - pcs[0] / 2;
        if (fmod(pcs[0], 2) == 0) pcs[1] = pcs[1] + 1;
        pcs[2] = pcs[1] + pcs[0] - 1;
    } else if (pcs[0] < -2) {
        pcs[1] = pcs[1] + pcs[0] / 2;
        pcs[2] = pcs[1] - pcs[0] - 1;
    }
 
    // cut the clusters at the beginning and at the end of the chamber
 
    pcs[1] = std::clamp(pcs[1], 1, nstrips);
    pcs[2] = std::clamp(pcs[2], 1, nstrips);
 
    pcs[0] = pcs[2] - pcs[1] + 1;
 
    return pcs;
}

UnPackMCTruth()

void RpcDigitizationTool::UnPackMCTruth ( double theWord, float & proptime, float & tof, float & posy, float & posz )

staticprivate

Definition at line 1039 of file RpcDigitizationTool.cxx.

                                                                                                                {
    // int64_t is just a shorter way of writing long long int
    using Repacker = union
 
    {
        double dWord;
 
        int64_t iWord;
    };
    Repacker MCTruth;
    MCTruth.dWord = theWord;
    proptime = ((MCTruth.iWord) & 0x00000000000000ffLL) / 10.;
    bctime = (((MCTruth.iWord) & 0x0000000000ffff00LL) >> 8) / 10.;
    posy = (((MCTruth.iWord) & 0x000000ffff000000LL) >> 24) / 10.;
    posz = (((MCTruth.iWord) & 0x00ffff0000000000LL) >> 40) / 10.;
 
    //
    bctime = bctime - 300.;
    posy = posy - 1500.;
    posz = posz - 1500.;
}

Member Data Documentation

m_BIL_id

int RpcDigitizationTool::m_BIL_id {-1}

protected

Definition at line 252 of file RpcDigitizationTool.h.

{-1};

m_BIS_id

int RpcDigitizationTool::m_BIS_id {-1}

protected

Definition at line 253 of file RpcDigitizationTool.h.

{-1};

m_BOF_id

int RpcDigitizationTool::m_BOF_id {-1}

protected

Definition at line 248 of file RpcDigitizationTool.h.

{-1};

m_BOG_BOF_DoubletR2_OFF

Gaudi::Property<bool> RpcDigitizationTool::m_BOG_BOF_DoubletR2_OFF {this, "Force_BOG_BOF_DoubletR2_OFF", false, "Turn-off BOG and BOF with DoubletR=2"}

protected

Definition at line 237 of file RpcDigitizationTool.h.

{this, "Force_BOG_BOF_DoubletR2_OFF", false, "Turn-off BOG and BOF with DoubletR=2"};

m_BOG_id

int RpcDigitizationTool::m_BOG_id {-1}

protected

Definition at line 249 of file RpcDigitizationTool.h.

{-1};

m_BOS_id

int RpcDigitizationTool::m_BOS_id {-1}

protected

Definition at line 250 of file RpcDigitizationTool.h.

{-1};

m_ClusterSize1_2uncorr

Gaudi::Property<bool> RpcDigitizationTool::m_ClusterSize1_2uncorr

protected

Initial value:

{this, "ClusterSize1_2uncorr", false,
                                                 "Cluster size 1 and 2 not correlated to track position"}

Definition at line 235 of file RpcDigitizationTool.h.

                                              {this, "ClusterSize1_2uncorr", false,
                                                 "Cluster size 1 and 2 not correlated to track position"};

m_ClusterSize_BIS78_fromCOOL

Gaudi::Property<bool> RpcDigitizationTool::m_ClusterSize_BIS78_fromCOOL {this, "ClusterSize_BIS78_fromCOOL", false, " read BIS78 Cluster Size from COOL DB"}

protected

Definition at line 241 of file RpcDigitizationTool.h.

{this, "ClusterSize_BIS78_fromCOOL", false, " read BIS78 Cluster Size from COOL DB"};

m_ClusterSize_fromCOOL

Gaudi::Property<bool> RpcDigitizationTool::m_ClusterSize_fromCOOL {this, "ClusterSize_fromCOOL", false, "Read cluster size from CoolDB"}

protected

Definition at line 234 of file RpcDigitizationTool.h.

{this, "ClusterSize_fromCOOL", false, "Read cluster size from CoolDB"};

m_CorrJitter

Gaudi::Property<double> RpcDigitizationTool::m_CorrJitter {this, "CorrJitter", 0.0, "jitter correlated between eta and phi"}

private

Definition at line 127 of file RpcDigitizationTool.h.

{this, "CorrJitter", 0.0, "jitter correlated between eta and phi"};

m_CorrJitter_BIS78

Gaudi::Property<double> RpcDigitizationTool::m_CorrJitter_BIS78 {this, "CorrJitter_BIS78", 0.0, "jitter correlated between eta and phi BIS78"}

private

Definition at line 130 of file RpcDigitizationTool.h.

{this, "CorrJitter_BIS78", 0.0, "jitter correlated between eta and phi BIS78"};

m_CutMaxClusterSize

Gaudi::Property<float> RpcDigitizationTool::m_CutMaxClusterSize {this, "CutMaxClusterSize", 5.0, ""}

protected

Definition at line 245 of file RpcDigitizationTool.h.

{this, "CutMaxClusterSize", 5.0, ""};

m_CutProjectedTracks

Gaudi::Property<int> RpcDigitizationTool::m_CutProjectedTracks {this, "CutProjectedTracks", 100, ""}

protected

Definition at line 246 of file RpcDigitizationTool.h.

{this, "CutProjectedTracks", 100, ""};

m_deadTime

Gaudi::Property<int> RpcDigitizationTool::m_deadTime {this, "DeadTime", 100., "dead time"}

private

Definition at line 166 of file RpcDigitizationTool.h.

{this, "DeadTime", 100., "dead time"};

m_detMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> RpcDigitizationTool::m_detMgrKey

private

Initial value:

{this, "DetectorManagerKey",  "MuonDetectorManager", 
                                                            "Key of input MuonDetectorManager condition data"}

Definition at line 158 of file RpcDigitizationTool.h.

                                                               {this, "DetectorManagerKey",  "MuonDetectorManager", 
                                                            "Key of input MuonDetectorManager condition data"};

m_Efficiency_BIS78_fromCOOL

Gaudi::Property<bool> RpcDigitizationTool::m_Efficiency_BIS78_fromCOOL {this, "Efficiency_BIS78_fromCOOL", false, " read BIS78 Efficiency from COOL DB"}

protected

Definition at line 240 of file RpcDigitizationTool.h.

{this, "Efficiency_BIS78_fromCOOL", false, " read BIS78 Efficiency from COOL DB"};

m_Efficiency_fromCOOL

Gaudi::Property<bool> RpcDigitizationTool::m_Efficiency_fromCOOL {this, "Efficiency_fromCOOL", false, "Read efficiency from CoolDB"}

protected

Definition at line 230 of file RpcDigitizationTool.h.

{this, "Efficiency_fromCOOL", false, "Read efficiency from CoolDB"};

m_EfficiencyPatchForBMShighEta

Gaudi::Property<bool> RpcDigitizationTool::m_EfficiencyPatchForBMShighEta

protected

Initial value:

{this, "EfficiencyPatchForBMShighEta", false,
                                                         "special patch to be true only when m_Efficiency_fromCOOL=true and "
                                                         "/RPC/DQMF/ELEMENT_STATUS tag is RPCDQMFElementStatus_2012_Jaunuary_26"}

Definition at line 231 of file RpcDigitizationTool.h.

                                                      {this, "EfficiencyPatchForBMShighEta", false,
                                                         "special patch to be true only when m_Efficiency_fromCOOL=true and "
                                                         "/RPC/DQMF/ELEMENT_STATUS tag is RPCDQMFElementStatus_2012_Jaunuary_26"};

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_FirstClusterSizeInTail

Gaudi::Property<int> RpcDigitizationTool::m_FirstClusterSizeInTail {this, "FirstClusterSizeInTail", 3, ""}

private

Definition at line 178 of file RpcDigitizationTool.h.

{this, "FirstClusterSizeInTail", 3, ""};

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,
      "First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_FracClusterSize1_A

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_FracClusterSize1_A {this, "FracClusterSize1_A", {}, ""}

private

Definition at line 191 of file RpcDigitizationTool.h.

{this, "FracClusterSize1_A", {}, ""};

m_FracClusterSize1_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_FracClusterSize1_BIS78 {this, "FracClusterSize1_BIS78", 0.60, ""}

private

Definition at line 201 of file RpcDigitizationTool.h.

{this, "FracClusterSize1_BIS78", 0.60, ""};

m_FracClusterSize1_C

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_FracClusterSize1_C {this, "FracClusterSize1_C", {}, ""}

private

Definition at line 196 of file RpcDigitizationTool.h.

{this, "FracClusterSize1_C", {}, ""};

m_FracClusterSize2_A

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_FracClusterSize2_A {this, "FracClusterSize2_A", {}, ""}

private

Definition at line 192 of file RpcDigitizationTool.h.

{this, "FracClusterSize2_A", {}, ""};

m_FracClusterSize2_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_FracClusterSize2_BIS78 {this, "FracClusterSize2_BIS78", 0.35, ""}

private

Definition at line 202 of file RpcDigitizationTool.h.

{this, "FracClusterSize2_BIS78", 0.35, ""};

m_FracClusterSize2_C

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_FracClusterSize2_C {this, "FracClusterSize2_C", {}, ""}

private

Definition at line 197 of file RpcDigitizationTool.h.

{this, "FracClusterSize2_C", {}, ""};

m_FracClusterSizeTail_A

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_FracClusterSizeTail_A {this, "FracClusterSizeTail_A", {}, ""}

private

Definition at line 193 of file RpcDigitizationTool.h.

{this, "FracClusterSizeTail_A", {}, ""};

m_FracClusterSizeTail_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_FracClusterSizeTail_BIS78 {this, "FracClusterSizeTail_BIA78", 0.05, ""}

private

Definition at line 203 of file RpcDigitizationTool.h.

{this, "FracClusterSizeTail_BIA78", 0.05, ""};

m_FracClusterSizeTail_C

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_FracClusterSizeTail_C {this, "FracClusterSizeTail_C", {}, ""}

private

Definition at line 198 of file RpcDigitizationTool.h.

{this, "FracClusterSizeTail_C", {}, ""};

m_hitsContainerKey

SG::ReadHandleKey<RPCSimHitCollection> RpcDigitizationTool::m_hitsContainerKey {this, "InputObjectName", "RPC_Hits", "name of the input object"}

protected

Definition at line 216 of file RpcDigitizationTool.h.

{this, "InputObjectName", "RPC_Hits", "name of the input object"};

m_idHelper

const RpcIdHelper* RpcDigitizationTool::m_idHelper {}

private

Definition at line 160 of file RpcDigitizationTool.h.

{};

m_ignoreRunDepConfig

Gaudi::Property<bool> RpcDigitizationTool::m_ignoreRunDepConfig

protected

Initial value:

{this, "IgnoreRunDependentConfig", false,
                                               "true if we want to force the RUN1/RUN2 dependent options"}

Definition at line 238 of file RpcDigitizationTool.h.

                                            {this, "IgnoreRunDependentConfig", false,
                                               "true if we want to force the RUN1/RUN2 dependent options"};

m_includePileUpTruth

Gaudi::Property<bool> RpcDigitizationTool::m_includePileUpTruth {this, "IncludePileUpTruth", true, "pileup truth veto"}

private

Definition at line 173 of file RpcDigitizationTool.h.

{this, "IncludePileUpTruth", true, "pileup truth veto"};

m_inputHitCollectionName

std::string RpcDigitizationTool::m_inputHitCollectionName {""}

protected

Definition at line 217 of file RpcDigitizationTool.h.

{""};

m_kill_deadstrips

Gaudi::Property<bool> RpcDigitizationTool::m_kill_deadstrips {this, "KillDeadStrips", false, ""}

private

Definition at line 176 of file RpcDigitizationTool.h.

{this, "KillDeadStrips", false, ""};              // gabriele

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,
      "Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

m_MeanClusterSizeTail_A

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_MeanClusterSizeTail_A {this, "MeanClusterSizeTail_A", {}, ""}

private

Definition at line 194 of file RpcDigitizationTool.h.

{this, "MeanClusterSizeTail_A", {}, ""};

m_MeanClusterSizeTail_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_MeanClusterSizeTail_BIS78 {this, "MeanClusterSizeTail_BIA78", 3.5, ""}

private

Definition at line 204 of file RpcDigitizationTool.h.

{this, "MeanClusterSizeTail_BIA78", 3.5, ""};

m_MeanClusterSizeTail_C

Gaudi::Property<std::vector<double> > RpcDigitizationTool::m_MeanClusterSizeTail_C {this, "MeanClusterSizeTail_C", {}, ""}

private

Definition at line 199 of file RpcDigitizationTool.h.

{this, "MeanClusterSizeTail_C", {}, ""};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> RpcDigitizationTool::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Pile up service"}

protected

Definition at line 213 of file RpcDigitizationTool.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc", "Pile up service"};

m_muonHelper

const RpcHitIdHelper* RpcDigitizationTool::m_muonHelper {}

private

Definition at line 161 of file RpcDigitizationTool.h.

{};

m_muonOnlySDOs

Gaudi::Property<bool> RpcDigitizationTool::m_muonOnlySDOs {this, "MuonOnlySDOs", true, ""}

private

Definition at line 208 of file RpcDigitizationTool.h.

{this, "MuonOnlySDOs", true, ""};

m_OnlyEtaEff_A

Gaudi::Property<std::vector<float> > RpcDigitizationTool::m_OnlyEtaEff_A {this, "OnlyEtaEff_A", {}, ""}

private

Definition at line 182 of file RpcDigitizationTool.h.

{this, "OnlyEtaEff_A", {}, ""};

m_OnlyEtaEff_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_OnlyEtaEff_BIS78 {this, "OnlyEtaEff_BIS78", 0.96, ""}

private

Definition at line 188 of file RpcDigitizationTool.h.

{this, "OnlyEtaEff_BIS78", 0.96, ""};

m_OnlyEtaEff_C

Gaudi::Property<std::vector<float> > RpcDigitizationTool::m_OnlyEtaEff_C {this, "OnlyEtaEff_C", {}, ""}

private

Definition at line 185 of file RpcDigitizationTool.h.

{this, "OnlyEtaEff_C", {}, ""};

m_OnlyPhiEff_A

Gaudi::Property<std::vector<float> > RpcDigitizationTool::m_OnlyPhiEff_A {this, "OnlyPhiEff_A", {}, ""}

private

Definition at line 181 of file RpcDigitizationTool.h.

{this, "OnlyPhiEff_A", {}, ""};

m_OnlyPhiEff_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_OnlyPhiEff_BIS78 {this, "OnlyPhiEff_BIS78", 0.96, ""}

private

Definition at line 189 of file RpcDigitizationTool.h.

{this, "OnlyPhiEff_BIS78", 0.96, ""};

m_OnlyPhiEff_C

Gaudi::Property<std::vector<float> > RpcDigitizationTool::m_OnlyPhiEff_C {this, "OnlyPhiEff_C", {}, ""}

private

Definition at line 184 of file RpcDigitizationTool.h.

{this, "OnlyPhiEff_C", {}, ""};

m_onlyUseContainerName

Gaudi::Property<bool> RpcDigitizationTool::m_onlyUseContainerName

protected

Initial value:

{this, "OnlyUseContainerName", true,
                                                 "Don't use the ReadHandleKey directly. Just extract the container name from it."}

Definition at line 214 of file RpcDigitizationTool.h.

                                              {this, "OnlyUseContainerName", true,
                                                 "Don't use the ReadHandleKey directly. Just extract the container name from it."};

m_outputDigitCollectionKey

SG::WriteHandleKey<RpcDigitContainer> RpcDigitizationTool::m_outputDigitCollectionKey

protected

Initial value:

{
        this, "OutputObjectName", "RPC_DIGITS", "WriteHandleKey for Output RpcDigitContainer"}

Definition at line 218 of file RpcDigitizationTool.h.

                                                                  {
        this, "OutputObjectName", "RPC_DIGITS", "WriteHandleKey for Output RpcDigitContainer"};  // name of the output digits

m_outputSDO_CollectionKey

SG::WriteHandleKey<MuonSimDataCollection> RpcDigitizationTool::m_outputSDO_CollectionKey

protected

Initial value:

{
        this, "OutputSDOName", "RPC_SDO", "WriteHandleKey for Output MuonSimDataCollection"}

Definition at line 220 of file RpcDigitizationTool.h.

                                                                     {
        this, "OutputSDOName", "RPC_SDO", "WriteHandleKey for Output MuonSimDataCollection"};  // name of the output SDOs

m_patch_for_rpc_time

Gaudi::Property<bool> RpcDigitizationTool::m_patch_for_rpc_time {this, "PatchForRpcTime", false, ""}

private

Definition at line 167 of file RpcDigitizationTool.h.

{this, "PatchForRpcTime", false, ""};

m_PhiAndEtaEff_A

Gaudi::Property<std::vector<float> > RpcDigitizationTool::m_PhiAndEtaEff_A {this, "PhiAndEtaEff_A", {}, ""}

private

Definition at line 180 of file RpcDigitizationTool.h.

{this, "PhiAndEtaEff_A", {}, ""};

m_PhiAndEtaEff_BIS78

Gaudi::Property<float> RpcDigitizationTool::m_PhiAndEtaEff_BIS78 {this, "PhiAndEtaEff_BIS78", 0.93, ""}

private

Definition at line 187 of file RpcDigitizationTool.h.

{this, "PhiAndEtaEff_BIS78", 0.93, ""};

m_PhiAndEtaEff_C

Gaudi::Property<std::vector<float> > RpcDigitizationTool::m_PhiAndEtaEff_C {this, "PhiAndEtaEff_C", {}, ""}

private

Definition at line 183 of file RpcDigitizationTool.h.

{this, "PhiAndEtaEff_C", {}, ""};

m_readKey

SG::ReadCondHandleKey<RpcCondDbData> RpcDigitizationTool::m_readKey {this, "ReadKey", "RpcCondDbData", "Key of RpcCondDbData"}

private

Definition at line 164 of file RpcDigitizationTool.h.

{this, "ReadKey", "RpcCondDbData", "Key of RpcCondDbData"};

m_rndmSvc

ServiceHandle<IAthRNGSvc> RpcDigitizationTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

protected

Definition at line 224 of file RpcDigitizationTool.h.

{this, "RndmSvc", "AthRNGSvc", ""};  // Random number service

m_rpc_time_shift

Gaudi::Property<double> RpcDigitizationTool::m_rpc_time_shift

private

Initial value:

{this, "PatchForRpcTimeShift", 12.5,
                                             "shift rpc digit time to match hardware time calibration: Zmumu muons are at the center of "
                                             "BC0, i.e. at 12.5ns+BC0shift w.r.t. RPC readout (BC0shift=2x3.125)"}

Definition at line 168 of file RpcDigitizationTool.h.

                                          {this, "PatchForRpcTimeShift", 12.5,
                                             "shift rpc digit time to match hardware time calibration: Zmumu muons are at the center of "
                                             "BC0, i.e. at 12.5ns+BC0shift w.r.t. RPC readout (BC0shift=2x3.125)"};

m_RPC_TimeSchema

Gaudi::Property<std::string> RpcDigitizationTool::m_RPC_TimeSchema {this, "RPC_TimeSchema", "RPC_TimeSchema", "Tag info name of Rpc Time Info"}

protected

Definition at line 226 of file RpcDigitizationTool.h.

{this, "RPC_TimeSchema", "RPC_TimeSchema", "Tag info name of Rpc Time Info"};

m_RPCHitCollList

std::vector<std::unique_ptr<RPCSimHitCollection> > RpcDigitizationTool::m_RPCHitCollList

private

Definition at line 162 of file RpcDigitizationTool.h.

m_RPCInfoFromDb

Gaudi::Property<bool> RpcDigitizationTool::m_RPCInfoFromDb {this, "RPCInfoFromDb", false, ""}

protected

Definition at line 244 of file RpcDigitizationTool.h.

{this, "RPCInfoFromDb", false, ""};

m_sdo_tmp_map

std::map<Identifier, std::vector<MuonSimData::Deposit> > RpcDigitizationTool::m_sdo_tmp_map

private

Definition at line 165 of file RpcDigitizationTool.h.

m_sdoAreOnlyDigits

Gaudi::Property<bool> RpcDigitizationTool::m_sdoAreOnlyDigits

protected

Initial value:

{this, "RPCSDOareRPCDigits", true,
                                             "decide is SDO deposits are saved for all G4 hits or only for those accepted as digits"}

Definition at line 227 of file RpcDigitizationTool.h.

                                          {this, "RPCSDOareRPCDigits", true,
                                             "decide is SDO deposits are saved for all G4 hits or only for those accepted as digits"};

m_simHitValidKey

SG::WriteHandleKey<RPCSimHitCollection> RpcDigitizationTool::m_simHitValidKey {this, "SimHitValidationKey", "InputRpcHits"}

protected

Definition at line 223 of file RpcDigitizationTool.h.

{this, "SimHitValidationKey", "InputRpcHits"};

m_thpcRPC

std::unique_ptr<TimedHitCollection<RPCSimHit> > RpcDigitizationTool::m_thpcRPC {}

private

Definition at line 163 of file RpcDigitizationTool.h.

{};

m_timeWindowLowerOffset

Gaudi::Property<double> RpcDigitizationTool::m_timeWindowLowerOffset {this, "WindowLowerOffset", -100., "digitization window lower limit"}

private

Definition at line 140 of file RpcDigitizationTool.h.

{this, "WindowLowerOffset", -100., "digitization window lower limit"};

m_timeWindowUpperOffset

Gaudi::Property<double> RpcDigitizationTool::m_timeWindowUpperOffset {this, "WindowUpperOffset", +150., "digitization window lower limit"}

private

Definition at line 141 of file RpcDigitizationTool.h.

{this, "WindowUpperOffset", +150., "digitization window lower limit"};

m_turnON_clustersize

Gaudi::Property<bool> RpcDigitizationTool::m_turnON_clustersize {this, "turnON_clustersize", true, ""}

private

Definition at line 177 of file RpcDigitizationTool.h.

{this, "turnON_clustersize", true, ""};

m_turnON_efficiency

Gaudi::Property<bool> RpcDigitizationTool::m_turnON_efficiency {this, "turnON_efficiency", true, ""}

private

Definition at line 175 of file RpcDigitizationTool.h.

{this, "turnON_efficiency", true, ""};

m_UncorrJitter

Gaudi::Property<double> RpcDigitizationTool::m_UncorrJitter {this, "UncorrJitter", 1.5, "jitter uncorrelated between eta and phi"}

private

Calculates the position of the hit wrt to the strip panel this transformation is needed since the impact point comes from the SD int he gas gap's reference frame.

Definition at line 126 of file RpcDigitizationTool.h.

{this, "UncorrJitter", 1.5, "jitter uncorrelated between eta and phi"};

m_UncorrJitter_BIS78

Gaudi::Property<double> RpcDigitizationTool::m_UncorrJitter_BIS78 {this, "UncorrJitter_BIS78", 0.3, "jitter uncorrelated between eta and phi BIS78"}

private

Definition at line 129 of file RpcDigitizationTool.h.

{this, "UncorrJitter_BIS78", 0.3, "jitter uncorrelated between eta and phi BIS78"};

m_validationSetup

Gaudi::Property<bool> RpcDigitizationTool::m_validationSetup {this, "ValidationSetup", false, ""}

private

Definition at line 172 of file RpcDigitizationTool.h.

{this, "ValidationSetup", false, ""};

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

---

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

• RpcDigitizationTool.h
• RpcDigitizationTool.cxx