ATLAS Offline Software
Public Member Functions | Protected Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
RpcDigitizationTool Class Reference

#include <RpcDigitizationTool.h>

Inheritance diagram for RpcDigitizationTool:
Collaboration diagram for RpcDigitizationTool:

Public Member Functions

 RpcDigitizationTool (const std::string &type, const std::string &name, const IInterface *pIID)
 
virtual StatusCode initialize () override final
 Initialize. More...
 
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. More...
 
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. More...
 
virtual StatusCode mergeEvent (const EventContext &ctx) override final
 When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop. More...
 
virtual StatusCode processAllSubEvents (const EventContext &ctx) override final
 alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents. More...
 

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: More...
 
StatusCode doDigitization (const EventContext &ctx, Collections_t &collections, MuonSimDataCollection *sdoContainer)
 Digitization functionality shared with RPC_PileUpTool. More...
 
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. More...
 
std::array< int, 3 > TurnOnStrips (const MuonGM::RpcReadoutElement *reEle, std::array< int, 3 > &&pcs, const Identifier &id) const
 Cluster simulation: second step. More...
 
double PropagationTime (const MuonGM::RpcReadoutElement *reEle, const Identifier &id, const Amg::Vector3D &globPos) const
 Calculates the propagation time along the strip. More...
 
Amg::Transform3D fromSimHitToLayer (const MuonGM::RpcReadoutElement *readOutEle, const Identifier &layerId) const
 Returns the position of the hit expressed in the gasGap coordinate system. More...
 
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. More...
 
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. More...
 
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 More...
 
virtual StatusCode processAllSubEvents (const EventContext &ctx)=0
 dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...
 
virtual bool filterPassed () const override
 dummy implementation of passing filter More...
 
virtual void resetFilter () override
 dummy implementation of filter reset More...
 

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 92 of file RpcDigitizationTool.cxx.

92  :
93  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 1089 of file RpcDigitizationTool.cxx.

1093  {
1094 
1095 
1096 
1097  ATH_MSG_DEBUG("RpcDigitizationTool::in DetectionEfficiency");
1098 
1099  ATH_MSG_DEBUG("EtaPanelId to look for Eff is " << m_idHelper->show_to_string(IdEta));
1100  ATH_MSG_DEBUG("PhiPanelId to look for Eff is " << m_idHelper->show_to_string(IdPhi));
1101 
1102 
1103  // dead spacers are not simulated in GEANT4 => their effect must be emulated in the digitizer as an effective max. efficiency = 99%
1104  // (spacers are 1x1cm^2 over a grid of 10x10cm^2 =? geometrical ineff. introduced is 1% for normal incidence)
1105  float maxGeomEff{0.99}, PhiAndEtaEff{0.99}, OnlyEtaEff{0.f}, OnlyPhiEff{0.f};
1106 
1107  // 2=BML,3=BMS,4=BOL,5=BOS,8=BMF,9=BOF,10=BOG
1108  int stationName = m_idHelper->stationName(IdEta);
1109  int stationEta = m_idHelper->stationEta(IdEta);
1110  int doubletR = m_idHelper->doubletR(IdEta);
1111 
1112  // remove feet extension. driven by joboption
1113  if (m_BOG_BOF_DoubletR2_OFF && (stationName == m_BOF_id || stationName == m_BOG_id) && doubletR == 2) {
1114  return std::make_pair(false, false);
1115  }
1116 
1117 
1118  if (!m_turnON_efficiency) {
1119  return std::make_pair(true, true);
1120  }
1121  bool etaStripOn{true}, phiStripOn{true};
1122 
1123  // int stripetadead = 0 ; // not used
1124  // int stripphidead = 0 ; // not used
1125 
1126  unsigned int index = stationName - 2;
1127  // BML and BMS, BOL and BOS come first (stationName= 2 and 3, 4 and 5 -> index 0-3)
1128  if (stationName > 5 && stationName < 50) index = index - 2;
1129  // BMF, BOF and BOG are 8,9,10 => must be 4,5 and 6
1130  else if (stationName > 50)
1131  index = index - 44;
1132  // BME and BOE 53 and 54 are at indices 7 and 8
1133 
1134  if (!m_Efficiency_fromCOOL && stationName >= 2) {
1135  if (index > m_PhiAndEtaEff_A.size() || index > m_OnlyEtaEff_A.size() || index > m_OnlyPhiEff_A.size()) {
1136  THROW_EXCEPTION("Index out of array in Detection Efficiency SideA " << index << " stationName = " << stationName);
1137  }
1138 
1139  PhiAndEtaEff = m_PhiAndEtaEff_A[index];
1140  OnlyEtaEff = m_OnlyEtaEff_A[index];
1141  OnlyPhiEff = m_OnlyPhiEff_A[index];
1142 
1143  if (stationEta < 0) {
1144  if (index > m_PhiAndEtaEff_C.size() || index > m_OnlyEtaEff_C.size() || index > m_OnlyPhiEff_C.size()) {
1145  THROW_EXCEPTION("Index out of array in Detection Efficiency SideC " << index << " stationName = " << stationName);
1146  }
1147  PhiAndEtaEff = m_PhiAndEtaEff_C[index];
1148  OnlyEtaEff = m_OnlyEtaEff_C[index];
1149  OnlyPhiEff = m_OnlyPhiEff_C[index];
1150  }
1151  } else if (stationName < 2 && (!m_Efficiency_fromCOOL || !m_Efficiency_BIS78_fromCOOL)) { // BIS
1152  PhiAndEtaEff = m_PhiAndEtaEff_BIS78;
1153  OnlyEtaEff = m_OnlyEtaEff_BIS78;
1154  OnlyPhiEff = m_OnlyPhiEff_BIS78;
1155  } else { // Efficiency from Cool
1156 
1157  const RpcCondDbData* readCdo{nullptr};
1158  if(!retrieveCondData(ctx, m_readKey, readCdo).isSuccess()){
1159  THROW_EXCEPTION("Failed to retrieve conditions object");
1160  }
1161 
1162  ATH_MSG_DEBUG("Efficiencies and cluster size + dead strips will be extracted from COOL");
1163 
1164  double FracDeadStripEta{0.}, FracDeadStripPhi{0.};
1165  double EtaPanelEfficiency{1.}, PhiPanelEfficiency{1.}, GapEfficiency{1.};
1166  int RPC_ProjectedTracksEta = 0;
1167 
1168  std::optional<double> fracDeadStripEtaFromCOOL = readCdo->getFracDeadStrip(IdEta);
1169  std::optional<double> fracDeadStripPhiFromCOOL = readCdo->getFracDeadStrip(IdPhi);
1170 
1171  bool noEntryInDb = !fracDeadStripEtaFromCOOL || !fracDeadStripPhiFromCOOL;
1172 
1173  FracDeadStripEta = fracDeadStripEtaFromCOOL.value_or(0.);
1174  FracDeadStripPhi = fracDeadStripPhiFromCOOL.value_or(0.);
1175  RPC_ProjectedTracksEta = readCdo->getProjectedTrack(IdEta).value_or(0);
1176 
1177  EtaPanelEfficiency = readCdo->getEfficiency(IdEta).value_or(1.);
1178  PhiPanelEfficiency = readCdo->getEfficiency(IdPhi).value_or(1.);
1179  GapEfficiency = readCdo->getGapEfficiency(IdEta).value_or(1.);
1180 
1181  if (std::abs(FracDeadStripEta - 1.) < 0.001) {
1182  ATH_MSG_DEBUG("Watch out: SPECIAL CASE: Read from Cool: FracDeadStripEta/Phi "
1183  << FracDeadStripEta << "/" << FracDeadStripPhi << " RPC_ProjectedTracksEta " << RPC_ProjectedTracksEta
1184  << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency << "/" << PhiPanelEfficiency << " gapEff " << GapEfficiency
1185  << " for gas gap " << m_idHelper->show_to_string(IdEta) << " id " << IdEta.get_identifier32().get_compact());
1186  // dead eta panel => cannot determine the strip status for phi strips
1187  // FracDeadStripPhi must be reset to 0. and undefinedPhiStripStatus = true
1188  FracDeadStripPhi = 0.;
1189  ATH_MSG_VERBOSE("Watch out: SPECIAL CASE: Resetting FracDeadStripPhi " << FracDeadStripPhi << " ignoring phi dead strips ");
1190  }
1191 
1192  // special test
1193  // here redefining the efficiencies:
1194  // EtaPanelEfficiency = 0.92;
1195  // PhiPanelEfficiency = 0.85;
1196  // GapEfficiency = 0.97;
1197  bool changing = false;
1198  ATH_MSG_DEBUG("Read from Cool: FracDeadStripEta/Phi " << FracDeadStripEta << "/" << FracDeadStripPhi << " RPC_ProjectedTracksEta "
1199  << RPC_ProjectedTracksEta << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency
1200  << "/" << PhiPanelEfficiency << " gapEff " << GapEfficiency);
1201  // if ((1.-FracDeadStripEta)<EtaPanelEfficiency)
1202  if ((maxGeomEff - FracDeadStripEta) - EtaPanelEfficiency < -0.011) {
1203  ATH_MSG_DEBUG("Ineff. from dead strips on Eta Panel larger that measured efficiency: deadFrac="
1204  << FracDeadStripEta << " Panel Eff=" << EtaPanelEfficiency << " for Panel " << m_idHelper->show_to_string(IdEta));
1205  ATH_MSG_DEBUG("... see the corresponding report from RpcDetectorStatusDbTool");
1206  // EtaPanelEfficiency = 1.-FracDeadStripEta;
1207  EtaPanelEfficiency = maxGeomEff - FracDeadStripEta;
1208  changing = true;
1209  }
1210  // if ((1.-FracDeadStripPhi)<PhiPanelEfficiency)
1211  if ((maxGeomEff - FracDeadStripPhi) - PhiPanelEfficiency < -0.011) {
1212  ATH_MSG_DEBUG("Ineff. from dead strips on Phi Panel larger that measured efficiency: deadFrac="
1213  << FracDeadStripPhi << " Panel Eff=" << PhiPanelEfficiency << " for Panel " << m_idHelper->show_to_string(IdPhi));
1214  ATH_MSG_DEBUG("... see the corresponding report among the warnings of RpcDetectorStatusDbTool");
1215  // PhiPanelEfficiency = 1.-FracDeadStripPhi;
1216  PhiPanelEfficiency = maxGeomEff - FracDeadStripPhi;
1217  changing = true;
1218  }
1219  // if ((1.-FracDeadStripEta*FracDeadStripPhi)<GapEfficiency)
1220  if ((maxGeomEff - FracDeadStripEta * FracDeadStripPhi) - GapEfficiency < -0.011) {
1221  ATH_MSG_DEBUG("Ineff. from dead strips on Eta/Phi Panels larger that measured EtaORPhi efficiency: deadFrac="
1222  << FracDeadStripEta * FracDeadStripPhi << " EtaORPhi Eff=" << GapEfficiency << " for GasGap "
1223  << m_idHelper->show_to_string(IdEta));
1224  ATH_MSG_DEBUG("... see the corresponding report among the warnings of RpcDetectorStatusDbTool");
1225  // GapEfficiency = 1.-FracDeadStripEta*FracDeadStripPhi;
1226  GapEfficiency = maxGeomEff - FracDeadStripEta * FracDeadStripPhi;
1227  changing = true;
1228  }
1229  if (changing)
1230  ATH_MSG_DEBUG("Rinormalized Values from Cool: FracDeadStripEta/Phi "
1231  << FracDeadStripEta << "/" << FracDeadStripPhi << " RPC_ProjectedTracksEta " << RPC_ProjectedTracksEta
1232  << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency << "/" << PhiPanelEfficiency << " gapEff " << GapEfficiency);
1233 
1234  // gabriele //..stefania - if there are dead strips renormalize the eff. to the active area
1235  if (m_kill_deadstrips) {
1236  if ((FracDeadStripEta > 0.0 && FracDeadStripEta < 1.0) || (FracDeadStripPhi > 0.0 && FracDeadStripPhi < 1.0) || (noEntryInDb)) {
1237  EtaPanelEfficiency = EtaPanelEfficiency / (maxGeomEff - FracDeadStripEta);
1238  PhiPanelEfficiency = PhiPanelEfficiency / (maxGeomEff - FracDeadStripPhi);
1239  GapEfficiency = GapEfficiency / (maxGeomEff - FracDeadStripEta * FracDeadStripPhi);
1240 
1241  if (EtaPanelEfficiency > maxGeomEff) EtaPanelEfficiency = maxGeomEff;
1242  if (PhiPanelEfficiency > maxGeomEff) PhiPanelEfficiency = maxGeomEff;
1243  if (GapEfficiency > maxGeomEff) GapEfficiency = maxGeomEff;
1244 
1245  if (EtaPanelEfficiency > GapEfficiency) GapEfficiency = EtaPanelEfficiency;
1246  if (PhiPanelEfficiency > GapEfficiency) GapEfficiency = PhiPanelEfficiency;
1247  ATH_MSG_DEBUG("Eff Redefined (to correct for deadfrac): FracDeadStripEta/Phi "
1248  << " Eta/PhiPanelEfficiency " << EtaPanelEfficiency << "/" << PhiPanelEfficiency << " gapEff "
1249  << GapEfficiency);
1250  }
1251  }
1252 
1253  // values from COOLDB (eventually overwritten later)
1254  PhiAndEtaEff = float(EtaPanelEfficiency + PhiPanelEfficiency - GapEfficiency);
1255  if (PhiAndEtaEff < 0.) PhiAndEtaEff = 0.;
1256  OnlyEtaEff = float(EtaPanelEfficiency - PhiAndEtaEff);
1257  if (OnlyEtaEff < 0.) OnlyEtaEff = 0.;
1258  OnlyPhiEff = float(PhiPanelEfficiency - PhiAndEtaEff);
1259  if (OnlyPhiEff < 0.) OnlyPhiEff = 0.;
1260 
1261  // special patch to be true only when m_Efficiency_fromCOOL=true and /RPC/DQMF/ELEMENT_STATUS tag is
1262  // RPCDQMFElementStatus_2012_Jaunuary_26
1263  bool applySpecialPatch = false;
1264  if (m_EfficiencyPatchForBMShighEta && m_Efficiency_fromCOOL) {
1265  if (m_idHelper->stationName(IdEta) == 3)
1266  {
1267  if (std::abs(m_idHelper->stationEta(IdEta)) == 6 && m_idHelper->doubletR(IdEta) == 1 &&
1268  m_idHelper->doubletZ(IdEta) == 2 && m_idHelper->doubletPhi(IdEta) == 1) {
1269  applySpecialPatch = true;
1270  ATH_MSG_WARNING(
1271  "Applying special patch for BMS at |eta|=6 lowPt plane -dbbZ=2 and dbPhi=1 ... will use default eff. for Id "
1272  << m_idHelper->show_to_string(IdEta));
1273  ATH_MSG_WARNING(
1274  "Applying special patch: THIS HAS TO BE DONE IF /RPC/DQMF/ELEMENT_STATUS tag is "
1275  "RPCDQMFElementStatus_2012_Jaunuary_2");
1276  }
1277  }
1278  }
1279 
1280  // if projected tracks number too low or inconsistent values get efficiencies from joboption and overwrite previous values
1281  if (applySpecialPatch || RPC_ProjectedTracksEta < m_CutProjectedTracks || RPC_ProjectedTracksEta > 10000000 ||
1282  EtaPanelEfficiency > 1 || EtaPanelEfficiency < 0 || PhiPanelEfficiency > 1 || PhiPanelEfficiency < 0 || GapEfficiency > 1 ||
1283  GapEfficiency < 0) {
1284  if (index > m_PhiAndEtaEff_A.size() || index > m_OnlyEtaEff_A.size() || index > m_OnlyPhiEff_A.size()) {
1285  THROW_EXCEPTION("Index out of array in Detection Efficiency SideA COOLDB" << index << " stationName = " << stationName);
1286  }
1287  if (RPC_ProjectedTracksEta < m_CutProjectedTracks)
1288  ATH_MSG_DEBUG("# of proj tracks = " << RPC_ProjectedTracksEta << " < cut = " << m_CutProjectedTracks
1289  << " resetting eff. from cool with default(python) values ");
1290 
1291  PhiAndEtaEff = m_PhiAndEtaEff_A[index];
1292  OnlyEtaEff = m_OnlyEtaEff_A[index];
1293  OnlyPhiEff = m_OnlyPhiEff_A[index];
1294 
1295  if (stationEta < 0) {
1296  if (index > m_PhiAndEtaEff_C.size() || index > m_OnlyEtaEff_C.size() || index > m_OnlyPhiEff_C.size()) {
1297  THROW_EXCEPTION("Index out of array in Detection Efficiency SideC COOLDB" << index << " stationName = " << stationName);
1298  }
1299  PhiAndEtaEff = m_PhiAndEtaEff_C[index];
1300  OnlyEtaEff = m_OnlyEtaEff_C[index];
1301  OnlyPhiEff = m_OnlyPhiEff_C[index];
1302  }
1303 
1304  // if (m_applyEffThreshold) {
1305  // gabriele Set efficiency from dead strip fraction instead of nominal value
1306  float effgap = PhiAndEtaEff + OnlyEtaEff + OnlyPhiEff;
1307  float s_EtaPanelEfficiency = 1. - FracDeadStripEta;
1308  float s_PhiPanelEfficiency = 1. - FracDeadStripPhi;
1309  float s_PhiAndEtaEff = s_EtaPanelEfficiency * s_PhiPanelEfficiency / effgap;
1310  if (s_PhiAndEtaEff < PhiAndEtaEff) PhiAndEtaEff = s_PhiAndEtaEff;
1311  float s_OnlyEtaEff = s_EtaPanelEfficiency - PhiAndEtaEff;
1312  float s_OnlyPhiEff = s_PhiPanelEfficiency - PhiAndEtaEff;
1313 
1314  if (s_OnlyEtaEff < OnlyEtaEff) OnlyEtaEff = s_OnlyEtaEff;
1315  if (s_OnlyPhiEff < OnlyPhiEff) OnlyPhiEff = s_OnlyPhiEff;
1316  // }
1317  }
1318 
1319  float VolEff = PhiAndEtaEff + OnlyEtaEff + OnlyPhiEff;
1320  if (VolEff > maxGeomEff) {
1321  PhiAndEtaEff = (PhiAndEtaEff / VolEff) * maxGeomEff;
1322  OnlyEtaEff = (OnlyEtaEff / VolEff) * maxGeomEff;
1323  OnlyPhiEff = (OnlyPhiEff / VolEff) * maxGeomEff;
1324  }
1325 
1326  } // End eff from COOL
1327 
1328  // Efficiency correction factor for fractional-charged particles(added by Quanyin Li: quli@cern.ch)
1329  // link to truth particles and calculate the charge and betagamma
1330  HepMC::ConstGenParticlePtr genparticle = trkParticle.cptr();
1331  if (genparticle) {
1332  // only apply efficiency correction to fractional-charged particles based on pdgId betagamma
1333  if (MC::isGenericMultichargedParticle(genparticle)) {
1334  const double eff_sf = FCPEfficiency(genparticle);
1335  // Apply scale factor to the 3 Eff.
1336  PhiAndEtaEff = PhiAndEtaEff * eff_sf;
1337  OnlyEtaEff = OnlyEtaEff * eff_sf;
1338  OnlyPhiEff = OnlyPhiEff * eff_sf;
1339  }
1340  }
1341 
1342  float I0 = PhiAndEtaEff;
1343  float I1 = PhiAndEtaEff + OnlyEtaEff;
1344  float ITot = PhiAndEtaEff + OnlyEtaEff + OnlyPhiEff;
1345 
1346  float GapEff = ITot ;
1347  float PhiEff = PhiAndEtaEff + OnlyPhiEff;
1348  float EtaEff = PhiAndEtaEff + OnlyEtaEff;
1349 
1350  ATH_MSG_DEBUG("DetectionEfficiency: Final Efficiency Values applied for "
1351  << m_idHelper->show_to_string(IdEta) << " are " << PhiAndEtaEff << "=PhiAndEtaEff " << OnlyEtaEff
1352  << "=OnlyEtaEff " << OnlyPhiEff << "=OnlyPhiEff " << GapEff << "=GapEff " << EtaEff << "=EtaEff " << PhiEff
1353  << "=PhiEff ");
1354 
1355  float rndmEff = CLHEP::RandFlat::shoot(rndmEngine, 1);
1356 
1357  if (rndmEff < I0) {
1358  phiStripOn = true;
1359  etaStripOn = true;
1360  } else if ((I0 <= rndmEff) && (rndmEff < I1)) {
1361  phiStripOn = false;
1362  etaStripOn = true;
1363  } else if ((I1 <= rndmEff) && (rndmEff <= ITot)) {
1364  phiStripOn = true;
1365  etaStripOn = false;
1366  } else {
1367  phiStripOn = false;
1368  etaStripOn = false;
1369  }
1370 
1371  return std::make_pair(etaStripOn, phiStripOn);
1372 }

◆ determineClusterSize()

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

Definition at line 1375 of file RpcDigitizationTool.cxx.

1378  {
1379  ATH_MSG_DEBUG("RpcDigitizationTool::in determineClusterSize");
1380 
1381  ATH_MSG_DEBUG("Digit Id = " << m_idHelper->show_to_string(idRpcStrip));
1382 
1383  int ClusterSize = 1;
1384 
1385  double FracClusterSize1{1.}, FracClusterSize2{0.}, MeanClusterSize{1.},
1386  FracClusterSizeTail{0.}, MeanClusterSizeTail{1.},
1387  FracClusterSize2norm{0.};
1388 
1389  // 2=BML,3=BMS,4=BOL,5=BOS,8=BMF,9=BOF,10=BOG
1390  int stationName = m_idHelper->stationName(idRpcStrip);
1391  int stationEta = m_idHelper->stationEta(idRpcStrip);
1392  int measuresPhi = m_idHelper->measuresPhi(idRpcStrip);
1393 
1394  unsigned int index = stationName - 2;
1395  // BML and BMS, BOL and BOS come first (stationName= 2 and 3, 4 and 5 -> index 0-3)
1396  if (stationName > 5 && stationName < 50) index = index - 2;
1397  // BMF, BOF and BOG are 8,9,10 => must be 4,5 and 6
1398  else if (stationName > 50)
1399  index = index - 44;
1400  // BME and BOE 53 and 54 are at indices 7 and 8
1401 
1402  if (!m_ClusterSize_fromCOOL && stationName >= 2) {
1403  index += m_FracClusterSize1_A.size() / 2 * measuresPhi;
1404  if (index >= m_FracClusterSize1_A.size() ||
1405  index >= m_FracClusterSize2_A.size() ||
1406  index >= m_FracClusterSizeTail_A.size() ||
1407  index >= m_MeanClusterSizeTail_A.size()) {
1408  ATH_MSG_ERROR("Index out of array in determineClusterSize SideA " << index << " statName " << stationName);
1409  return 1;
1410  }
1411  FracClusterSize1 = m_FracClusterSize1_A[index];
1412  FracClusterSize2 = m_FracClusterSize2_A[index];
1413  FracClusterSizeTail = m_FracClusterSizeTail_A[index];
1414  MeanClusterSizeTail = m_MeanClusterSizeTail_A[index];
1415 
1416  if (stationEta < 0) {
1417  index += m_FracClusterSize1_C.size() / 2 * measuresPhi - m_FracClusterSize1_A.size() / 2 * measuresPhi;
1418  if (index >= m_FracClusterSize1_C.size() ||
1419  index >= m_FracClusterSize2_C.size() ||
1420  index >= m_FracClusterSizeTail_C.size() ||
1421  index >= m_MeanClusterSizeTail_C.size()) {
1422  ATH_MSG_ERROR("Index out of array in determineClusterSize SideC " << index << " statName " << stationName);
1423  return 1;
1424  }
1425  FracClusterSize1 = m_FracClusterSize1_C[index];
1426  FracClusterSize2 = m_FracClusterSize2_C[index];
1427  FracClusterSizeTail = m_FracClusterSizeTail_C[index];
1428  MeanClusterSizeTail = m_MeanClusterSizeTail_C[index];
1429  }
1430  } else if (stationName < 2 && (!m_ClusterSize_fromCOOL || !m_ClusterSize_BIS78_fromCOOL)) { // BIS78
1431  FracClusterSize1 = m_FracClusterSize1_BIS78;
1432  FracClusterSize2 = m_FracClusterSize2_BIS78;
1433  FracClusterSizeTail = m_FracClusterSizeTail_BIS78;
1434  MeanClusterSizeTail = m_MeanClusterSizeTail_BIS78;
1435  } else { // Cluster size from COOL
1436  const RpcCondDbData* readCdo{nullptr};
1437  retrieveCondData(ctx, m_readKey, readCdo).ignore();
1438 
1439  Identifier Id = m_idHelper->panelID(idRpcStrip);
1440 
1441  int RPC_ProjectedTracks = readCdo->getProjectedTrack(Id).value_or(0);
1442  FracClusterSize1 = readCdo->getFracClusterSize1(Id).value_or(1.);
1443  FracClusterSize2 = readCdo->getFracClusterSize2(Id).value_or(0.);
1444  MeanClusterSize = readCdo->getMeanClusterSize(Id).value_or(1.);
1445 
1446 
1447  ATH_MSG_DEBUG("FracClusterSize1 and 2 " << FracClusterSize1 << " " << FracClusterSize2);
1448 
1449  FracClusterSizeTail = 1. - FracClusterSize1 - FracClusterSize2;
1450 
1451  MeanClusterSizeTail = MeanClusterSize - FracClusterSize1 - 2 * FracClusterSize2;
1452 
1453  ATH_MSG_DEBUG("MeanClusterSizeTail and FracClusterSizeTail " << MeanClusterSizeTail << " " << FracClusterSizeTail);
1454 
1455  // if clustersize have anomalous values set to the average cluster size from joboption
1456  if (RPC_ProjectedTracks < m_CutProjectedTracks || RPC_ProjectedTracks > 10000000 || MeanClusterSize > m_CutMaxClusterSize ||
1457  MeanClusterSize <= 1 || FracClusterSizeTail < 0 || FracClusterSize1 < 0 || FracClusterSize2 < 0 || FracClusterSizeTail > 1 ||
1458  FracClusterSize1 > 1 || FracClusterSize2 > 1) {
1459  if (stationName >= 2) {
1460  index += m_FracClusterSize1_A.size() / 2 * measuresPhi;
1461  if (index >= m_FracClusterSize1_A.size() ||
1462  index >= m_FracClusterSize2_A.size() ||
1463  index >= m_FracClusterSizeTail_A.size() ||
1464  index >= m_MeanClusterSizeTail_A.size()) {
1465  ATH_MSG_ERROR("Index out of array in determineClusterSize SideA " << index << " statName " << stationName);
1466  return 1;
1467  }
1468  FracClusterSize1 = m_FracClusterSize1_A[index];
1469  FracClusterSize2 = m_FracClusterSize2_A[index];
1470  FracClusterSizeTail = m_FracClusterSizeTail_A[index];
1471  MeanClusterSizeTail = m_MeanClusterSizeTail_A[index];
1472 
1473  if (stationEta < 0) {
1474  index += m_FracClusterSize1_C.size() / 2 * measuresPhi - m_FracClusterSize1_A.size() / 2 * measuresPhi;
1475  if (index > m_FracClusterSize1_C.size() || index > m_FracClusterSize2_C.size() ||
1476  index > m_FracClusterSizeTail_C.size() || index > m_MeanClusterSizeTail_C.size()) {
1477  ATH_MSG_ERROR("Index out of array in determineClusterSize SideC " << index << " statName " << stationName);
1478  return 1;
1479  }
1480 
1481  FracClusterSize1 = m_FracClusterSize1_C[index];
1482  FracClusterSize2 = m_FracClusterSize2_C[index];
1483  FracClusterSizeTail = m_FracClusterSizeTail_C[index];
1484  MeanClusterSizeTail = m_MeanClusterSizeTail_C[index];
1485  }
1486  } else {
1487  FracClusterSize1 = m_FracClusterSize1_BIS78;
1488  FracClusterSize2 = m_FracClusterSize2_BIS78;
1489  FracClusterSizeTail = m_FracClusterSizeTail_BIS78;
1490  MeanClusterSizeTail = m_MeanClusterSizeTail_BIS78;
1491  }
1492  }
1493  }
1494  FracClusterSize1 = std::min(FracClusterSize1, 1.);
1495  FracClusterSize2 = std::min(FracClusterSize2, 1.);
1496  FracClusterSizeTail = std::min(FracClusterSizeTail, 1.);
1497  float FracTot = FracClusterSize1 + FracClusterSize2 + FracClusterSizeTail;
1498  if (FracTot != 1. && FracTot > 0) {
1499  FracClusterSize1 = FracClusterSize1 / FracTot;
1500  FracClusterSize2 = FracClusterSize2 / FracTot;
1501  FracClusterSizeTail = FracClusterSizeTail / FracTot;
1502  }
1503  if (MeanClusterSizeTail < 0 || MeanClusterSizeTail > 10) MeanClusterSizeTail = 1;
1504 
1505  ATH_MSG_VERBOSE("ClusterSize Final " << FracClusterSize1 << " FracClusterSize1 " << FracClusterSize2 << " FracClusterSize2 "
1506  << FracClusterSizeTail << " " << FracClusterSizeTail << " MeanClusterSizeTail "
1507  << MeanClusterSizeTail);
1508 
1509  float FracClusterSize1plus2 = FracClusterSize1 + FracClusterSize2;
1510  float ITot = FracClusterSize1 + FracClusterSize2 + FracClusterSizeTail;
1511 
1512  if (FracClusterSize1plus2 != 0) {
1513  // FracClusterSize1norm = FracClusterSize1 / FracClusterSize1plus2 ; // not used
1514  FracClusterSize2norm = FracClusterSize2 / FracClusterSize1plus2;
1515  }
1516 
1517  float rndmCS = CLHEP::RandFlat::shoot(rndmEngine, ITot);
1518 
1519  if (stationName >= 2) { // Legacy RPCs
1520  // Expanded CS2 of 1.3 to match average CS1 and CS2 (to be investigate)
1521  if (rndmCS < FracClusterSize1plus2) {
1522  // deterministic assignment of CS 1 or 2
1523  if (xstripnorm <= FracClusterSize2norm / 2. * 1.3) {
1524  ClusterSize = -2;
1525  } else if ((1.0 - FracClusterSize2norm / 2. * 1.3) <= xstripnorm) {
1526  ClusterSize = 2;
1527  } else {
1528  ClusterSize = 1;
1529  }
1530  if (m_ClusterSize1_2uncorr) {
1531  float rndmCS1_2 = CLHEP::RandFlat::shoot(rndmEngine, 1);
1532  ClusterSize = 1 + (rndmCS1_2 < FracClusterSize2norm);
1533  }
1534 
1535  } else if ((FracClusterSize1plus2 <= rndmCS) && (rndmCS <= ITot)) {
1536  ClusterSize = m_FirstClusterSizeInTail;
1537  ClusterSize += int(CLHEP::RandExponential::shoot(rndmEngine, MeanClusterSizeTail));
1538  float rndmLR = CLHEP::RandFlat::shoot(rndmEngine, 1.0);
1539  if (rndmLR > 0.5) ClusterSize = -ClusterSize;
1540  } else {
1541  ClusterSize = 1;
1542  }
1543 
1544  } else { // NRPCs
1545  if (rndmCS < FracClusterSize1) {
1546  ClusterSize = 1;
1547  } else if (rndmCS < FracClusterSize1 + FracClusterSize2) {
1548  ClusterSize = 2;
1549  } else {
1550  ClusterSize = int(CLHEP::RandExponential::shoot(rndmEngine, MeanClusterSizeTail));
1551  }
1552  ClusterSize = std::max(ClusterSize, 1);
1553  if (ClusterSize > 1) {
1554  float rndmLR = CLHEP::RandFlat::shoot(rndmEngine, 1.0);
1555  if (rndmLR > 0.5) ClusterSize = -ClusterSize;
1556  }
1557  }
1558 
1559  // negative CS correspond to left asymmetric cluster with respect to nstrip
1560  return ClusterSize;
1561 }

◆ 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 481 of file RpcDigitizationTool.cxx.

483  {
484  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
485  rngWrapper->setSeed(name(), ctx);
486  CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);
487 
488  const MuonGM::MuonDetectorManager* detMgr{nullptr};
489  ATH_CHECK(retrieveCondData(ctx, m_detMgrKey, detMgr));
490 
491 
492  std::unique_ptr<RPCSimHitCollection> inputSimHitColl{std::make_unique<RPCSimHitCollection>("RPC_Hits")};
493 
494 
495  // get the iterator pairs for this DetEl
496  // iterate over hits
497  TimedHitCollection<RPCSimHit>::const_iterator i, e;
498 
499  // Perform null check on m_thpcRPC
500  if (!m_thpcRPC) {
501  ATH_MSG_ERROR("m_thpcRPC is null");
502  return StatusCode::FAILURE;
503  }
504 
505  struct SimDataContent {
506  Identifier channelId{};
507  std::vector<MuonSimData::Deposit> deposits;
508  Amg::Vector3D gpos{Amg::Vector3D::Zero()};
509  double simTime{0.};
510  };
511 
512  while (m_thpcRPC->nextDetectorElement(i, e)) {
513  // to store the a single
514 
515  std::map<Identifier, SimDataContent> channelSimDataMap;
516 
517  // Loop over the hits:
518  while (i != e) {
519  ATH_MSG_DEBUG("RpcDigitizationTool::loop over the hits");
520 
521  TimedHitPtr<RPCSimHit> phit(*i++);
522 
523  // the hit
524  const RPCSimHit& hit(*phit);
525  // the hit id
526  const int idHit = hit.RPCid();
527  // the global time (G4 time + bunch time)
528  const double globalHitTime{hitTime(phit)};
529  // the G4 time or TOF from IP
530  const double G4Time{hit.globalTime()};
531  // the bunch time
532  const double bunchTime{globalHitTime - hit.globalTime()};
533 
534  ATH_MSG_DEBUG("Global time " << globalHitTime << " G4 time " << G4Time << " Bunch time " << bunchTime);
535 
536  if (!m_simHitValidKey.empty()) {
537  ATH_MSG_VERBOSE("Validation: globalHitTime, G4Time, BCtime = " << globalHitTime << " " << G4Time << " " << bunchTime);
538  inputSimHitColl->Emplace(idHit, globalHitTime, hit.localPosition(),
539  HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx), // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
540  hit.postLocalPosition(),
541  hit.energyDeposit(), hit.stepLength(), hit.particleEncoding(), hit.kineticEnergy());
542  }
543 
544  // convert sim id helper to offline id
545  const std::string stationName = m_muonHelper->GetStationName(idHit);
546  const int stationEta = m_muonHelper->GetZSector(idHit);
547  const int stationPhi = m_muonHelper->GetPhiSector(idHit);
548  const int doubletR = m_muonHelper->GetDoubletR(idHit);
549  const int doubletZ = m_muonHelper->GetDoubletZ(idHit);
550  const int doubletPhi = m_muonHelper->GetDoubletPhi(idHit);
551  int gasGap = m_muonHelper->GetGasGapLayer(idHit);
552 
553  if (m_muonHelper->GetMeasuresPhi(idHit)) continue; // Skip phi strip . To be created after efficiency evaluation
554 
555 
556  bool isValid{false};
557  const Identifier elementID = m_idHelper->elementID(stationName,stationEta,stationPhi,doubletR, isValid);
558  if (!isValid) {
559  ATH_MSG_WARNING("Failed to construct the element ID from "<<stationName
560  <<", stationEta: "<<stationEta<<", stationPhi: "<<stationPhi<<", doubletR: "<<doubletR);
561  continue;
562  }
563  // construct Atlas identifier from components
564  ATH_MSG_DEBUG("creating id for hit in element:"
565  << " stationName " << stationName << " stationEta " << stationEta << " stationPhi " << stationPhi << " doubletR "
566  << doubletR << " doubletZ " << doubletZ << " doubletPhi " << doubletPhi << " gasGap " << gasGap);
567  const Identifier detElId{m_idHelper->channelID(elementID, doubletZ, doubletPhi, 1,0, 1, isValid)};
568  if (!isValid) {
569  continue;
570  }
571  const RpcReadoutElement* reEle = detMgr->getRpcReadoutElement(detElId);
573  if (false && reEle->rotatedRpcModule()) {
574  gasGap = gasGap == 1 ? 2 : 1;
575  }
576 
577 
578  bool isValidEta{false}, isValidPhi{false};
579  const Identifier idpaneleta = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 0, 1, isValidEta);
580  const Identifier idpanelphi = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 1, 1, isValidPhi);
581  if (!isValidEta || !isValidPhi) {
582  ATH_MSG_WARNING("Found an invalid identifier "
583  << " stationName " << stationName << " stationEta " << stationEta << " stationPhi " << stationPhi
584  << " doubletR " << doubletR << " doubletZ " << doubletZ << " doubletPhi " << doubletPhi << " gasGap "
585  << gasGap);
586  continue;
587  }
588  // loop on eta and phi to apply correlated efficiency between the two views
589 
591  const double tmp_CorrJitter = m_idHelper->stationName(idpaneleta) < 2 ? m_CorrJitter_BIS78 : m_CorrJitter;
593  const double corrtimejitter = tmp_CorrJitter > 0.01 ?
594  CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0., tmp_CorrJitter) : 0.; // correlated jitter
595  // handle here the special case where eta panel is dead => phi strip status (dead or eff.) cannot be resolved;
596  // measured panel eff. will be used in that case and no phi strip killing will happen
597 
598 
599  // Extrapolate the hit to the gas gap centre located at x=0
600  const Amg::Vector3D hitDir{(hit.postLocalPosition() - hit.localPosition()).unit()};
601  const Amg::Vector3D gapCentre = hit.localPosition() +
602  Amg::intersect<3>(hit.localPosition(), hitDir, Amg::Vector3D::UnitX(), 0).value_or(0) * hitDir;
603 
604  std::array<int, 3> pcseta = physicalClusterSize(ctx, reEle, idpaneleta, gapCentre, rndmEngine); // set to one for new algorithms
605  ATH_MSG_VERBOSE("Simulated cluster on eta panel: size/first/last= " << pcseta[0] << "/" << pcseta[1] << "/" << pcseta[2]);
606  std::array<int, 3> pcsphi = physicalClusterSize(ctx, reEle, idpanelphi, gapCentre, rndmEngine); // set to one for new algorithms
607  ATH_MSG_VERBOSE("Simulated cluster on phi panel: size/first/last= " << pcsphi[0] << "/" << pcsphi[1] << "/" << pcsphi[2]);
608 
609 
610 
611  // create Identifiers
612  const Identifier atlasRpcIdeta = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 0, pcseta[1], isValidEta);
613  const Identifier atlasRpcIdphi = m_idHelper->channelID(elementID, doubletZ, doubletPhi, gasGap, 1, pcsphi[1], isValidPhi);
614 
615  const HepMcParticleLink particleLink = HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
616  const auto [etaStripOn, phiStripOn] = detectionEfficiency(ctx, idpaneleta, idpanelphi, rndmEngine, particleLink);
617  ATH_MSG_DEBUG("SetPhiOn " << phiStripOn << " SetEtaOn " << etaStripOn);
618 
619  for (bool imeasphi : {false, true}) {
620  if (!imeasphi && (!etaStripOn || !isValidEta)) continue;
621  if (imeasphi && (!phiStripOn || !isValidPhi)) continue;
622 
623 
624  // get Identifier and list of clusters for this projection
625  const Identifier& atlasId = !imeasphi ? atlasRpcIdeta : atlasRpcIdphi;
626  std::array<int, 3> pcs{!imeasphi ? pcseta : pcsphi};
627 
628  ATH_MSG_DEBUG("SetOn: stationName " << stationName << " stationEta " << stationEta << " stationPhi " << stationPhi
629  << " doubletR " << doubletR << " doubletZ " << doubletZ << " doubletPhi " << doubletPhi
630  << " gasGap " << gasGap << " measphi " << imeasphi);
631 
632  // pcs contains the cluster size, the first strip number and the last strip number of the cluster
633  pcs = TurnOnStrips(reEle, std::move(pcs), atlasId);
634  if (pcs[2] < 0){
635  continue;
636  }
637 
638  ATH_MSG_DEBUG("Simulated cluster1: size/first/last= " << pcs[0] << "/" << pcs[1] << "/" << pcs[2]);
639 
640 
641  const Amg::Vector3D pos = fromSimHitToLayer(reEle, atlasId) * hit.localPosition();
642  const Amg::Vector3D gpos = reEle->transform(atlasId) * pos;
643 
644  ATH_MSG_VERBOSE(" evt: "<<ctx.eventID().event_number()
645  <<" hit "<<m_idHelper->print_to_string(atlasId)
646  <<" local simHit "<<Amg::toString(hit.localPosition())
647  <<" corrected: "<<Amg::toString(pos)
648  <<" transform: "<<GeoTrf::toString(fromSimHitToLayer(reEle, atlasId))
649  <<" local strip: "<<Amg::toString(reEle->localToGlobalTransf(atlasId).inverse()*reEle->stripPos(atlasId))
650  <<" local strip (II): "<<Amg::toString(reEle->transform(atlasId).inverse()*reEle->stripPos(atlasId))
651  <<" global: "<<Amg::toString(gpos)
652  <<" strip Pos: "<<Amg::toString(reEle->stripPos(atlasId)));
653 
654  // Calculate propagation time along readout strip in seconds
655  double proptime = PropagationTime(reEle, atlasId, gpos);
656 
657  double tns = G4Time + proptime + corrtimejitter; // the time is in nanoseconds
658  ATH_MSG_VERBOSE("TOF+propagation time " << tns << " /s where proptime " << proptime << "/s");
659 
660  double time = tns + bunchTime;
661  ATH_MSG_VERBOSE("final time in ns: BC+TOF+prop " << time << " /ns");
662 
663  // pack propagation time along strip, bunch time and local hit position
664  long long int packedMCword = PackMCTruth(proptime, bunchTime, pos.y(), pos.z());
665  //cppcheck-suppress invalidPointerCast
666  double* b = reinterpret_cast<double*>(&packedMCword);
667 
669  // create here deposit for MuonSimData
670  // MuonMCData first word is the packing of : proptime, bunchTime, posy, posz
671  // MuonMCData second word is the total hit time: bunchcTime+tof+proptime+correlatedJitter / ns
672  MuonSimData::Deposit deposit(particleLink, MuonMCData((*b), time)); // store tof+strip_propagation+corr.jitter
673  // MuonMCData((*b),G4Time+bunchTime+proptime )); // store tof+strip_propagation
674 
675  // Do not store pile-up truth information
676  if (m_includePileUpTruth || !HepMC::ignoreTruthLink(phit->particleLink(), m_vetoPileUpTruthLinks)) {
677  if (std::abs(hit.particleEncoding()) == 13 || hit.particleEncoding() == 0) {
678  if (channelSimDataMap.find(atlasId) == channelSimDataMap.end()) {
679  SimDataContent& content = channelSimDataMap[atlasId];
680  content.channelId = atlasId;
681  content.deposits.push_back(deposit);
682  content.gpos = reEle->transform(atlasId)*
683  fromSimHitToLayer(reEle,atlasId) * gapCentre;
684  content.simTime = hitTime(phit);
685  ATH_MSG_VERBOSE("adding SDO entry: r " << content.gpos.perp() << " z " << content.gpos.z());
686  }
687  }
688  }
689 
690 
691  //---------------------------------------------------------------------
692  // construct new digit and store it in the respective digit collection
693  // --------------------------------------------------------------------
694 
695  // we create one digit-vector/deposit for each strip in the cluster
696  bool isValid{false};
697  for (int clus = pcs[1]; clus <= pcs[2]; ++clus) {
698  Identifier newId = m_idHelper->channelID(stationName, stationEta, stationPhi, doubletR, doubletZ,
699  doubletPhi, gasGap, imeasphi, clus, isValid);
700  if (!isValid) {
701  ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<< "Channel "<< stationName<<" "<<stationEta<<" "<<stationPhi<<" "<< doubletR<<" "<<doubletZ
702  <<" "<< doubletPhi<<" "<< gasGap <<" "<< imeasphi<<" "<< clus<<" is invalid");
703  continue;
704  }
705 
706  if (!m_idHelper->valid(newId)) {
707  if (stationName.find("BI") != std::string::npos) {
708  ATH_MSG_WARNING("Temporary skipping creation of RPC digit for stationName="
709  << stationName << ", eta=" << stationEta << ", phi=" << stationPhi << ", doubletR=" << doubletR
710  << ", doubletZ=" << doubletZ << ", doubletPhi=" << doubletPhi << ", gasGap=" << gasGap
711  << ", measuresPhi=" << imeasphi << ", strip=" << clus << ", cf. ATLASRECTS-6124");
712  return StatusCode::SUCCESS;
713  } else {
714  ATH_MSG_ERROR("Created an invalid id, aborting!");
715  m_idHelper->print(newId);
716  return StatusCode::FAILURE;
717  }
718  }
719 
723  // One identifier but several deposits // name m_sdo_tmp_map is wrong call it m_sdo_map
724  if (m_sdo_tmp_map.find(newId) == m_sdo_tmp_map.end()) {
725  std::vector<MuonSimData::Deposit> newdeps;
726  newdeps.push_back(deposit);
727  m_sdo_tmp_map.insert(std::map<Identifier, std::vector<MuonSimData::Deposit>>::value_type(newId, newdeps));
728  } else {
729  m_sdo_tmp_map[newId].push_back(deposit);
730  }
731  } // end for cluster
732  } // loop on eta and phi
733  } // end loop hits
734 
735  if (m_muonOnlySDOs) {
736  for (auto it = channelSimDataMap.begin(); it != channelSimDataMap.end(); ++it) {
737  MuonSimData simData(it->second.deposits, 0);
738  simData.setPosition(it->second.gpos);
739  simData.setTime(it->second.simTime);
740  auto insertResult = sdoContainer->insert(std::make_pair(it->first, simData));
741  if (!insertResult.second)
742  ATH_MSG_WARNING("Attention: this sdo is not recorded, since the identifier already exists in the sdoContainer map");
743  }
744  }
745 
746  } // end loop detector elements
747 
749 
750  std::map<Identifier, std::vector<MuonSimData::Deposit>>::iterator map_iter = m_sdo_tmp_map.begin();
751  ATH_MSG_DEBUG("Start the digit map loop");
752 
753  for (; map_iter != m_sdo_tmp_map.end(); ++map_iter) {
754  // Identifier
755  const Identifier theId = (*map_iter).first;
756  ATH_MSG_DEBUG("in the map loop: id " << m_idHelper->show_to_string(theId));
757  // Deposit
758  const std::vector<MuonSimData::Deposit> theDeps = (*map_iter).second;
759 
760  // store the SDO from the muon
761  MuonSimData::Deposit theMuon; // useful beacuse it sorts the digits in ascending time.
762  std::multimap<double, MuonSimData::Deposit> times; // extract here time info from deposits.
763 
764  // loop on the vector deposit
765  for (unsigned int k = 0; k < theDeps.size(); k++) {
766  double time = theDeps[k].second.secondEntry();
767  times.insert(std::multimap<double, MuonSimData::Deposit>::value_type(time, theDeps[k]));
768  }
769 
770  // now iterate again over the multimap entries and store digits after dead time applied
771 
772  IdContext rpcContext = m_idHelper->module_context(); // work on chamber context
773 
774  std::multimap<double, MuonSimData::Deposit>::iterator map_dep_iter = times.begin();
775 
776  // loop to suppress digits too close in time (emulate Front-End and CMA dead time)
777  double last_time = -10000; // init to high value
778  for (; map_dep_iter != times.end(); ++map_dep_iter) {
779  double currTime = (*map_dep_iter).first;
780  ATH_MSG_VERBOSE("deposit with time " << currTime);
781 
782  if (!m_muonOnlySDOs && !m_sdoAreOnlyDigits) {
783  // store (before any cut: all G4 hits) in the SDO container
784  // Identifier sdo and digit are the same
785  if (sdoContainer->find(theId) != sdoContainer->end()) // Identifier exist -> increase deposit
786  {
787  std::map<Identifier, MuonSimData>::const_iterator it = sdoContainer->find(theId);
788  std::vector<MuonSimData::Deposit> deps = ((*it).second).getdeposits();
789  deps.push_back((*map_dep_iter).second);
790  } else // Identifier does not exist -> create (Id,deposit)
791  {
792  std::vector<MuonSimData::Deposit> deposits;
793  deposits.push_back((*map_dep_iter).second);
794  std::pair<std::map<Identifier, MuonSimData>::iterator, bool> insertResult =
795  sdoContainer->insert(std::make_pair(theId, MuonSimData(deposits, 0)));
796  if (!insertResult.second)
797  ATH_MSG_ERROR(
798  "Attention TEMP: this sdo is not recorded, since the identifier already exists in the sdoContainer map");
799  }
800  }
801  // apply dead time
802  if (std::abs(currTime - last_time) > (m_deadTime)) {
803  ATH_MSG_DEBUG("deposit with time " << currTime << " is distant enough from previous (if any) hit on teh same strip");
804  last_time = (*map_dep_iter).first;
805 
806  // first add time jitter to the time:
807  double uncorrjitter = 0;
808  double tmp_UncorrJitter = m_UncorrJitter;
809  if (m_idHelper->stationName(theId) < 2) tmp_UncorrJitter = m_UncorrJitter_BIS78;
810  if (tmp_UncorrJitter > 0.01) uncorrjitter = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0., tmp_UncorrJitter);
811  // Historically patch for the cavern background
812  // Now we subtract TOF from IP to assume full time calibrated detector (t=0 for particle from IP at light speed)
813  // We add a time shift to emulate FE global offset
814 
815  const RpcReadoutElement* ele = detMgr->getRpcReadoutElement(theId);
816  Amg::Vector3D posi = ele->stripPos(theId);
817  double tp = m_patch_for_rpc_time ? posi.mag() / Gaudi::Units::c_light : 0.;
818  // Calculate propagation time for a hit at the center of the strip, to be subtructed as well as the nominal TOF
819  double propTimeFromStripCenter = PropagationTime(ele, theId, posi);
820  double newDigit_time = currTime + uncorrjitter + m_rpc_time_shift - tp - propTimeFromStripCenter;
821 
822  double digi_ToT = -1.; // Time over threshold, for Narrow-gap RPCs only
823  if (m_idHelper->stationName(theId) < 2) digi_ToT = timeOverThreshold(rndmEngine); //mn
824 
825  ATH_MSG_VERBOSE("last_time=currTime " << last_time << " jitter " << uncorrjitter << " TOFcorrection " << tp << " shift "
826  << m_rpc_time_shift << " newDigit_time " << newDigit_time);
827 
828  // Apply readout window (sensitive detector time window)
829  bool outsideDigitizationWindow = outsideWindow(newDigit_time);
830  if (outsideDigitizationWindow) {
831  ATH_MSG_VERBOSE("hit outside digitization window - do not produce digits");
832  ATH_MSG_DEBUG("Hit outside time window!!"
833  << " hit time (ns) = " << newDigit_time << " timeWindow = " << m_timeWindowLowerOffset << " / "
834  << m_timeWindowUpperOffset);
835 
836  continue;
837  }
838  // ok, let's store this digit
839  // this is an accepted hit to become digit
840  last_time = (*map_dep_iter).first;
841 
842  std::unique_ptr<RpcDigit> newDigit = std::make_unique<RpcDigit>(theId, newDigit_time, digi_ToT, false);
843 
844  Identifier elemId = m_idHelper->elementID(theId);
845  RpcDigitCollection* digitCollection = nullptr;
846 
847  IdentifierHash coll_hash;
848  if (m_idHelper->get_hash(elemId, coll_hash, &rpcContext)) {
849  ATH_MSG_ERROR("Unable to get RPC hash id from RPC Digit collection "
850  << "context begin_index = " << rpcContext.begin_index()
851  << " context end_index = " << rpcContext.end_index() << " the identifier is ");
852  elemId.show();
853  }
854 
855  // make new digit
856  ATH_MSG_DEBUG("Digit Id = " << m_idHelper->show_to_string(theId) << " digit time " << newDigit_time);
857 
858  // remember new collection.
859  if (coll_hash >= collections.size()) {
860  collections.resize (coll_hash+1);
861  }
862  digitCollection = collections[coll_hash].get();
863  if (!digitCollection) {
864  collections[coll_hash] = std::make_unique<RpcDigitCollection>(elemId, coll_hash);
865  digitCollection = collections[coll_hash].get();
866  }
867  digitCollection->push_back(std::move(newDigit));
868 
869  if (!m_muonOnlySDOs && m_sdoAreOnlyDigits) {
870  // put SDO collection in StoreGate
871  if (sdoContainer->find(theId) != sdoContainer->end()) {
872  std::map<Identifier, MuonSimData>::const_iterator it = sdoContainer->find(theId);
873  std::vector<MuonSimData::Deposit> deps = ((*it).second).getdeposits();
874  deps.push_back((*map_dep_iter).second);
875  } else {
876  std::vector<MuonSimData::Deposit> deposits;
877  deposits.push_back((*map_dep_iter).second);
878  std::pair<std::map<Identifier, MuonSimData>::iterator, bool> insertResult =
879  sdoContainer->insert(std::make_pair(theId, MuonSimData(deposits, 0)));
880  if (!insertResult.second)
881  ATH_MSG_ERROR(
882  "Attention: this sdo is not recorded, since teh identifier already exists in the sdoContainer map");
883  }
884  }
885 
886  } else
887  ATH_MSG_DEBUG("discarding digit due to dead time: " << (*map_dep_iter).first << " " << last_time);
888  }
889 
890  } // loop to suppress digits too close in time ended
891 
892  // reset the pointer if it not null
893  m_thpcRPC.reset();
894  if (!m_simHitValidKey.empty()) {
895  SG::WriteHandle<RPCSimHitCollection> validHandle{m_simHitValidKey, ctx};
896  ATH_CHECK(validHandle.record(std::move(inputSimHitColl)));
897  }
898 
899  return StatusCode::SUCCESS;
900 }

◆ FCPEfficiency()

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

Definition at line 1562 of file RpcDigitizationTool.cxx.

1562  {
1563  double qcharge = 1.;
1564  const int particlePdgId = genParticle->pdg_id();
1565  // charge calculation
1566  qcharge = (static_cast<double>((std::abs(particlePdgId) / 1000) % 100)) / (static_cast<double>((std::abs(particlePdgId) / 10) % 100));
1567  qcharge = ((static_cast<double>((static_cast<int>(qcharge * 100))))) / 100;
1568  if (particlePdgId < 0.0) qcharge = -qcharge;
1569  // BetaGamma calculation
1570  const double QPx = genParticle->momentum().px();
1571  const double QPy = genParticle->momentum().py();
1572  const double QPz = genParticle->momentum().pz();
1573  const double QE = genParticle->momentum().e();
1574  const double QM2 = std::pow(QE, 2) - std::pow(QPx, 2) - std::pow(QPy, 2) - std::pow(QPz, 2);
1575  const double QP = std::hypot(QPx, QPy, QPz);
1576  const double QM = QM2 >=0 ? std::sqrt(QM2) : -1.;
1577 
1578  const double qbetagamma = QM > 0. ? QP / QM : -1.;
1579 
1580  // find the i in the array
1581  int i_e = -1;
1582  for (int i = 0; i < 12; i++) {
1583  if (Charge[i] == std::abs(qcharge)) {
1584  i_e = i;
1585  break;
1586  }
1587  }
1588  int i_v = -99, j_v = 99;
1589  if (qbetagamma != -1) {
1590  for (int i = 0; i < 15; i++) {
1591  if (Velocity[i] <= qbetagamma) { i_v = i; }
1592  }
1593  for (int i = 14; i >= 0; i--) {
1594  if (Velocity[i] >= qbetagamma) { j_v = i; }
1595  }
1596  }
1597  // calculate the efficiency according to charge and velocity. Using linear function to calculate efficiency of a specific velocity
1598  // between velocity1 and velocity2
1599  double eff_fcp = 1.0, eff_muon = 1.0;
1600  if (i_e >= 0 && i_e <= 11) {
1601  if (validIndex(j_v, N_Velocity) && validIndex(i_v, N_Velocity) && (j_v - i_v) == 1) {
1602  const double delta_v = Velocity[i_v] - Velocity[j_v];
1603  eff_fcp = (Eff_garfield[i_e][i_v] - Eff_garfield[i_e][j_v]) / delta_v * qbetagamma +
1604  (Eff_garfield[i_e][j_v] * Velocity[i_v] - Eff_garfield[i_e][i_v] * Velocity[j_v]) / delta_v;
1605  eff_muon = (Eff_garfield[11][i_v] - Eff_garfield[11][j_v]) / delta_v * qbetagamma +
1606  (Eff_garfield[11][j_v] * Velocity[i_v] - Eff_garfield[11][i_v] * Velocity[j_v]) / delta_v;
1607  } else if (i_v == 14 && j_v == 99) {
1608  eff_fcp = Eff_garfield[i_e][14];
1609  eff_muon = Eff_garfield[11][14];
1610  } else if (i_v == -99 && j_v == 0) {
1611  eff_fcp = Eff_garfield[i_e][0];
1612  eff_muon = Eff_garfield[11][0];
1613  } else {
1614  ATH_MSG_WARNING("Wrong particle with unknown velocity! Scale factor is set to be 1.");
1615  }
1616  } else {
1617  ATH_MSG_WARNING("Wrong particle with unknown charge! Scale factor is set to be 1.");
1618  }
1619  // A scale factor is calculated by efficiency of fcp / efficiency of muon(charge==1.0
1620  const double eff_SF = eff_fcp / eff_muon;
1621  return eff_SF;
1622 }

◆ fillTagInfo()

StatusCode RpcDigitizationTool::fillTagInfo ( )
private

Definition at line 1060 of file RpcDigitizationTool.cxx.

1060  {
1061  // get TagInfoMgr
1062  SmartIF<ITagInfoMgr> tagInfoMgr{Gaudi::svcLocator()->service("TagInfoMgr")}; // Tag Info Manager
1063  if (!tagInfoMgr) { return StatusCode::FAILURE; }
1064 
1065  std::string RpctimeSchema = "";
1066  std::stringstream RpctimeShift;
1067  RpctimeShift << (int)m_rpc_time_shift;
1068 
1069  if (m_patch_for_rpc_time) {
1070  RpctimeSchema = "Datalike_TOFoff_TimeShift" + RpctimeShift.str() + "nsec";
1071  } else {
1072  RpctimeSchema = "G4like_TOFon_TimeShift" + RpctimeShift.str() + "nsec";
1073  }
1074 
1075  StatusCode sc = tagInfoMgr->addTag(m_RPC_TimeSchema, RpctimeSchema);
1076 
1077  if (sc.isFailure()) {
1078  ATH_MSG_WARNING(m_RPC_TimeSchema << " " << RpctimeSchema << " not added to TagInfo ");
1079  return sc;
1080  }
1081 
1082  ATH_MSG_DEBUG(m_RPC_TimeSchema << " " << RpctimeSchema << " added to TagInfo ");
1083 
1084  return StatusCode::SUCCESS;
1085 }

◆ filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const
inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

49 { 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 901 of file RpcDigitizationTool.cxx.

902  {
903 
904  Amg::Vector3D lGasGapPos = reEle->localGasGapPos(layerId);
905  if (reEle->NphiStripPanels() != reEle->nGasGapPerLay()) {
906  lGasGapPos.y() =0.;
907  }
908 
912  const bool flip = reEle->numberOfLayers() == 2 &&
913  (m_idHelper->gasGap(layerId) == 2) != reEle->rotatedRpcModule();
914  const Amg::Transform3D fromHitToGap{reEle->transform(layerId).inverse() *
915  reEle->absTransform() * Amg::getTranslate3D(lGasGapPos) *
916  (flip ? Amg::getRotateY3D(180.*Gaudi::Units::deg) : Amg::Transform3D::Identity())};
917  ATH_MSG_VERBOSE("Transformation to go from hit to gap restframe "<<m_idHelper->print_to_string(layerId)
918  <<" "<<Amg::toString(fromHitToGap));
919  return fromHitToGap;
920 }

◆ getNextEvent()

StatusCode RpcDigitizationTool::getNextEvent ( const EventContext &  ctx)
private

Get next event and extract collection of hit collections:

Definition at line 351 of file RpcDigitizationTool.cxx.

351  {
352  ATH_MSG_DEBUG("RpcDigitizationTool::getNextEvent()");
353 
354  // initialize pointer
355  m_thpcRPC.reset();
356 
357  // get the container(s)
358  using TimedHitCollList = PileUpMergeSvc::TimedList<RPCSimHitCollection>::type;
359 
360  // In case of single hits container just load the collection using read handles
361  if (!m_onlyUseContainerName) {
362  SG::ReadHandle<RPCSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
363  if (!hitCollection.isValid()) {
364  ATH_MSG_ERROR("Could not get RPCSimHitCollection container " << hitCollection.name() << " from store "
365  << hitCollection.store());
366  return StatusCode::FAILURE;
367  }
368 
369  // create a new hits collection
370  m_thpcRPC = std::make_unique<TimedHitCollection<RPCSimHit>>(1);
371  m_thpcRPC->insert(0, hitCollection.cptr());
372  ATH_MSG_DEBUG("RPCSimHitCollection found with " << hitCollection->size() << " hits");
373 
374  return StatusCode::SUCCESS;
375  }
376  // this is a list<pair<time_t, DataLink<RPCSimHitCollection> > >
377  TimedHitCollList hitCollList;
378 
379  if (!(m_mergeSvc->retrieveSubEvtsData(m_inputHitCollectionName, hitCollList).isSuccess())) {
380  ATH_MSG_ERROR("Could not fill TimedHitCollList");
381  return StatusCode::FAILURE;
382  }
383  if (hitCollList.empty()) {
384  ATH_MSG_ERROR("TimedHitCollList has size 0");
385  return StatusCode::FAILURE;
386  } else {
387  ATH_MSG_DEBUG(hitCollList.size() << " RPCSimHitCollections with key " << m_inputHitCollectionName << " found");
388  }
389 
390  // create a new hits collection
391  m_thpcRPC = std::make_unique<TimedHitCollection<RPCSimHit>>();
392  // now merge all collections into one
393  TimedHitCollList::iterator iColl(hitCollList.begin());
394  TimedHitCollList::iterator endColl(hitCollList.end());
395  while (iColl != endColl) {
396  const RPCSimHitCollection* p_collection(iColl->second);
397  m_thpcRPC->insert(iColl->first, p_collection);
398  // if ( m_debug ) ATH_MSG_DEBUG ( "RPCSimHitCollection found with "
399  // << p_collection->size() << " hits" ); // loop on the hit collections
400  ++iColl;
401  }
402  return StatusCode::SUCCESS;
403 }

◆ initialize()

StatusCode RpcDigitizationTool::initialize ( )
finaloverridevirtual

Initialize.

Reimplemented from PileUpToolBase.

Definition at line 97 of file RpcDigitizationTool.cxx.

97  {
98  ATH_MSG_DEBUG("RpcDigitizationTool:: in initialize()");
99  ATH_MSG_DEBUG("Configuration RpcDigitizationTool ");
100 
101  ATH_MSG_DEBUG("InputObjectName " << m_inputHitCollectionName);
102  ATH_MSG_DEBUG("OutputObjectName " << m_outputDigitCollectionKey.key());
103  ATH_MSG_DEBUG("OutputSDOName " << m_outputSDO_CollectionKey.key());
104  ATH_MSG_DEBUG("WindowLowerOffset " << m_timeWindowLowerOffset);
105  ATH_MSG_DEBUG("WindowUpperOffset " << m_timeWindowUpperOffset);
106  ATH_MSG_DEBUG("DeadTime " << m_deadTime);
107  ATH_MSG_DEBUG("RndmSvc " << m_rndmSvc);
108  ATH_MSG_DEBUG("PatchForRpcTime " << m_patch_for_rpc_time);
109  ATH_MSG_DEBUG("RpcTimeShift " << m_rpc_time_shift);
110  ATH_MSG_DEBUG("RPC_TimeSchema " << m_RPC_TimeSchema);
111  ATH_MSG_DEBUG("RPCSDOareRPCDigits " << m_sdoAreOnlyDigits);
112 
113  ATH_MSG_DEBUG("IgnoreRunDependentConfig " << m_ignoreRunDepConfig);
114  ATH_MSG_DEBUG("turnON_efficiency " << m_turnON_efficiency);
115  ATH_MSG_DEBUG("Efficiency_fromCOOL " << m_Efficiency_fromCOOL);
116  ATH_MSG_DEBUG("Efficiency_BIS78_fromCOOL" << m_Efficiency_BIS78_fromCOOL);
117  ATH_MSG_DEBUG("turnON_clustersize " << m_turnON_clustersize);
118  ATH_MSG_DEBUG("ClusterSize_fromCOOL " << m_ClusterSize_fromCOOL);
119  ATH_MSG_DEBUG("ClusterSize_BIS78_fromCOOL" << m_ClusterSize_BIS78_fromCOOL);
120  ATH_MSG_DEBUG("FirstClusterSizeInTail " << m_FirstClusterSizeInTail);
121  ATH_MSG_DEBUG("ClusterSize1_2uncorr " << m_ClusterSize1_2uncorr);
122  ATH_MSG_DEBUG("BOG_BOF_DoubletR2_OFF " << m_BOG_BOF_DoubletR2_OFF);
123  ATH_MSG_DEBUG("CutMaxClusterSize " << m_CutMaxClusterSize);
124  ATH_MSG_DEBUG("CutProjectedTracks " << m_CutProjectedTracks);
125  ATH_MSG_DEBUG("ValidationSetup " << m_validationSetup);
126  ATH_MSG_DEBUG("IncludePileUpTruth " << m_includePileUpTruth);
127  ATH_MSG_DEBUG("VetoPileUpTruthLinks " << m_vetoPileUpTruthLinks);
128 
129  ATH_CHECK(m_detMgrKey.initialize());
130  if (m_onlyUseContainerName) { ATH_CHECK(m_mergeSvc.retrieve()); }
131  ATH_CHECK(detStore()->retrieve(m_idHelper));
132  // check the identifiers
133 
134  ATH_MSG_INFO("Max Number of RPC Gas Gaps for these Identifiers = " << m_idHelper->gasGapMax());
135 
136  // check the input object name
137  if (m_hitsContainerKey.key().empty()) {
138  ATH_MSG_FATAL("Property InputObjectName not set !");
139  return StatusCode::FAILURE;
140  }
141  if (m_onlyUseContainerName) m_inputHitCollectionName = m_hitsContainerKey.key();
142  ATH_MSG_DEBUG("Input objects in container : '" << m_inputHitCollectionName << "'");
143 
144  // Initialize ReadHandleKey
145  ATH_CHECK(m_hitsContainerKey.initialize());
146 
147  // initialize the output WriteHandleKeys
148  ATH_CHECK(m_outputDigitCollectionKey.initialize());
149  ATH_CHECK(m_outputSDO_CollectionKey.initialize());
150  ATH_CHECK(m_simHitValidKey.initialize(m_validationSetup));
151  ATH_MSG_DEBUG("Output digits: '" << m_outputDigitCollectionKey.key() << "'");
152 
153  // set the configuration based on run1/run2
154  ATH_CHECK(initializeRunDependentParameters());
155 
156  ATH_MSG_DEBUG("Ready to read parameters for cluster simulation from file");
157 
158  ATH_CHECK(m_rndmSvc.retrieve());
159 
160  // fill the taginfo information
161  ATH_CHECK(fillTagInfo());
162 
163  ATH_CHECK(m_readKey.initialize(m_RPCInfoFromDb));
164 
166  // m_turnON_clustersize=false;
167  m_BOF_id = m_idHelper->stationNameIndex("BOF");
168  m_BOG_id = m_idHelper->stationNameIndex("BOG");
169  m_BOS_id = m_idHelper->stationNameIndex("BOS");
170  m_BIL_id = m_idHelper->stationNameIndex("BIL");
171  m_BIS_id = m_idHelper->stationNameIndex("BIS");
172  m_muonHelper = RpcHitIdHelper::GetHelper(m_idHelper->gasGapMax());
173 
174  return StatusCode::SUCCESS;
175 }

◆ initializeRunDependentParameters()

StatusCode RpcDigitizationTool::initializeRunDependentParameters ( )
private

Definition at line 177 of file RpcDigitizationTool.cxx.

177  {
178  // TODO This should all be in a conditions Alg
179  // Retrieve geometry config information from the database (RUN1, RUN2, etc...)
180  SmartIF<IGeoModelSvc> geoModel{Gaudi::svcLocator()->service("GeoModelSvc")};
181  if ( !geoModel ) {
182  ATH_MSG_ERROR("Could not locate GeoModelSvc");
183  return StatusCode::FAILURE;
184  }
185 
186  // check the DetDescr version
187  std::string atlasVersion = geoModel->atlasVersion();
188 
189  SmartIF<IRDBAccessSvc> rdbAccess{Gaudi::svcLocator()->service("RDBAccessSvc")};
190  if ( !rdbAccess ) {
191  ATH_MSG_ERROR("Could not locate RDBAccessSvc");
192  return StatusCode::FAILURE;
193  }
194 
195  enum DataPeriod {Unknown, Run1, Run2, Run3, Run4 };
196  DataPeriod run = Unknown;
197 
198  std::string configVal = "";
199 
200  IRDBRecordset_ptr atlasCommonRec = rdbAccess->getRecordsetPtr("AtlasCommon", atlasVersion, "ATLAS");
201  if (atlasCommonRec->size() == 0) {
202  run = Run1;
203  } else {
204  configVal = (*atlasCommonRec)[0]->getString("CONFIG");
205  ATH_MSG_INFO("From DD Database, Configuration is " << configVal);
206  if (configVal == "RUN1") {
207  run = Run1;
208  } else if (configVal == "RUN2") {
209  run = Run2;
210  } else if (configVal == "RUN3") {
211  run = Run3;
212  } else if (configVal == "RUN4") {
213  run = Run4;
214  }
215  if (run == DataPeriod::Unknown) {
216  ATH_MSG_FATAL("Unexpected value for geometry config read from the database: " << configVal);
217  return StatusCode::FAILURE;
218  }
219  }
220  if (run == Run3 && m_idHelper->gasGapMax() < 3)
221  ATH_MSG_WARNING("Run3, configVal = " << configVal << " and GasGapMax =" << m_idHelper->gasGapMax());
222 
223  if (run == Run1)
224  ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN1 or MuonGeometry = R.06");
225  else if (run == Run2)
226  ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN2 or MuonGeometry = R.07");
227  else if (run == Run3)
228  ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN3 or MuonGeometry = R.09");
229  else if (run == Run4)
230  ATH_MSG_INFO("From Geometry DB: MuonSpectrometer configuration is: RUN4 or MuonGeometry = R.10");
231 
232  if (m_ignoreRunDepConfig == false) {
233  m_BOG_BOF_DoubletR2_OFF = false;
234  m_Efficiency_fromCOOL = false;
235  m_ClusterSize_fromCOOL = false;
236  m_RPCInfoFromDb = false;
237  m_kill_deadstrips = false;
238  if (run == Run1) {
239  // m_BOG_BOF_DoubletR2_OFF = true
240  // m_Efficiency_fromCOOL = true
241  // m_ClusterSize_fromCOOL = true
242  m_BOG_BOF_DoubletR2_OFF = true;
243  if (configVal == "RUN1") { // MC12 setup
244  m_Efficiency_fromCOOL = true;
245  m_ClusterSize_fromCOOL = true;
246  m_RPCInfoFromDb = true;
247  m_kill_deadstrips = true;
248  m_CutProjectedTracks = 50;
249  }
250  } else {
251  // m_BOG_BOF_DoubletR2_OFF = false # do not turn off at digitization the hits in the dbR=2 chambers in the feet
252  // m_Efficiency_fromCOOL = false # use common average values in python conf.
253  // m_ClusterSize_fromCOOL = false # use common average values in python conf.
254  m_BOG_BOF_DoubletR2_OFF = false;
255  if (run == Run2) { // MC15c setup
256  m_Efficiency_fromCOOL = true;
257  m_ClusterSize_fromCOOL = true;
258  m_RPCInfoFromDb = true;
259  m_kill_deadstrips = false;
260  m_CutProjectedTracks = 100;
261  } else {
262  ATH_MSG_INFO("Run3/4: configuration parameter not from COOL");
263  m_Efficiency_fromCOOL = false;
264  m_ClusterSize_fromCOOL = false;
265  m_RPCInfoFromDb = false;
266  m_kill_deadstrips = false;
267  }
268  }
269  ATH_MSG_INFO("RPC Run1/2/3-dependent configuration is enforced");
270  } else {
271  ATH_MSG_WARNING("Run1/2/3-dependent configuration is bypassed; be careful with option settings");
272  }
273 
274  ATH_MSG_DEBUG("......RPC Efficiency_fromCOOL " << m_Efficiency_fromCOOL);
275  ATH_MSG_DEBUG("......RPC ClusterSize_fromCOOL " << m_ClusterSize_fromCOOL);
276  ATH_MSG_DEBUG("......RPC BOG_BOF_DoubletR2_OFF " << m_BOG_BOF_DoubletR2_OFF);
277  ATH_MSG_DEBUG("......RPC RPCInfoFromDb " << m_RPCInfoFromDb);
278  ATH_MSG_DEBUG("......RPC KillDeadStrips " << m_kill_deadstrips);
279  ATH_MSG_DEBUG("......RPC CutProjectedTracks " << m_CutProjectedTracks);
280 
281 
282  return StatusCode::SUCCESS;
283 }

◆ 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 406 of file RpcDigitizationTool.cxx.

406  {
407  StatusCode status = StatusCode::SUCCESS;
408 
409  ATH_MSG_DEBUG("RpcDigitizationTool::in mergeEvent()");
410  // create and record the Digit container in StoreGate
411  SG::WriteHandle<RpcDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
412  ATH_CHECK(digitContainer.record(std::make_unique<RpcDigitContainer>(m_idHelper->module_hash_max())));
413  ATH_MSG_DEBUG("RpcDigitContainer recorded in StoreGate.");
414 
415  // Create and record the SDO container in StoreGate
416  SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDO_CollectionKey, ctx);
417  ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
418  ATH_MSG_DEBUG("RpcSDOCollection recorded in StoreGate.");
419 
421  m_sdo_tmp_map.clear();
423 
424  Collections_t collections;
425  status = doDigitization(ctx, collections, sdoContainer.ptr());
426  if (status.isFailure()) { ATH_MSG_ERROR("doDigitization Failed"); }
427  for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
428  if (collections[coll_hash]) {
429  ATH_CHECK( digitContainer->addCollection (collections[coll_hash].release(), coll_hash) );
430  }
431  }
432 
433  // Clean-up
434  m_RPCHitCollList.clear();
435 
436  return status;
437 }

◆ outsideWindow()

bool RpcDigitizationTool::outsideWindow ( double  time) const
inlineprivate

Definition at line 257 of file RpcDigitizationTool.h.

257  {
258  return time < m_timeWindowLowerOffset || time > m_timeWindowUpperOffset;
259 }

◆ PackMCTruth()

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

Definition at line 1009 of file RpcDigitizationTool.cxx.

1009  {
1010  // start with proptime: it is usually ~ns. It comes in ns. We express it in ns/10. use only 8 bits
1011  if (proptime < 0) {
1012  ATH_MSG_WARNING("A poblem: packing a propagation time <0 " << proptime << " redefine it as 0");
1013  proptime = 0.;
1014  }
1015  long long int new_proptime = int(proptime * 10) & 0xff;
1016 
1017  // now tof. it is ~100ns. comes in ns. express it in ns/10. 16 bits needed (0-32768)
1018  // now BC time: it is ~100ns. comes in ns. express it in ns/10. 16 bits needed (0-32768)
1019  // can be negative (=> add 300 ns)
1020 
1021  long long int new_bctime = int((bctime + 300.) * 10.) & 0xffff;
1022 
1023  // posy: ~1000mm comes in mm, write it in mm*10. need 16 bits (0-32768)
1024  // can be negative (=>add 1500 mm)
1025 
1026  long long int new_posy = int((posy + 1500.) * 10.) & 0xffff;
1027 
1028  // posz: ~1000mm comes in mm, write it in mm*10. need 16 bits (0-32768)
1029  // can be negative (=>add 1500 mm)
1030 
1031  long long int new_posz = int((posz + 1500.) * 10.) & 0xffff;
1032 
1033  return (new_proptime + (new_bctime << 8) + (new_posy << 24) + (new_posz << 40));
1034 }

◆ 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 923 of file RpcDigitizationTool.cxx.

927  {
928 
929 
930  std::array<int, 3> result{};
931 
932  const Amg::Vector3D position = fromSimHitToLayer(ele, id) * gapCentre;
933 
934  const int doubletPhi = m_idHelper->doubletPhi(id);
935  const int gasGap = m_idHelper->gasGap(id);
936  const bool measuresPhi = m_idHelper->measuresPhi(id);
937  const double pitch= ele->StripPitch(measuresPhi);
938 
939 
940  const int nstrip = ele->stripNumber(position.block<2,1>(0,0), id);
941  const int numStrips = ele->Nstrips(measuresPhi);
942 
943  result[1] = nstrip;
944  result[2] = nstrip;
945 
946  if (nstrip < 1 || nstrip > numStrips) {
947  return make_array<int, 3>(-1);
948  }
949  const Amg::Vector3D locStripPos = ele->transform(id).inverse()*ele->stripPos(doubletPhi, gasGap, measuresPhi, nstrip);
950  float xstripnorm = (locStripPos -position).x() / pitch ;
951  result[0] = determineClusterSize(ctx, id, xstripnorm, rndmEngine);
952 
953  //
954 
955 
956  if (m_turnON_clustersize == false) result[0] = 1;
957 
958  return result;
959 }

◆ 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 305 of file RpcDigitizationTool.cxx.

305  {
306  ATH_MSG_DEBUG("RpcDigitizationTool::in prepareEvent()");
307 
308  // John's Hacks START
309  m_RPCHitCollList.clear();
310  m_thpcRPC = std::make_unique<TimedHitCollection<RPCSimHit>>();
311  // John's Hacks END
312 
313  return StatusCode::SUCCESS;
314 }

◆ processAllSubEvents() [1/2]

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 440 of file RpcDigitizationTool.cxx.

440  {
441  StatusCode status = StatusCode::SUCCESS;
442 
443  // merging of the hit collection in getNextEvent method
444 
445  ATH_MSG_DEBUG("RpcDigitizationTool::in digitize()");
446 
447  // create and record the Digit container in StoreGate
448  SG::WriteHandle<RpcDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
449  ATH_CHECK(digitContainer.record(std::make_unique<RpcDigitContainer>(m_idHelper->module_hash_max())));
450  ATH_MSG_DEBUG("RpcDigitContainer recorded in StoreGate.");
451 
452  // Create and record the SDO container in StoreGate
453  SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDO_CollectionKey, ctx);
454  ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
455  ATH_MSG_DEBUG("RpcSDOCollection recorded in StoreGate.");
456 
458  m_sdo_tmp_map.clear();
460 
461  if (!m_thpcRPC) {
462  status = getNextEvent(ctx);
463  if (StatusCode::FAILURE == status) {
464  ATH_MSG_INFO("There are no RPC hits in this event");
465  return status; // there are no hits in this event
466  }
467  }
468 
469  Collections_t collections;
470  ATH_CHECK(doDigitization(ctx, collections, sdoContainer.ptr()));
471  for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
472  if (collections[coll_hash]) {
473  ATH_CHECK( digitContainer->addCollection (collections[coll_hash].release(), coll_hash) );
474  }
475  }
476 
477  return status;
478 }

◆ processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents
inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

◆ 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 317 of file RpcDigitizationTool.cxx.

317  {
318  ATH_MSG_DEBUG("RpcDigitizationTool::in processBunchXing()");
319 
320  typedef PileUpMergeSvc::TimedList<RPCSimHitCollection>::type TimedHitCollList;
321  TimedHitCollList hitCollList;
322 
323  if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputHitCollectionName, hitCollList, bunchXing, bSubEvents, eSubEvents).isSuccess()) &&
324  hitCollList.empty()) {
325  ATH_MSG_ERROR("Could not fill TimedHitCollList");
326  return StatusCode::FAILURE;
327  } else {
328  ATH_MSG_VERBOSE(hitCollList.size() << " RPCSimHitCollection with key " << m_inputHitCollectionName << " found");
329  }
330 
331  TimedHitCollList::iterator iColl(hitCollList.begin());
332  TimedHitCollList::iterator endColl(hitCollList.end());
333 
334  // Iterating over the list of collections
335  for (; iColl != endColl; ++iColl) {
336  RPCSimHitCollection* hitCollPtr = new RPCSimHitCollection(*iColl->second);
337  PileUpTimeEventIndex timeIndex(iColl->first);
338 
339  ATH_MSG_DEBUG("RPCSimHitCollection found with " << hitCollPtr->size() << " hits");
340  ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time() << " index: " << timeIndex.index() << " type: " << timeIndex.type());
341 
342  m_thpcRPC->insert(timeIndex, hitCollPtr);
343  m_RPCHitCollList.emplace_back(hitCollPtr);
344  }
345 
346  return StatusCode::SUCCESS;
347 }

◆ 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 993 of file RpcDigitizationTool.cxx.

995  {
996 
997  double distance{0.};
998  if (m_idHelper->measuresPhi(id)) {
999  distance = ele->distanceToPhiReadout(globPos);
1000  } else {
1001  distance = ele->distanceToEtaReadout(globPos);
1002  }
1003 
1004  // distance in mm, SIG_VEL in ns/m
1005  return std::abs(distance * SIG_VEL * 1.e-3);
1006 }

◆ resetFilter()

virtual void PileUpToolBase::resetFilter ( )
inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

51 { 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 286 of file RpcDigitizationTool.cxx.

288  {
289 
290  if (key.empty()) {
291  ATH_MSG_DEBUG("No key has been configured for object "<<typeid(CondType).name()<<". Clear pointer");
292  condPtr = nullptr;
293  return StatusCode::SUCCESS;
294  }
295  SG::ReadCondHandle<CondType> readHandle{key, ctx};
296  if (!readHandle.isValid()){
297  ATH_MSG_FATAL("Failed to load conditions object "<<key.fullKey()<<".");
298  return StatusCode::FAILURE;
299  }
300  condPtr = readHandle.cptr();
301  return StatusCode::SUCCESS;
302 
303 }

◆ timeOverThreshold()

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

Definition at line 1624 of file RpcDigitizationTool.cxx.

1624  {
1625  //mn Time-over-threshold modeled as a narrow and a wide gaussian
1626  //mn based on the fit documented in https://its.cern.ch/jira/browse/ATLASRECTS-7820
1627  constexpr double tot_mean_narrow = 16.;
1628  constexpr double tot_sigma_narrow = 2.;
1629  constexpr double tot_mean_wide = 15.;
1630  constexpr double tot_sigma_wide = 4.5;
1631 
1632  double thetot = 0.;
1633 
1634  if (CLHEP::RandFlat::shoot(rndmEngine)<0.75) {
1635  thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_narrow, tot_sigma_narrow);
1636  } else {
1637  thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_wide, tot_sigma_wide);
1638  }
1639 
1640  return (thetot > 0.) ? thetot : 0.;
1641 }

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

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

◆ 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 962 of file RpcDigitizationTool.cxx.

964  {
965 
966 
967  const int nstrips = ele->Nstrips(m_idHelper->measuresPhi(id));
968 
969  if (pcs[0] == -2) {
970  pcs[1] = pcs[2] - 1;
971  } else if (pcs[0] == 2) {
972  pcs[2] = pcs[1] + 1;
973  } else if (pcs[0] > 2) {
974  pcs[1] = pcs[1] - pcs[0] / 2;
975  if (fmod(pcs[0], 2) == 0) pcs[1] = pcs[1] + 1;
976  pcs[2] = pcs[1] + pcs[0] - 1;
977  } else if (pcs[0] < -2) {
978  pcs[1] = pcs[1] + pcs[0] / 2;
979  pcs[2] = pcs[1] - pcs[0] - 1;
980  }
981 
982  // cut the clusters at the beginning and at the end of the chamber
983 
984  pcs[1] = std::clamp(pcs[1], 1, nstrips);
985  pcs[2] = std::clamp(pcs[2], 1, nstrips);
986 
987  pcs[0] = pcs[2] - pcs[1] + 1;
988 
989  return pcs;
990 }

◆ UnPackMCTruth()

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

Definition at line 1037 of file RpcDigitizationTool.cxx.

1037  {
1038  // int64_t is just a shorter way of writing long long int
1039  using Repacker = union
1040 
1041  {
1042  double dWord;
1043 
1044  int64_t iWord;
1045  };
1046  Repacker MCTruth;
1047  MCTruth.dWord = theWord;
1048  proptime = ((MCTruth.iWord) & 0x00000000000000ffLL) / 10.;
1049  bctime = (((MCTruth.iWord) & 0x0000000000ffff00LL) >> 8) / 10.;
1050  posy = (((MCTruth.iWord) & 0x000000ffff000000LL) >> 24) / 10.;
1051  posz = (((MCTruth.iWord) & 0x00ffff0000000000LL) >> 40) / 10.;
1052 
1053  //
1054  bctime = bctime - 300.;
1055  posy = posy - 1500.;
1056  posz = posz - 1500.;
1057 }

Member Data Documentation

◆ m_BIL_id

int RpcDigitizationTool::m_BIL_id {-1}
protected

Definition at line 252 of file RpcDigitizationTool.h.

◆ m_BIS_id

int RpcDigitizationTool::m_BIS_id {-1}
protected

Definition at line 253 of file RpcDigitizationTool.h.

◆ m_BOF_id

int RpcDigitizationTool::m_BOF_id {-1}
protected

Definition at line 248 of file RpcDigitizationTool.h.

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

◆ m_BOG_id

int RpcDigitizationTool::m_BOG_id {-1}
protected

Definition at line 249 of file RpcDigitizationTool.h.

◆ m_BOS_id

int RpcDigitizationTool::m_BOS_id {-1}
protected

Definition at line 250 of file RpcDigitizationTool.h.

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

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

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

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

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

◆ m_CutMaxClusterSize

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

Definition at line 245 of file RpcDigitizationTool.h.

◆ m_CutProjectedTracks

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

Definition at line 246 of file RpcDigitizationTool.h.

◆ m_deadTime

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

Definition at line 166 of file RpcDigitizationTool.h.

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

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

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

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

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}
protectedinherited

Definition at line 60 of file PileUpToolBase.h.

◆ m_FirstClusterSizeInTail

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

Definition at line 178 of file RpcDigitizationTool.h.

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

◆ m_FracClusterSize1_A

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

Definition at line 191 of file RpcDigitizationTool.h.

◆ m_FracClusterSize1_BIS78

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

Definition at line 201 of file RpcDigitizationTool.h.

◆ m_FracClusterSize1_C

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

Definition at line 196 of file RpcDigitizationTool.h.

◆ m_FracClusterSize2_A

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

Definition at line 192 of file RpcDigitizationTool.h.

◆ m_FracClusterSize2_BIS78

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

Definition at line 202 of file RpcDigitizationTool.h.

◆ m_FracClusterSize2_C

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

Definition at line 197 of file RpcDigitizationTool.h.

◆ m_FracClusterSizeTail_A

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

Definition at line 193 of file RpcDigitizationTool.h.

◆ m_FracClusterSizeTail_BIS78

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

Definition at line 203 of file RpcDigitizationTool.h.

◆ m_FracClusterSizeTail_C

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

Definition at line 198 of file RpcDigitizationTool.h.

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

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

◆ m_includePileUpTruth

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

Definition at line 173 of file RpcDigitizationTool.h.

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

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

◆ m_MeanClusterSizeTail_A

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

Definition at line 194 of file RpcDigitizationTool.h.

◆ m_MeanClusterSizeTail_BIS78

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

Definition at line 204 of file RpcDigitizationTool.h.

◆ m_MeanClusterSizeTail_C

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

Definition at line 199 of file RpcDigitizationTool.h.

◆ m_mergeSvc

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

Definition at line 213 of file RpcDigitizationTool.h.

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

◆ m_OnlyEtaEff_A

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

Definition at line 182 of file RpcDigitizationTool.h.

◆ m_OnlyEtaEff_BIS78

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

Definition at line 188 of file RpcDigitizationTool.h.

◆ m_OnlyEtaEff_C

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

Definition at line 185 of file RpcDigitizationTool.h.

◆ m_OnlyPhiEff_A

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

Definition at line 181 of file RpcDigitizationTool.h.

◆ m_OnlyPhiEff_BIS78

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

Definition at line 189 of file RpcDigitizationTool.h.

◆ m_OnlyPhiEff_C

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

Definition at line 184 of file RpcDigitizationTool.h.

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

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

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

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

◆ m_PhiAndEtaEff_A

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

Definition at line 180 of file RpcDigitizationTool.h.

◆ m_PhiAndEtaEff_BIS78

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

Definition at line 187 of file RpcDigitizationTool.h.

◆ m_PhiAndEtaEff_C

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

Definition at line 183 of file RpcDigitizationTool.h.

◆ m_readKey

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

Definition at line 164 of file RpcDigitizationTool.h.

◆ m_rndmSvc

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

Definition at line 224 of file RpcDigitizationTool.h.

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

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

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

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

◆ m_simHitValidKey

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

Definition at line 223 of file RpcDigitizationTool.h.

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

◆ m_timeWindowUpperOffset

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

Definition at line 141 of file RpcDigitizationTool.h.

◆ m_turnON_clustersize

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

Definition at line 177 of file RpcDigitizationTool.h.

◆ m_turnON_efficiency

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

Definition at line 175 of file RpcDigitizationTool.h.

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

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

◆ m_validationSetup

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

Definition at line 172 of file RpcDigitizationTool.h.

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

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
RpcDigitizationTool::fillTagInfo
StatusCode fillTagInfo()
Definition: RpcDigitizationTool.cxx:1060
Run1
USAGE: openCoraCool.exe "COOLONL_SCT/COMP200".
Definition: openCoraCool.cxx:57
RpcDigitizationTool::m_sdo_tmp_map
std::map< Identifier, std::vector< MuonSimData::Deposit > > m_sdo_tmp_map
Definition: RpcDigitizationTool.h:165
RpcDigitizationTool::m_outputDigitCollectionKey
SG::WriteHandleKey< RpcDigitContainer > m_outputDigitCollectionKey
Definition: RpcDigitizationTool.h:218
RpcHitIdHelper::GetStationName
std::string GetStationName(const int &hid) const
Definition: RpcHitIdHelper.cxx:58
MuonIdHelper::stationNameIndex
int stationNameIndex(const std::string &name) const
Definition: MuonIdHelper.cxx:852
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
RpcDigitizationTool::m_rpc_time_shift
Gaudi::Property< double > m_rpc_time_shift
Definition: RpcDigitizationTool.h:168
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
RpcDigitizationTool::m_BIS_id
int m_BIS_id
Definition: RpcDigitizationTool.h:253
RpcDigitizationTool::fromSimHitToLayer
Amg::Transform3D fromSimHitToLayer(const MuonGM::RpcReadoutElement *readOutEle, const Identifier &layerId) const
Returns the position of the hit expressed in the gasGap coordinate system.
Definition: RpcDigitizationTool.cxx:901
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
MuonGM::MuonClusterReadoutElement::transform
virtual const Amg::Transform3D & transform() const override
Return local to global transform.
Definition: MuonClusterReadoutElement.h:124
RpcDigitizationTool::m_OnlyEtaEff_BIS78
Gaudi::Property< float > m_OnlyEtaEff_BIS78
Definition: RpcDigitizationTool.h:188
RpcHitIdHelper::GetHelper
static const RpcHitIdHelper * GetHelper(unsigned int nGasGaps=2)
Definition: RpcHitIdHelper.cxx:23
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonSimData::Deposit
std::pair< HepMcParticleLink, MuonMCData > Deposit
Definition: MuonSimData.h:66
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
RpcDigitizationTool::m_muonHelper
const RpcHitIdHelper * m_muonHelper
Definition: RpcDigitizationTool.h:161
get_generator_info.result
result
Definition: get_generator_info.py:21
RpcHitIdHelper::GetDoubletPhi
int GetDoubletPhi(const int &hid) const
Definition: RpcHitIdHelper.cxx:88
RpcDigitizationTool::m_turnON_efficiency
Gaudi::Property< bool > m_turnON_efficiency
Definition: RpcDigitizationTool.h:175
RpcDigitizationTool::physicalClusterSize
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.
Definition: RpcDigitizationTool.cxx:923
RpcDigitizationTool::m_BOG_id
int m_BOG_id
Definition: RpcDigitizationTool.h:249
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
RpcDigitizationTool::m_CorrJitter
Gaudi::Property< double > m_CorrJitter
Definition: RpcDigitizationTool.h:127
PileUpToolBase::m_filterPassed
bool m_filterPassed
Definition: PileUpToolBase.h:60
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
RpcDigitizationTool::m_FracClusterSize1_A
Gaudi::Property< std::vector< double > > m_FracClusterSize1_A
Definition: RpcDigitizationTool.h:191
RpcDigitizationTool::m_readKey
SG::ReadCondHandleKey< RpcCondDbData > m_readKey
Definition: RpcDigitizationTool.h:164
RpcDigitizationTool::m_MeanClusterSizeTail_C
Gaudi::Property< std::vector< double > > m_MeanClusterSizeTail_C
Definition: RpcDigitizationTool.h:199
RpcIdHelper::elementID
Identifier elementID(int stationName, int stationEta, int stationPhi, int doubletR) const
Definition: RpcIdHelper.cxx:798
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
RpcDigitizationTool::m_RPC_TimeSchema
Gaudi::Property< std::string > m_RPC_TimeSchema
Definition: RpcDigitizationTool.h:226
RpcHitIdHelper::GetMeasuresPhi
int GetMeasuresPhi(const int &hid) const
Definition: RpcHitIdHelper.cxx:96
RpcIdHelper::doubletZ
int doubletZ(const Identifier &id) const
Definition: RpcIdHelper.cxx:1058
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
RpcDigitizationTool::m_timeWindowUpperOffset
Gaudi::Property< double > m_timeWindowUpperOffset
Definition: RpcDigitizationTool.h:141
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
RpcDigitizationTool::m_BOG_BOF_DoubletR2_OFF
Gaudi::Property< bool > m_BOG_BOF_DoubletR2_OFF
Definition: RpcDigitizationTool.h:237
RpcDigitizationTool::m_FracClusterSize2_C
Gaudi::Property< std::vector< double > > m_FracClusterSize2_C
Definition: RpcDigitizationTool.h:197
RpcDigitCollection
Definition: RpcDigitCollection.h:17
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
RpcDigitizationTool::m_PhiAndEtaEff_BIS78
Gaudi::Property< float > m_PhiAndEtaEff_BIS78
Definition: RpcDigitizationTool.h:187
RpcDigitizationTool::m_CorrJitter_BIS78
Gaudi::Property< double > m_CorrJitter_BIS78
Definition: RpcDigitizationTool.h:130
RpcDigitizationTool::m_idHelper
const RpcIdHelper * m_idHelper
Definition: RpcDigitizationTool.h:160
IdContext::end_index
size_type end_index() const
Definition: IdContext.h:46
RpcDigitizationTool::PropagationTime
double PropagationTime(const MuonGM::RpcReadoutElement *reEle, const Identifier &id, const Amg::Vector3D &globPos) const
Calculates the propagation time along the strip.
Definition: RpcDigitizationTool.cxx:993
VKalVrtAthena::GeoModel::Run2
@ Run2
Definition: VrtSecInclusive.h:74
AtlasHitsVector
Definition: AtlasHitsVector.h:32
RpcDigitizationTool::m_OnlyPhiEff_BIS78
Gaudi::Property< float > m_OnlyPhiEff_BIS78
Definition: RpcDigitizationTool.h:189
skel.it
it
Definition: skel.GENtoEVGEN.py:407
RpcIdHelper::measuresPhi
bool measuresPhi(const Identifier &id) const override
Definition: RpcIdHelper.cxx:1064
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:15
RpcDigitizationTool::FCPEfficiency
double FCPEfficiency(const HepMC::ConstGenParticlePtr &genParticle) const
Definition: RpcDigitizationTool.cxx:1562
Run2
Definition: openCoraCool.cxx:137
deg
#define deg
Definition: SbPolyhedron.cxx:17
ParticleTest.tp
tp
Definition: ParticleTest.py:25
RpcHitIdHelper::GetDoubletZ
int GetDoubletZ(const int &hid) const
Definition: RpcHitIdHelper.cxx:92
DataVector::get
const T * get(size_type n) const
Access an element, as an rvalue.
RpcDigitizationTool::m_detMgrKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detMgrKey
Definition: RpcDigitizationTool.h:158
RPCSimHitCollection
AtlasHitsVector< RPCSimHit > RPCSimHitCollection
Definition: RPCSimHitCollection.h:15
RpcDigitizationTool::getNextEvent
StatusCode getNextEvent(const EventContext &ctx)
Get next event and extract collection of hit collections:
Definition: RpcDigitizationTool.cxx:351
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:55
RpcDigitizationTool::m_UncorrJitter
Gaudi::Property< double > m_UncorrJitter
Calculates the position of the hit wrt to the strip panel this transformation is needed since the imp...
Definition: RpcDigitizationTool.h:126
RpcDigitizationTool::detectionEfficiency
std::pair< bool, bool > detectionEfficiency(const EventContext &ctx, const Identifier &ideta, const Identifier &idphi, CLHEP::HepRandomEngine *rndmEngine, const HepMcParticleLink &trkParticle) const
Evaluate detection efficiency.
Definition: RpcDigitizationTool.cxx:1089
TimedHitPtr< RPCSimHit >
MuonIdHelper::stationName
int stationName(const Identifier &id) const
Definition: MuonIdHelper.cxx:810
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:878
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
RpcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int doubletR, int doubletZ, int doubletPhi, int gasGap, int measuresPhi, int strip) const
Definition: RpcIdHelper.cxx:936
PileUpToolBase::m_lastXing
Gaudi::Property< int > m_lastXing
Definition: PileUpToolBase.h:56
HepMC::ignoreTruthLink
bool ignoreTruthLink(const T &p, bool vetoPileUp)
Helper function for SDO creation in PileUpTools.
Definition: MagicNumbers.h:344
x
#define x
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
RpcDigitizationTool::m_FracClusterSize1_C
Gaudi::Property< std::vector< double > > m_FracClusterSize1_C
Definition: RpcDigitizationTool.h:196
RpcDigitizationTool::m_PhiAndEtaEff_A
Gaudi::Property< std::vector< float > > m_PhiAndEtaEff_A
Definition: RpcDigitizationTool.h:180
PileUpToolBase::m_vetoPileUpTruthLinks
Gaudi::Property< int > m_vetoPileUpTruthLinks
Definition: PileUpToolBase.h:58
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
RpcDigitizationTool::m_MeanClusterSizeTail_BIS78
Gaudi::Property< float > m_MeanClusterSizeTail_BIS78
Definition: RpcDigitizationTool.h:204
RpcDigitizationTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Definition: RpcDigitizationTool.h:224
isGenericMultichargedParticle
bool isGenericMultichargedParticle(const T &p)
In addition, there is a need to identify ”Q-ball” and similar very exotic (multi-charged) particles w...
Definition: AtlasPID.h:684
RpcDigitizationTool::outsideWindow
bool outsideWindow(double time) const
Definition: RpcDigitizationTool.h:257
PileUpMergeSvc::TimedList::type
std::list< value_t > type
type of the collection of timed data object
Definition: PileUpMergeSvc.h:73
RpcIdHelper::gasGap
int gasGap(const Identifier &id) const override
get the hashes
Definition: RpcIdHelper.cxx:1062
RpcDigitizationTool::m_kill_deadstrips
Gaudi::Property< bool > m_kill_deadstrips
Definition: RpcDigitizationTool.h:176
RpcDigitizationTool::m_FirstClusterSizeInTail
Gaudi::Property< int > m_FirstClusterSizeInTail
Definition: RpcDigitizationTool.h:178
RpcDigitizationTool::m_sdoAreOnlyDigits
Gaudi::Property< bool > m_sdoAreOnlyDigits
Definition: RpcDigitizationTool.h:227
RpcDigitizationTool::m_includePileUpTruth
Gaudi::Property< bool > m_includePileUpTruth
Definition: RpcDigitizationTool.h:173
grepfile.content
string content
Definition: grepfile.py:56
IdContext::begin_index
size_type begin_index() const
Definition: IdContext.h:45
MuonGM::RpcReadoutElement::localToGlobalTransf
Amg::Transform3D localToGlobalTransf(const Identifier &id) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/RpcReadoutElement.cxx:211
RpcDigitizationTool::m_ignoreRunDepConfig
Gaudi::Property< bool > m_ignoreRunDepConfig
Definition: RpcDigitizationTool.h:238
RpcDigitizationTool::timeOverThreshold
static double timeOverThreshold(CLHEP::HepRandomEngine *rndmEngine)
Definition: RpcDigitizationTool.cxx:1624
RpcHitIdHelper::GetPhiSector
int GetPhiSector(const int &hid) const
Definition: RpcHitIdHelper.cxx:69
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
RpcIdHelper::doubletR
int doubletR(const Identifier &id) const
Definition: RpcIdHelper.cxx:1056
RpcDigitizationTool::m_PhiAndEtaEff_C
Gaudi::Property< std::vector< float > > m_PhiAndEtaEff_C
Definition: RpcDigitizationTool.h:183
RpcDigitizationTool::TurnOnStrips
std::array< int, 3 > TurnOnStrips(const MuonGM::RpcReadoutElement *reEle, std::array< int, 3 > &&pcs, const Identifier &id) const
Cluster simulation: second step.
Definition: RpcDigitizationTool.cxx:962
lumiFormat.i
int i
Definition: lumiFormat.py:85
RpcDigitizationTool::doDigitization
StatusCode doDigitization(const EventContext &ctx, Collections_t &collections, MuonSimDataCollection *sdoContainer)
Digitization functionality shared with RPC_PileUpTool.
Definition: RpcDigitizationTool.cxx:481
VKalVrtAthena::GeoModel::Run1
@ Run1
Definition: VrtSecInclusive.h:74
RpcCondDbData
Definition: RpcCondDbData.h:24
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
RpcIdHelper::panelID
Identifier panelID(const Identifier &padID, int gasGap, int measuresPhi) const
Definition: RpcIdHelper.cxx:875
RpcDigitizationTool::m_FracClusterSizeTail_A
Gaudi::Property< std::vector< double > > m_FracClusterSizeTail_A
Definition: RpcDigitizationTool.h:193
PileUpToolBase::PileUpToolBase
PileUpToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: PileUpToolBase.cxx:7
RpcDigitizationTool::m_simHitValidKey
SG::WriteHandleKey< RPCSimHitCollection > m_simHitValidKey
Definition: RpcDigitizationTool.h:223
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
RpcDigitizationTool::m_RPCInfoFromDb
Gaudi::Property< bool > m_RPCInfoFromDb
Definition: RpcDigitizationTool.h:244
run
Definition: run.py:1
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
RpcDigitizationTool::m_deadTime
Gaudi::Property< int > m_deadTime
Definition: RpcDigitizationTool.h:166
RpcDigitizationTool::m_inputHitCollectionName
std::string m_inputHitCollectionName
Definition: RpcDigitizationTool.h:217
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:121
IRDBRecordset_ptr
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
Definition: IRDBAccessSvc.h:25
RpcDigitizationTool::m_timeWindowLowerOffset
Gaudi::Property< double > m_timeWindowLowerOffset
Definition: RpcDigitizationTool.h:140
RpcDigitizationTool::Collections_t
std::vector< std::unique_ptr< RpcDigitCollection > > Collections_t
Definition: RpcDigitizationTool.h:94
RpcDigitizationTool::m_BOF_id
int m_BOF_id
Definition: RpcDigitizationTool.h:248
RpcDigitizationTool::m_FracClusterSize2_A
Gaudi::Property< std::vector< double > > m_FracClusterSize2_A
Definition: RpcDigitizationTool.h:192
RpcHitIdHelper::GetGasGapLayer
int GetGasGapLayer(const int &hid) const
Definition: RpcHitIdHelper.cxx:84
RpcDigitizationTool::m_OnlyEtaEff_C
Gaudi::Property< std::vector< float > > m_OnlyEtaEff_C
Definition: RpcDigitizationTool.h:185
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
AtlasDetectorID::print_to_string
std::string print_to_string(Identifier id, const IdContext *context=0) const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:427
HepMC::ConstGenParticlePtr
const GenParticle * ConstGenParticlePtr
Definition: GenParticle.h:38
MCP::DataYear::Run4
@ Run4
Amg
Definition of ATLAS Math & Geometry primitives (Amg)
Definition: AmgStringHelpers.h:19
MuonGM::RpcReadoutElement::rotatedRpcModule
bool rotatedRpcModule() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/RpcReadoutElement.cxx:182
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
RpcDigitizationTool::m_OnlyPhiEff_A
Gaudi::Property< std::vector< float > > m_OnlyPhiEff_A
Definition: RpcDigitizationTool.h:181
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
RpcIdHelper::gasGapMax
int gasGapMax() const
Definition: RpcIdHelper.cxx:1094
MuonGM::RpcReadoutElement::stripPos
Amg::Vector3D stripPos(const Identifier &id) const
Definition: MuonDetDescr/MuonReadoutGeometry/src/RpcReadoutElement.cxx:177
RpcDigitizationTool::m_OnlyPhiEff_C
Gaudi::Property< std::vector< float > > m_OnlyPhiEff_C
Definition: RpcDigitizationTool.h:184
RpcIdHelper::valid
bool valid(const Identifier &id) const
Definition: RpcIdHelper.cxx:601
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MuonIdHelper::stationEta
int stationEta(const Identifier &id) const
Definition: MuonIdHelper.cxx:815
MuonSimData
Definition: MuonSimData.h:62
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:73
Amg::getRotateY3D
Amg::Transform3D getRotateY3D(double angle)
get a rotation transformation around Y-axis
Definition: GeoPrimitivesHelpers.h:261
RpcDigitizationTool::m_FracClusterSize1_BIS78
Gaudi::Property< float > m_FracClusterSize1_BIS78
Definition: RpcDigitizationTool.h:201
RpcDigitizationTool::m_CutProjectedTracks
Gaudi::Property< int > m_CutProjectedTracks
Definition: RpcDigitizationTool.h:246
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
THROW_EXCEPTION
#define THROW_EXCEPTION(MESSAGE)
Definition: throwExcept.h:10
MuonIdHelper::module_hash_max
size_type module_hash_max() const
the maximum hash value
Definition: MuonIdHelper.cxx:758
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
AtlasDetectorID::print
void print(Identifier id, const IdContext *context=0) const
Expanded print out of any identifier.
Definition: AtlasDetectorID.cxx:423
RpcDigitizationTool::initializeRunDependentParameters
StatusCode initializeRunDependentParameters()
Definition: RpcDigitizationTool.cxx:177
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
DeMoScan.index
string index
Definition: DeMoScan.py:362
RpcDigitizationTool::m_EfficiencyPatchForBMShighEta
Gaudi::Property< bool > m_EfficiencyPatchForBMShighEta
Definition: RpcDigitizationTool.h:231
RpcDigitizationTool::m_OnlyEtaEff_A
Gaudi::Property< std::vector< float > > m_OnlyEtaEff_A
Definition: RpcDigitizationTool.h:182
RpcDigitizationTool::retrieveCondData
StatusCode retrieveCondData(const EventContext &ctx, const SG::ReadCondHandleKey< CondType > &key, const CondType *&condPtr) const
Definition: RpcDigitizationTool.cxx:286
RpcHitIdHelper::GetDoubletR
int GetDoubletR(const int &hid) const
Definition: RpcHitIdHelper.cxx:80
RpcDigitizationTool::m_UncorrJitter_BIS78
Gaudi::Property< double > m_UncorrJitter_BIS78
Definition: RpcDigitizationTool.h:129
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
RpcDigitizationTool::determineClusterSize
int determineClusterSize(const EventContext &ctx, const Identifier &id, double xstripnorm, CLHEP::HepRandomEngine *rndmEngine) const
Definition: RpcDigitizationTool.cxx:1375
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:365
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:51
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonIdHelper::get_hash
virtual int get_hash(const Identifier &id, IdentifierHash &hash_id, const IdContext *context=0) const override
Create hash id from compact id (return == 0 for OK)
Definition: MuonIdHelper.cxx:148
unit
const PlainObject unit() const
This is a plugin that makes Eigen look like CLHEP & defines some convenience methods.
Definition: AmgMatrixBasePlugin.h:21
PileUpToolBase::m_firstXing
Gaudi::Property< int > m_firstXing
Definition: PileUpToolBase.h:54
RpcDigitizationTool::m_Efficiency_fromCOOL
Gaudi::Property< bool > m_Efficiency_fromCOOL
Definition: RpcDigitizationTool.h:230
MuonIdHelper::module_context
IdContext module_context() const
id for module
Definition: MuonIdHelper.cxx:741
RpcDigitizationTool::m_FracClusterSizeTail_C
Gaudi::Property< std::vector< double > > m_FracClusterSizeTail_C
Definition: RpcDigitizationTool.h:198
RpcDigitizationTool::m_onlyUseContainerName
Gaudi::Property< bool > m_onlyUseContainerName
Definition: RpcDigitizationTool.h:214
AtlasHitsVector::size
size_type size() const
Definition: AtlasHitsVector.h:142
RpcDigitizationTool::m_turnON_clustersize
Gaudi::Property< bool > m_turnON_clustersize
Definition: RpcDigitizationTool.h:177
RpcDigitizationTool::m_ClusterSize1_2uncorr
Gaudi::Property< bool > m_ClusterSize1_2uncorr
Definition: RpcDigitizationTool.h:235
RpcDigitizationTool::m_BIL_id
int m_BIL_id
Definition: RpcDigitizationTool.h:252
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:16
RPCSimHit
Definition: RPCSimHit.h:19
RpcDigitizationTool::m_FracClusterSize2_BIS78
Gaudi::Property< float > m_FracClusterSize2_BIS78
Definition: RpcDigitizationTool.h:202
RpcDigitizationTool::m_BOS_id
int m_BOS_id
Definition: RpcDigitizationTool.h:250
RpcDigitizationTool::m_patch_for_rpc_time
Gaudi::Property< bool > m_patch_for_rpc_time
Definition: RpcDigitizationTool.h:167
merge.status
status
Definition: merge.py:16
RpcDigitizationTool::m_muonOnlySDOs
Gaudi::Property< bool > m_muonOnlySDOs
Definition: RpcDigitizationTool.h:208
RpcDigitizationTool::m_CutMaxClusterSize
Gaudi::Property< float > m_CutMaxClusterSize
Definition: RpcDigitizationTool.h:245
RpcDigitizationTool::m_RPCHitCollList
std::vector< std::unique_ptr< RPCSimHitCollection > > m_RPCHitCollList
Definition: RpcDigitizationTool.h:162
simData
constexpr bool simData
Definition: constants.h:36
RpcDigitizationTool::m_FracClusterSizeTail_BIS78
Gaudi::Property< float > m_FracClusterSizeTail_BIS78
Definition: RpcDigitizationTool.h:203
RpcDigitizationTool::m_thpcRPC
std::unique_ptr< TimedHitCollection< RPCSimHit > > m_thpcRPC
Definition: RpcDigitizationTool.h:163
hitTime
float hitTime(const AFP_SIDSimHit &hit)
Definition: AFP_SIDSimHit.h:39
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
RpcDigitizationTool::m_mergeSvc
ServiceHandle< PileUpMergeSvc > m_mergeSvc
Definition: RpcDigitizationTool.h:213
python.CreateTierZeroArgdict.pcs
pcs
Definition: CreateTierZeroArgdict.py:200
value_type
Definition: EDM_MasterSearch.h:11
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
PileUpTimeEventIndex
a struct encapsulating the identifier of a pile-up event
Definition: PileUpTimeEventIndex.h:12
RpcDigitizationTool::m_ClusterSize_BIS78_fromCOOL
Gaudi::Property< bool > m_ClusterSize_BIS78_fromCOOL
Definition: RpcDigitizationTool.h:241
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
RpcDigitizationTool::m_outputSDO_CollectionKey
SG::WriteHandleKey< MuonSimDataCollection > m_outputSDO_CollectionKey
Definition: RpcDigitizationTool.h:220
RpcDigitizationTool::PackMCTruth
long long int PackMCTruth(float proptime, float tof, float posx, float posz) const
Definition: RpcDigitizationTool.cxx:1009
RpcDigitizationTool::m_hitsContainerKey
SG::ReadHandleKey< RPCSimHitCollection > m_hitsContainerKey
Definition: RpcDigitizationTool.h:216
TimedHitCollection
Definition: TimedHitCollection.h:15
plot_times.times
def times(fn)
Definition: plot_times.py:10
MuonMCData
Definition: MuonSimData.h:42
RpcHitIdHelper::GetZSector
int GetZSector(const int &hid) const
Definition: RpcHitIdHelper.cxx:74
RpcDigitizationTool::m_MeanClusterSizeTail_A
Gaudi::Property< std::vector< double > > m_MeanClusterSizeTail_A
Definition: RpcDigitizationTool.h:194
fitman.k
k
Definition: fitman.py:528
RpcDigitizationTool::m_ClusterSize_fromCOOL
Gaudi::Property< bool > m_ClusterSize_fromCOOL
Definition: RpcDigitizationTool.h:234
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
Amg::getTranslate3D
Amg::Transform3D getTranslate3D(const double X, const double Y, const double Z)
: Returns a shift transformation along an arbitrary axis
Definition: GeoPrimitivesHelpers.h:289
RpcIdHelper::doubletPhi
int doubletPhi(const Identifier &id) const
Definition: RpcIdHelper.cxx:1060
RpcDigitizationTool::m_Efficiency_BIS78_fromCOOL
Gaudi::Property< bool > m_Efficiency_BIS78_fromCOOL
Definition: RpcDigitizationTool.h:240
RpcDigitizationTool::m_validationSetup
Gaudi::Property< bool > m_validationSetup
Definition: RpcDigitizationTool.h:172
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Oct 30 2025 21:40:04 for ATLAS Offline Software by   doxygen 1.8.18