MuonR4::RpcDigiTool Class Reference

#include <RpcDigiTool.h>

Inheritance diagram for MuonR4::RpcDigiTool:

Collaboration diagram for MuonR4::RpcDigiTool:

Public Member Functions
StatusCode	initialize () override final
StatusCode	finalize () override final
StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
StatusCode	mergeEvent (const EventContext &ctx) override final
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.
StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.
StatusCode	processAllSubEvents (const EventContext &ctx) const
	Reentrant version of the digitization tool.
	PileUpToolBase (const std::string &type, const std::string &name, const IInterface *parent)

Protected Types
using	TimedHit = TimedHitPtr<xAOD::MuonSimHit>
using	TimedHits = std::vector<TimedHitPtr<xAOD::MuonSimHit>>
template<class DetType>
using	OutDigitCache_t = std::vector<std::unique_ptr<DetType>>
	DigitContainers are sorted by DigitCollections which are the ensemble of all hits in a given MuonChamber.
using	DeadTimeMap = std::unordered_map<Identifier, double>

Protected Member Functions
StatusCode	digitize (const EventContext &ctx, const TimedHits &hitsToDigit, xAOD::MuonSimHitContainer *sdoContainer) const override final
	Digitize the time ordered hits and write them to the digit format specific for the detector technology.
CLHEP::HepRandomEngine *	getRandomEngine (const EventContext &ctx) const
xAOD::MuonSimHit *	addSDO (const TimedHit &hit, xAOD::MuonSimHitContainer *sdoContainer) const
	Adds the timed simHit to the output SDO container.
const ActsTrk::GeometryContext &	getGeoCtx (const EventContext &ctx) const
	Returns the reference to the ActsTrk::GeometryContext needed to fetch global positions from the Readout geometry.
template<class DigitColl>
DigitColl *	fetchCollection (const Identifier &hitId, OutDigitCache_t< DigitColl > &digitCache) const
	Helper function that provides fetches the proper DigitCollection from the DigitCache for a given hit identifier If the Collection is fetched for the first time, it's inserted into the cache first.
template<class DigitCont, class DigitColl>
StatusCode	writeDigitContainer (const EventContext &ctx, const SG::WriteHandleKey< DigitCont > &key, OutDigitCache_t< DigitColl > &&digitCache, unsigned int hashMax) const
	Helper function to move the collected digits into the final DigitContainer.

Static Protected Member Functions
static double	hitTime (const TimedHit &hit)
	Returns the global time of the hit which is the sum of eventTime & individual hit time.
static bool	passDeadTime (const Identifier &channelId, const double hitTime, const double deadTimeWindow, DeadTimeMap &deadTimeMap)
	Returns whether the new digit is within the dead time window.

Protected Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc

Private Types
using	EdgeSide = MuonGMR4::RpcReadoutElement::EdgeSide
using	DigiCache = OutDigitCache_t<RpcDigitCollection>
using	PileUpHits = PileUpMergeSvc::TimedList<xAOD::MuonSimHitContainer>::type
using	SimHitLocalCopy
	Create a local copy of the sim hits to ensure overlayed hits across the events remain valid.

Private Member Functions
bool	digitizeHit (const TimedHit &simHit, const bool measuresPhi, const Muon::DigitEffiData *effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine *rndEngine, DeadTimeMap &deadTimes) const
	Digitize the sim hit as Rpc strip 1D hit.
bool	digitizeHitBI (const TimedHit &simHit, const Muon::DigitEffiData *effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine *rndEngine, DeadTimeMap &deadTimes) const
	Digitize the sim hit as Rpc strip 2D hit.
int	determineClusterSizeBI (const Identifier &id, CLHEP::HepRandomEngine *rndmEngine) const
	Returns BI cluster strip molteplicity.
double	calculateChargeOnStrip (const TimedHit &simHit, CLHEP::HepRandomEngine *rndmEngine, const double gasGapSize) const
	Returns the charge (fC) after the amplification in gas.
std::vector< double >	divideChargeOnStrips (double totalCharge, int n_strips, CLHEP::HepRandomEngine *rndmEngine) const
	Returns a vector with chages (fC) divided on strips.
double	getTOT (const double aCharge) const
	Returns Time Over Threshold (ns) for a signal on a strip.
double	getTOA (const double aCharge, const double aDistance) const
	Returns Time Of Arrival (ns) for a signal on a strip.
StatusCode	fillTimedHits (PileUpHits &&hitColl, TimedHits &timedHits) const
	Translates the PileUpHits into the timed hits format.

Static Private Member Functions
static double	timeOverThreshold (CLHEP::HepRandomEngine *rndmEngine)
	Roll the time over threshold for each signal digit.

Private Attributes
SG::WriteHandleKey< RpcDigitContainer >	m_writeKey
SG::ReadCondHandleKey< Muon::DigitEffiData >	m_effiDataKey
std::array< std::atomic< unsigned >, 2 > m_allHits	ATLAS_THREAD_SAFE {}
std::array< std::atomic< unsigned >, 2 > m_acceptedHits	ATLAS_THREAD_SAFE {}
Gaudi::Property< double >	m_propagationVelocity
Gaudi::Property< double >	m_stripTimeResolution
Gaudi::Property< double >	m_deadTime
Gaudi::Property< bool >	m_digitizeMuonOnly
SG::ReadHandleKey< xAOD::MuonSimHitContainer >	m_simHitKey {this, "SimHitKey", ""}
ActsTrk::GeoContextReadKey_t	m_geoCtxKey
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
Gaudi::Property< std::string >	m_streamName {this, "StreamName", ""}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
SG::WriteHandleKey< xAOD::MuonSimHitContainer >	m_sdoKey {this, "OutputSDOName", ""}
Gaudi::Property< bool >	m_onlyUseContainerName
Gaudi::Property< bool >	m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}
std::string	m_inputObjectName {""}
TimedHits	m_timedHits {}
std::vector< SimHitLocalCopy >	m_simHits {}

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

Detailed Description

Definition at line 17 of file RpcDigiTool.h.

Member Typedef Documentation

DeadTimeMap

using MuonR4::MuonDigitizationTool::DeadTimeMap = std::unordered_map<Identifier, double>

protectedinherited

Definition at line 100 of file MuonDigitizationTool.h.

DigiCache

using MuonR4::RpcDigiTool::DigiCache = OutDigitCache_t<RpcDigitCollection>

private

Definition at line 61 of file RpcDigiTool.h.

EdgeSide

using MuonR4::RpcDigiTool::EdgeSide = MuonGMR4::RpcReadoutElement::EdgeSide

private

Definition at line 30 of file RpcDigiTool.h.

OutDigitCache_t

template<class DetType>

using MuonR4::MuonDigitizationTool::OutDigitCache_t = std::vector<std::unique_ptr<DetType>>

protectedinherited

DigitContainers are sorted by DigitCollections which are the ensemble of all hits in a given MuonChamber.

To fill the final DigitContainer thread-safely, the DigitCollections shall be cached pre cached in a OutDigitCache_t vector which is later moved to the final DigitContainer

Definition at line 80 of file MuonDigitizationTool.h.

PileUpHits

using MuonR4::MuonDigitizationTool::PileUpHits = PileUpMergeSvc::TimedList<xAOD::MuonSimHitContainer>::type

privateinherited

Definition at line 116 of file MuonDigitizationTool.h.

SimHitLocalCopy

using MuonR4::MuonDigitizationTool::SimHitLocalCopy

privateinherited

Initial value:

std::pair<std::unique_ptr<xAOD::MuonSimHitContainer>,
                                             std::unique_ptr<xAOD::MuonSimHitAuxContainer>>

Create a local copy of the sim hits to ensure overlayed hits across the events remain valid.

Definition at line 143 of file MuonDigitizationTool.h.

TimedHit

using MuonR4::MuonDigitizationTool::TimedHit = TimedHitPtr<xAOD::MuonSimHit>

protectedinherited

Definition at line 57 of file MuonDigitizationTool.h.

TimedHits

using MuonR4::MuonDigitizationTool::TimedHits = std::vector<TimedHitPtr<xAOD::MuonSimHit>>

protectedinherited

Definition at line 58 of file MuonDigitizationTool.h.

Member Function Documentation

addSDO()

xAOD::MuonSimHit * MuonR4::MuonDigitizationTool::addSDO ( const TimedHit & hit, xAOD::MuonSimHitContainer * sdoContainer ) const

protectedinherited

Adds the timed simHit to the output SDO container.

The hit may be rejected if it's originating from pile-up and the pile-up truth skimming strategy is applied

Definition at line 138 of file MuonDigitizationTool.cxx.

                                                                                                {
        if(!sdoContainer) {
            ATH_MSG_VERBOSE("No SDO container setup of writing");
            return nullptr;
        }
        if (!m_includePileUpTruth && HepMC::ignoreTruthLink(hit->genParticleLink(), m_vetoPileUpTruthLinks)) { 
            ATH_MSG_VERBOSE("Hit "<<m_idHelperSvc->toString(hit->identify())<<" is a pile-up truth link");
            return nullptr; 
        }
        ATH_MSG_VERBOSE(m_idHelperSvc->toString(hit->identify())<<", pdgID: "<<hit->pdgId()<< " genParticleLink :"<<hit->genParticleLink());
        ATH_MSG_VERBOSE("Genparticle: "<<hit->genParticleLink());        
        xAOD::MuonSimHit* sdoHit = sdoContainer->push_back(std::make_unique<xAOD::MuonSimHit>());
        (*sdoHit) = (*hit);
        static const SG::Accessor<float> acc_eventTime{"MuSim_evtTime"};
        static const SG::Accessor<unsigned short> acc_eventID{"MuSim_evtID"};
        static const SG::Accessor<unsigned short> acc_puType{"MuSim_puType"};
        acc_eventTime(*sdoHit) = hit.eventTime();
        acc_eventID(*sdoHit) = hit.eventId();
        acc_puType(*sdoHit) = hit.pileupType();
        return sdoHit;
    }

calculateChargeOnStrip()

double MuonR4::RpcDigiTool::calculateChargeOnStrip ( const TimedHit & simHit, CLHEP::HepRandomEngine * rndmEngine, const double gasGapSize ) const

private

Returns the charge (fC) after the amplification in gas.

Parameters

simHit	Reference to the sim hit to digitize
rndmEngine	A random engine

Definition at line 405 of file RpcDigiTool.cxx.

                                                                          {
 
  // Average energy to create an electron-ion pair inside RPC gas
  constexpr double W_VALUE_EV = 30.0; // Unit: [eV/pair]
 
  // RPC BI gas gap thickness
  const double GAP_THICKNESS_M = gasGapSize; // Unit: [m] (2 mm for Phase-II BI RPCs))
 
  // Townsend coefficient for gas mixture and operational voltage
  constexpr double ALPHA_PER_M = 5500.0 / Gaudi::Units::m; // Unit: [1/m]
 
  // Energy deposited by Geant4
  const double energy_deposit_ev = simHit->energyDeposit() / Gaudi::Units::eV;
 
  // Number of electron-ion pairs created
  const double N0 = energy_deposit_ev / W_VALUE_EV;
 
  // Primary ionization poistion inside gas gap
  const double z_hit_m =
      CLHEP::RandFlat::shoot(rndmEngine, 0.0, GAP_THICKNESS_M); // Unit: [m]
 
  // Distance to anode
  const double z_drift_m = std::abs(GAP_THICKNESS_M - z_hit_m); // Unit: [m]
 
  // Avalanche gain
  const double gas_gain = std::exp(ALPHA_PER_M * z_drift_m);
 
  // Total charge
  const double total_charge_c = N0 * gas_gain * Gaudi::Units::e_SI; // Unit: [C]
 
  ATH_MSG_DEBUG(__func__<<"() - "<<__LINE__<<" GAP_THICKNESS_M: "<<GAP_THICKNESS_M<<
      ", "<<energy_deposit_ev<<", z_hit_m: "<<z_hit_m<<", N0: "<<N0<<", z_drift_m: "<<z_drift_m
    <<", gas_gain: "<<gas_gain<< "---> Charge on strip (fC): " << total_charge_c * 1e15);
 
  return total_charge_c * 1e15; // charge in fC
}

determineClusterSizeBI()

int MuonR4::RpcDigiTool::determineClusterSizeBI ( const Identifier & id, CLHEP::HepRandomEngine * rndmEngine ) const

private

Returns BI cluster strip molteplicity.

Parameters

id	Reference to the chamber identifier
rndmEngin	Random engine used for probabilities

Definition at line 444 of file RpcDigiTool.cxx.

                                                                        {
 
  const RpcIdHelper &id_helper{m_idHelperSvc->rpcIdHelper()};
 
  ATH_MSG_DEBUG("RpcDigitizationTool::in determineClusterSize");
 
  ATH_MSG_DEBUG("Digit Id = " << id_helper.show_to_string(idGasGap));
 
  // These cluster size probabilities were taken from preliminary
  // results from the BI RPC Upgrade work in 2025 at BB5.
  // They could be updated if new results for BI RPCs become available.
  static constexpr std::array<double, 4> ClusterSizeProbabilities{0.642, 0.316,
                                                                  0.032, 0.010};
  // Compile-time calculation of the cumulative array
  // Used empty capture list [] since variables are static constexpr
  static constexpr std::array<double, 4> cumulative = []() {
    std::array<double, 4> acumulative{};
    acumulative[0] = ClusterSizeProbabilities[0];
    for (size_t i = 1; i < ClusterSizeProbabilities.size(); ++i) {
      acumulative[i] = acumulative[i - 1] + ClusterSizeProbabilities[i];
    }
    return acumulative;
  }();
 
  float rndmCS = CLHEP::RandFlat::shoot(rndmEngine, 1.);
 
  unsigned ClusterSize{0};
  while (ClusterSize < ClusterSizeProbabilities.size() &&
         rndmCS > cumulative[ClusterSize])
    ++ClusterSize;
 
  if (ClusterSize >= ClusterSizeProbabilities.size())
    ClusterSize = ClusterSizeProbabilities.size() - 1;
  return ClusterSize + 1;
}

digitize()

StatusCode MuonR4::RpcDigiTool::digitize ( const EventContext & ctx, const TimedHits & hitsToDigit, xAOD::MuonSimHitContainer * sdoContainer ) const

finaloverrideprotectedvirtual

Digitize the time ordered hits and write them to the digit format specific for the detector technology.

A new MuonSimHitContainer pointer is parsed to also create the MuonSDO. If a new SDO should be added to the container plese use the addSDO() method as defined below.

Fetch the conditions for efficiency calculations

Standard digitization path

Write everything at the end into the final digit container

Implements MuonR4::MuonDigitizationTool.

Definition at line 61 of file RpcDigiTool.cxx.

                                                                   {
  const RpcIdHelper &idHelper{m_idHelperSvc->rpcIdHelper()};
  // Prepare the temporary cache
  DigiCache digitCache{};
  const Muon::DigitEffiData *efficiencyMap{nullptr};
  ATH_CHECK(SG::get(efficiencyMap, m_effiDataKey, ctx));
 
  CLHEP::HepRandomEngine *rndEngine = getRandomEngine(ctx);
  xAOD::ChamberViewer viewer{hitsToDigit, m_idHelperSvc.get()};
  do {
    DeadTimeMap deadTimes{};
    for (const TimedHit &simHit : viewer) {
      if (m_digitizeMuonOnly && !MC::isMuon(simHit)) {
        continue;
      }
      const Identifier hitId{simHit->identify()};
      RpcDigitCollection *digiColl = fetchCollection(hitId, digitCache);
      const std::size_t beforeDigiSize = digiColl->size();
      xAOD::MuonSimHit* sdo{nullptr};
      if (m_detMgr->getRpcReadoutElement(hitId)->nPhiStrips() > 0) {
 
        const bool digitizedPhi = digitizeHit(simHit, true, efficiencyMap,
                                              *digiColl, rndEngine, deadTimes);
        const bool digitizedEta = digitizeHit(simHit, false, efficiencyMap,
                                              *digiColl, rndEngine, deadTimes);
        if (digitizedEta || digitizedPhi) {
            sdo = addSDO(simHit, sdoContainer);
        }
      } else if (digitizeHitBI(simHit, efficiencyMap, *digiColl, rndEngine,
                               deadTimes)) {
       sdo = addSDO(simHit, sdoContainer);
      }
      if (sdo) {
        sdo->setIdentifier(digiColl->back()->identify());
        dec_etaChannel(*sdo).clear();
        dec_phiChannel(*sdo).clear();
        for (std::size_t newDigit = beforeDigiSize; newDigit< digiColl->size(); ++newDigit) {
            const Identifier id = digiColl->at(newDigit)->identify();
            ChVec_t& ch{idHelper.measuresPhi(id)? dec_phiChannel(*sdo) : dec_etaChannel(*sdo)};
            ch.push_back(idHelper.channel(id));      
        }
      }
    }
  } while (viewer.next());
  ATH_CHECK(writeDigitContainer(ctx, m_writeKey, std::move(digitCache),
                                idHelper.module_hash_max()));
  return StatusCode::SUCCESS;
}

digitizeHit()

bool MuonR4::RpcDigiTool::digitizeHit ( const TimedHit & simHit, const bool measuresPhi, const Muon::DigitEffiData * effiMap, RpcDigitCollection & outContainer, CLHEP::HepRandomEngine * rndEngine, DeadTimeMap & deadTimes ) const

private

Digitize the sim hit as Rpc strip 1D hit.

Parameters

simHit	Reference to the sim hit to digitize
measuresPhi	Process an eta or a phi strip
effiMap	Pointer to an efficiency look-up table
outContainer	DigitCollection to push the new digit into
rndEngine	Random engine used for smearing
deadTimes	Reference to the last digitized times in order to apply the dead time model

Final check whether the digit is actually efficient

Correct for the signal propagation time

Definition at line 113 of file RpcDigiTool.cxx.

                                                            {
 
  ++(m_allHits[measuresPhi]);
 
  const Identifier gasGapId = hit->identify();
  const MuonGMR4::RpcReadoutElement *reEle =
      m_detMgr->getRpcReadoutElement(gasGapId);
 
  const RpcIdHelper &idHelper{m_idHelperSvc->rpcIdHelper()};
 
  bool isValid{false};
  const Identifier layerId = idHelper.channelID(
      gasGapId, idHelper.doubletZ(gasGapId), idHelper.doubletPhi(gasGapId),
      idHelper.gasGap(gasGapId), measuresPhi, 1, isValid);
 
  const MuonGMR4::StripLayerPtr &layerDesign =
      reEle->sensorLayout(reEle->layerHash(layerId));
 
  const MuonGMR4::StripDesign &design{layerDesign->design(measuresPhi)};
 
  const double uncert = design.stripPitch() / std::sqrt(12.);
  Amg::Vector3D locHitPos{xAOD::toEigen(hit->localPosition())};
  locHitPos[measuresPhi] = CLHEP::RandGaussZiggurat::shoot(
      rndEngine, locHitPos[measuresPhi], uncert);
 
  const Amg::Vector2D locPos2D = layerDesign->to2D(locHitPos, measuresPhi);
  if (!design.insideTrapezoid(locPos2D)) {
    ATH_MSG_VERBOSE("The hit " << Amg::toString(locHitPos) << " / "
                               << Amg::toString(locPos2D)
                               << " is outside of the trapezoid bounds for "
                               << m_idHelperSvc->toString(layerId));
    return false;
  }
  const int strip = design.stripNumber(locPos2D);
  if (strip < 0) {
    ATH_MSG_VERBOSE("Hit " << Amg::toString(locHitPos) << " / "
                           << Amg::toString(locPos2D)
                           << " cannot trigger any signal in a strip for "
                           << m_idHelperSvc->toString(layerId) << std::endl
                           << design);
    return false;
  }
 
  const Identifier digitId{idHelper.channelID(
      gasGapId, idHelper.doubletZ(gasGapId), idHelper.doubletPhi(gasGapId),
      idHelper.gasGap(gasGapId), measuresPhi, strip, isValid)};
 
  if (!isValid) {
    ATH_MSG_WARNING("Invalid hit identifier obtained for "
                    << m_idHelperSvc->toStringGasGap(gasGapId)
                    << ",  eta strip " << strip << " & hit "
                    << Amg::toString(locHitPos, 2) << " /// " << design);
    return false;
  }
  if (effiMap && effiMap->getEfficiency(digitId) <
                     CLHEP::RandFlat::shoot(rndEngine, 0., 1.)) {
    ATH_MSG_VERBOSE("Hit is marked as inefficient");
    return false;
  }
  if (!passDeadTime(digitId, hitTime(hit), m_deadTime, deadTimes)) {
    ATH_MSG_VERBOSE("Reject hit due to dead map constraint");
    return false;
  }
  const double signalTime =
      hitTime(hit) + reEle->distanceToEdge(reEle->measurementHash(digitId),
                                           locHitPos, EdgeSide::readOut) /
                         m_propagationVelocity;
  const double digitTime = CLHEP::RandGaussZiggurat::shoot(
      rndEngine, signalTime, m_stripTimeResolution);
  ATH_MSG_VERBOSE("Created new digit " << m_idHelperSvc->toString(digitId)
                                       << ", @ " << Amg::toString(locPos2D)
                                       << ", recorded time: " << digitTime);
  outContainer.push_back(std::make_unique<RpcDigit>(
      digitId, digitTime, timeOverThreshold(rndEngine)));
  ++(m_acceptedHits[measuresPhi]);
  return true;
}

digitizeHitBI()

bool MuonR4::RpcDigiTool::digitizeHitBI ( const TimedHit & simHit, const Muon::DigitEffiData * effiMap, RpcDigitCollection & outContainer, CLHEP::HepRandomEngine * rndEngine, DeadTimeMap & deadTimes ) const

private

Digitize the sim hit as Rpc strip 2D hit.

Parameters

simHit	Reference to the sim hit to digitize
effiMap	Pointer to an efficiency look-up table
outContainer	DigitCollection to push the new digit into
rndEngine	Random engine used for smearing
deadTimes	Reference to the last digitized times in order to apply the dead time model

Definition at line 197 of file RpcDigiTool.cxx.

                                                              {
 
  ++(m_allHits[false]);
  const Identifier gasGapId = simHit->identify();
  const MuonGMR4::RpcReadoutElement *reEle =
      m_detMgr->getRpcReadoutElement(gasGapId);
  const Amg::Vector3D locPos = xAOD::toEigen(simHit->localPosition());
  const MuonGMR4::StripDesign &design{*reEle->getParameters().etaDesign};
  const RpcIdHelper &idHelper{m_idHelperSvc->rpcIdHelper()};
 
  /* with RpcReadoutElement reEle you can access infor about the readout like */
  ATH_MSG_VERBOSE("RpcDigiTool::digitizeHitBI reEle->nGasGaps "<< reEle->nGasGaps());
  /* with StripDesign you can access the strip information of the readout
   * element for instance: */
  ATH_MSG_VERBOSE("RpcDigiTool::digitizeHitBI design: "<< design);
 
  // Check the correctness of the local hit position
  const Amg::Vector2D locHitPosition{locPos.x(), locPos.y()};
  if (!design.insideTrapezoid(locHitPosition)) {
    ATH_MSG_VERBOSE("The hit " << Amg::toString(locHitPosition)
                               << " is outside of the trapezoid bounds for "
                               << m_idHelperSvc->toStringGasGap(gasGapId));
    return false;
  }
 
  // Calculate distance to strip edges (mm)
  const IdentifierHash layHash = reEle->layerHash(gasGapId);
  const double DistanceToReadOut =
      reEle->distanceToEdge(layHash, locPos, EdgeSide::readOut); // mm
  const double DistanceToHV =
      reEle->distanceToEdge(layHash, locPos, EdgeSide::highVoltage); // mm
 
  // Calculate charge deposited
  const double TotalChargeOnStrip =
      calculateChargeOnStrip(simHit, rndEngine, reEle->gasGapPitch());
  ATH_MSG_VERBOSE(" total charge (fC): " << TotalChargeOnStrip);
 
  // Calculate cluster size (number of strips)
  int clusterSize = determineClusterSizeBI(gasGapId, rndEngine);
  ATH_MSG_VERBOSE(" cluster size: " << clusterSize);
 
  // Get corresponding strip number and apply checks
  const int strip = design.stripNumber(locHitPosition);
  if (strip < 0) {
    ATH_MSG_VERBOSE("Hit " << Amg::toString(locHitPosition)
                           << " cannot trigger any signal in a strip for "
                           << m_idHelperSvc->toStringGasGap(gasGapId)
                           << std::endl
                           << design);
    return false;
  }
 
  // Get min and max strips
  int minStrip{strip}, maxStrip{strip}; // case strip number is 1
  if (clusterSize > 1) {
    int halfCluster = clusterSize / 2; // half cluster size (int)
    minStrip = strip - halfCluster;    // min strip number
    if (clusterSize % 2 == 0) { // if clusterSize is even, we have to randomly
                                // assign one strip on left or right side
      int side = Acts::copySign(1,CLHEP::RandFlat::shoot(rndEngine, 0., 1.) + 0.5);
      minStrip += side; // if side==1 move the min strip to right
    }
    maxStrip = minStrip + clusterSize - 1;
    // Check design strip boundaries
    minStrip = std::max(minStrip, design.firstStripNumber());
    maxStrip = std::min(design.firstStripNumber() + design.numStrips() - 1, maxStrip);
  }
 
  // Recalculate cluster size with minStrip and maxStrip
  clusterSize = (maxStrip - minStrip) + 1;
 
  // Divide charge on N strips
  const std::vector<double> StripCharges =
      divideChargeOnStrips(TotalChargeOnStrip, clusterSize, rndEngine);
 
  // Digitize each strip
  for (int aStrip = minStrip; aStrip <= maxStrip; aStrip++) {
    bool isValid{false};
    const Identifier digitId{idHelper.channelID(
        gasGapId, idHelper.doubletZ(gasGapId), idHelper.doubletPhi(gasGapId),
        idHelper.gasGap(gasGapId), false, aStrip, isValid)};
 
    // Check digitID is valid
    if (!isValid) {
      ATH_MSG_WARNING("Failed to create a valid strip "
                      << m_idHelperSvc->toStringGasGap(gasGapId)
                      << ", strip: " << aStrip);
      return false;
    }
    // Check is not dead time
    if (!passDeadTime(digitId, hitTime(simHit), m_deadTime, deadTimes)) {
      ATH_MSG_VERBOSE("Reject hit due to dead map constraint");
      return false;
    }
    // Check whether the digit is actually efficient
    const bool effiSignal1 =
        !effiMap || effiMap->getEfficiency(gasGapId) >=
                        CLHEP::RandFlat::shoot(rndEngine, 0., 1.);
    const bool effiSignal2 =
        !effiMap || effiMap->getEfficiency(gasGapId) >=
                        CLHEP::RandFlat::shoot(rndEngine, 0., 1.);
    if (effiSignal1) {
      outContainer.push_back(std::make_unique<RpcDigit>(
          digitId,
          hitTime(simHit) + getTOA(StripCharges[aStrip], DistanceToHV / 1000.),
          getTOT(StripCharges[aStrip])));
    }
    if (effiSignal2) {
      outContainer.push_back(std::make_unique<RpcDigit>(
          digitId,
          hitTime(simHit) +
              getTOA(StripCharges[aStrip], DistanceToReadOut / 1000.),
          getTOT(StripCharges[aStrip]), true));
    }
    if (effiSignal1 || effiSignal2) {
      ATH_MSG_VERBOSE("Digitize hit "
                      << m_idHelperSvc->toString(digitId)
                      << " located at: " << Amg::toString(locPos)
                      << ", SDO: " << Amg::toString(locHitPosition));
      ++(m_acceptedHits[false]);
      return true;
    }
  }
 
  return false;
}

divideChargeOnStrips()

std::vector< double > MuonR4::RpcDigiTool::divideChargeOnStrips ( double totalCharge, int n_strips, CLHEP::HepRandomEngine * rndmEngine ) const

private

Returns a vector with chages (fC) divided on strips.

Parameters

totalCharge	total charge from a single spike (fC)
n_strips	number of strips to divide the charge over
rndmEngine	A random engine

Definition at line 351 of file RpcDigiTool.cxx.

                                                                          {
 
  std::vector<double> charges;
 
  switch (n_strips) {
  case 1: {
    // Trivial case, all charge on a single strip
    charges.push_back(totalCharge);
    break;
  }
  case 2: {
    // We use a Gaussian distribution centered over 0.5 to simulate
    // a charge sharing that is on average 50/50 but includes fluctuations
    double f = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.5, 0.15);
 
    // Make sure fraction is bounded between 0 and 1
    f = std::clamp(f, 0., 1.);
 
    charges.push_back(f * totalCharge);
    charges.push_back((1.0 - f) * totalCharge);
    break;
  }
  case 3: {
    // These fractions are guesses on a reasonable charge
    // sharing when three strips are activated.
    // These fractions must be updated once the final
    // distributions of TOT from Phase-II BI RPCs
    // are available.
    charges.push_back(0.20 * totalCharge); // left strip
    charges.push_back(0.60 * totalCharge); // center strip
    charges.push_back(0.20 * totalCharge); // right strip
    break;
  }
  case 4: {
    // These fractions are guesses on a reasonable charge
    // sharing when four strips are activated.
    // These fractions must be updated once the final
    // distributions of TOT from Phase-II BI RPCs
    // are available.
    charges.push_back(0.15 * totalCharge); // left external strip
    charges.push_back(0.35 * totalCharge); // left internal strip
    charges.push_back(0.35 * totalCharge); // right internal strip
    charges.push_back(0.15 * totalCharge); // right external strip
    break;
  }
  default: {
    // return empy vector
    break;
  }
  }
  return charges;
}

fetchCollection()

template<class DigitColl>

DigitColl * MuonR4::MuonDigitizationTool::fetchCollection ( const Identifier & hitId, OutDigitCache_t< DigitColl > & digitCache ) const

protectedinherited

Helper function that provides fetches the proper DigitCollection from the DigitCache for a given hit identifier If the Collection is fetched for the first time, it's inserted into the cache first.

fillTimedHits()

StatusCode MuonR4::MuonDigitizationTool::fillTimedHits ( PileUpHits && hitColl, TimedHits & timedHits ) const

privateinherited

Translates the PileUpHits into the timed hits format.

Definition at line 48 of file MuonDigitizationTool.cxx.

                                                                                                   {
        for (const auto& [timeIndex, simHitColl] : hitColl) {
            timedHits.reserve(timedHits.capacity() + simHitColl->size());
            for (const xAOD::MuonSimHit* simHit : *simHitColl) {
                timedHits.emplace_back(timeIndex.time(), timeIndex.index(), simHit, timeIndex.type());
            }           
        }
        std::stable_sort(timedHits.begin(), timedHits.end(), 
                 [](const TimedHit& a, const TimedHit& b){
                    if (a->identify() != b->identify()){
                        return a->identify() < b->identify();
                    }
                    if (a.eventId() != b.eventId()) {
                       return a.eventId() < b.eventId();
                    } 
                    return a.eventTime() < b.eventTime(); 
                }); 
        return StatusCode::SUCCESS;
    }

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

finalize()

StatusCode MuonR4::RpcDigiTool::finalize ( )

finaloverride

Definition at line 31 of file RpcDigiTool.cxx.

                                 {
  ATH_MSG_INFO("Tried to convert "
               << m_allHits[0] << "/" << m_allHits[1] << " hits. In, "
               << percentage(m_acceptedHits[0], m_allHits[0]) << "/"
               << percentage(m_acceptedHits[1], m_allHits[1])
               << "% of the cases, the conversion was successful");
  return StatusCode::SUCCESS;
}

getGeoCtx()

const ActsTrk::GeometryContext & MuonR4::MuonDigitizationTool::getGeoCtx ( const EventContext & ctx ) const

protectedinherited

Returns the reference to the ActsTrk::GeometryContext needed to fetch global positions from the Readout geometry.

Definition at line 131 of file MuonDigitizationTool.cxx.

                                                                                               {
        const ActsTrk::GeometryContext* gctx{};
        if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
            THROW_EXCEPTION("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
        }
        return *gctx;
    }

getRandomEngine()

CLHEP::HepRandomEngine * MuonR4::MuonDigitizationTool::getRandomEngine ( const EventContext & ctx ) const

protectedinherited

Definition at line 125 of file MuonDigitizationTool.cxx.

                                                                                            {
        ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_streamName);
        std::string rngName = m_streamName;
        rngWrapper->setSeed(rngName, ctx);
        return rngWrapper->getEngine(ctx);
    }

getTOA()

double MuonR4::RpcDigiTool::getTOA ( const double aCharge, const double aDistance ) const

private

Returns Time Of Arrival (ns) for a signal on a strip.

Parameters

aCharge	electric charge deposited on the strip (fC)
aDistance	distance from hit to strip edge (m)

Definition at line 49 of file RpcDigiTool.cxx.

                                                                               {
    // This is a parameterization of BIRPC TOA (ns) values corresponding to
    // a charge (fC) and a distance (m), it was obtained from a
    // detailed model for RPC signal emulation.
    constexpr std::array<double, 3> distCoeffs{0., 5.00311, 0.00006};
    constexpr std::array<double, 3> chargeCoeffs{2.02843, -0.00641, 0.00001};
    using namespace Acts::detail;
    return polynomialSum(aDistance, distCoeffs) +
           polynomialSum(aCharge, chargeCoeffs);
  }

getTOT()

double MuonR4::RpcDigiTool::getTOT ( const double aCharge ) const

private

Returns Time Over Threshold (ns) for a signal on a strip.

Parameters

aCharge

electric charge deposited on the strip (fC)

Definition at line 41 of file RpcDigiTool.cxx.

                                                      {
    // This is a parameterization of BIRPC TOT (ns) values corresponding to
    // a charge (fC), it was obtained from a detailed model for
    // RPC signal emulation.
    constexpr std::array<double, 3> coeffs{19.9587, 0.10081, -0.00017};
    using namespace Acts::detail;
    return polynomialSum(aCharge, coeffs); 
  }

hitTime()

double MuonR4::MuonDigitizationTool::hitTime ( const TimedHit & hit )

staticprotectedinherited

Returns the global time of the hit which is the sum of eventTime & individual hit time.

Definition at line 67 of file MuonDigitizationTool.cxx.

                                                            {
        return hit.eventTime() + hit->globalTime();
    }

initialize()

StatusCode MuonR4::RpcDigiTool::initialize ( )

finaloverridevirtual

Reimplemented from MuonR4::MuonDigitizationTool.

Definition at line 24 of file RpcDigiTool.cxx.

                                   {
  ATH_CHECK(MuonDigitizationTool::initialize());
  ATH_CHECK(m_writeKey.initialize());
  ATH_CHECK(m_effiDataKey.initialize(!m_effiDataKey.empty()));
  return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode MuonR4::MuonDigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverrideinherited

Definition at line 92 of file MuonDigitizationTool.cxx.

                                                                       {
        ATH_MSG_DEBUG("mergeEvent()");
        
        SDOFiller_t sdoContainer{};
        ATH_CHECK(digitize(ctx, m_timedHits, !m_sdoKey.empty() ? sdoContainer.get() : nullptr));
        ATH_CHECK(sdoContainer.record(m_sdoKey, ctx));
        m_timedHits.clear();
        m_simHits.clear();
        return StatusCode::SUCCESS;
    }

passDeadTime()

bool MuonR4::MuonDigitizationTool::passDeadTime ( const Identifier & channelId, const double hitTime, const double deadTimeWindow, DeadTimeMap & deadTimeMap )

staticprotectedinherited

Returns whether the new digit is within the dead time window.

channelId: Identifier of the fired channel

hitTime: Current hit time

deadTimeWindow: Dead time to pass before the next hit may be accepted

deadTimeMap: Map storing the last hit times from each Identifier

Channel not seen before

Update dead time map & accept hit

Definition at line 160 of file MuonDigitizationTool.cxx.

                                                                      {
        auto insertItr = deadTimeMap.insert(std::make_pair(channelId,hitTime));
        if (insertItr.second) {
            return true;
        }
        if (hitTime - insertItr.first->second < deadTimeWindow) {
            return false;
        }
        insertItr.first->second = hitTime;
        return true;
    }

PileUpToolBase()

PileUpToolBase::PileUpToolBase ( const std::string & type, const std::string & name, const IInterface * parent )

inherited

Definition at line 22 of file PileUpToolBase.cxx.

  : base_class(type, name, parent)
{
}

prepareEvent()

StatusCode MuonR4::MuonDigitizationTool::prepareEvent ( const EventContext & ctx, const unsigned int nInputEvents )

finaloverrideinherited

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

Not able to access SubEvents

Definition at line 39 of file MuonDigitizationTool.cxx.

                                                                             {
 
        ATH_MSG_DEBUG("prepareEvent() called for " << nInputEvents << " input events");
        m_timedHits.clear();
        m_simHits.clear();
        return StatusCode::SUCCESS;
    }

processAllSubEvents() [1/2]

StatusCode MuonR4::MuonDigitizationTool::processAllSubEvents ( const EventContext & ctx ) const

inherited

Reentrant version of the digitization tool.

In case of single hits container just load the collection using read handles

Definition at line 75 of file MuonDigitizationTool.cxx.

                                                                                      {
        PileUpHits hitCollList{};
        TimedHits timedHits{};
        if (!m_onlyUseContainerName) {            
            const xAOD::MuonSimHitContainer* hitCollection{nullptr};
            ATH_CHECK(SG::get(hitCollection, m_simHitKey, ctx));
            hitCollList.emplace_back(PileUpTimeEventIndex(0), hitCollection);
         } else {
            ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList));
        }
        ATH_CHECK(fillTimedHits(std::move(hitCollList), timedHits));
        SDOFiller_t sdoContainer{};
        ATH_CHECK(digitize(ctx, timedHits, !m_sdoKey.empty() ? sdoContainer.get() : nullptr));
        ATH_CHECK(sdoContainer.record(m_sdoKey, ctx));
        return StatusCode::SUCCESS;
    }

processAllSubEvents() [2/2]

StatusCode MuonR4::MuonDigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtualinherited

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

Reimplemented from PileUpToolBase.

Definition at line 70 of file MuonDigitizationTool.cxx.

                                                                                {
        const MuonDigitizationTool* digiTool = this;
        return digiTool->processAllSubEvents(ctx);
    }

processBunchXing()

StatusCode MuonR4::MuonDigitizationTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtualinherited

Reimplemented from PileUpToolBase.

Definition at line 104 of file MuonDigitizationTool.cxx.

                                                                                   {        
        ATH_MSG_DEBUG("processBunchXing()" << bunchXing);
        PileUpHits hitList{}, hitListPermanent{};
        ATH_CHECK(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitList, bunchXing, bSubEvents, eSubEvents));
        ATH_MSG_VERBOSE(hitList.size() << " hits in  xAODMuonSimHitContainer " << m_inputObjectName << " found");
        for (auto& [hitPtr, hitContainer] : hitList) {
            auto copyContainer = std::make_unique<xAOD::MuonSimHitContainer>();
            auto copyAuxContainer = std::make_unique<xAOD::MuonSimHitAuxContainer>();
            copyContainer->setStore(copyAuxContainer.get());
            for (const xAOD::MuonSimHit* copyMe : *hitContainer) {
               (*copyContainer->push_back(std::make_unique<xAOD::MuonSimHit>())) = (*copyMe);
            }
            hitListPermanent.emplace_back(hitPtr, copyContainer.get());
            m_simHits.emplace_back(std::move(copyContainer), std::move(copyAuxContainer));
        } 
        ATH_CHECK(fillTimedHits(std::move(hitListPermanent), m_timedHits));
        return StatusCode::SUCCESS;
    }

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

timeOverThreshold()

double MuonR4::RpcDigiTool::timeOverThreshold ( CLHEP::HepRandomEngine * rndmEngine )

staticprivate

Roll the time over threshold for each signal digit.

Definition at line 328 of file RpcDigiTool.cxx.

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

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

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

writeDigitContainer()

template<class DigitCont, class DigitColl>

StatusCode MuonR4::MuonDigitizationTool::writeDigitContainer ( const EventContext & ctx, const SG::WriteHandleKey< DigitCont > & key, OutDigitCache_t< DigitColl > && digitCache, unsigned int hashMax ) const

protectedinherited

Helper function to move the collected digits into the final DigitContainer.

The function needs the maximal size of the container in advance which is provided by calling the module_hash_max() function of the corresponding MuonIdHelper.

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

std::array<std::atomic<unsigned>, 2> m_acceptedHits MuonR4::RpcDigiTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 71 of file RpcDigiTool.h.

{};

ATLAS_THREAD_SAFE [2/2]

std::array<std::atomic<unsigned>, 2> m_allHits MuonR4::RpcDigiTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 69 of file RpcDigiTool.h.

{};

m_deadTime

Gaudi::Property<double> MuonR4::RpcDigiTool::m_deadTime

private

Initial value:

{this, "deadTime",
                                     100. * Gaudi::Units::nanosecond}

Definition at line 81 of file RpcDigiTool.h.

                                  {this, "deadTime",
                                     100. * Gaudi::Units::nanosecond};

m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::MuonDigitizationTool::m_detMgr {nullptr}

protectedinherited

Definition at line 111 of file MuonDigitizationTool.h.

{nullptr};

m_digitizeMuonOnly

Gaudi::Property<bool> MuonR4::RpcDigiTool::m_digitizeMuonOnly

private

Initial value:

{
      this, "ProcessTrueMuonsOnly", false,
      "If set to true hit with pdgId != 13 are skipped"}

Definition at line 84 of file RpcDigiTool.h.

                                        {
      this, "ProcessTrueMuonsOnly", false,
      "If set to true hit with pdgId != 13 are skipped"};

m_effiDataKey

SG::ReadCondHandleKey<Muon::DigitEffiData> MuonR4::RpcDigiTool::m_effiDataKey

private

Initial value:

{
      this, "EffiDataKey", "RpcDigitEff",
      "Efficiency constants of the individual Rpc gasGaps"}

Definition at line 65 of file RpcDigiTool.h.

                                                      {
      this, "EffiDataKey", "RpcDigitEff",
      "Efficiency constants of the individual Rpc gasGaps"};

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

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

Definition at line 54 of file PileUpToolBase.h.

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

m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonR4::MuonDigitizationTool::m_geoCtxKey

privateinherited

Initial value:

{this, "AlignmentKey", "ActsAlignment", 
                                                               "Geometry context"}

Definition at line 123 of file MuonDigitizationTool.h.

                                                  {this, "AlignmentKey", "ActsAlignment", 
                                                               "Geometry context"};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::MuonDigitizationTool::m_idHelperSvc

protectedinherited

Initial value:

{this, "MuonIdHelperSvc", 
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 113 of file MuonDigitizationTool.h.

                                                             {this, "MuonIdHelperSvc", 
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_includePileUpTruth

Gaudi::Property<bool> MuonR4::MuonDigitizationTool::m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}

privateinherited

Definition at line 137 of file MuonDigitizationTool.h.

{this, "IncludePileUpTruth", true, "Include pile-up truth info"};

m_inputObjectName

std::string MuonR4::MuonDigitizationTool::m_inputObjectName {""}

privateinherited

Definition at line 139 of file MuonDigitizationTool.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.

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

m_mergeSvc

ServiceHandle<PileUpMergeSvc> MuonR4::MuonDigitizationTool::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}

privateinherited

Definition at line 126 of file MuonDigitizationTool.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};

m_onlyUseContainerName

Gaudi::Property<bool> MuonR4::MuonDigitizationTool::m_onlyUseContainerName

privateinherited

Initial value:

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

Definition at line 134 of file MuonDigitizationTool.h.

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

m_propagationVelocity

Gaudi::Property<double> MuonR4::RpcDigiTool::m_propagationVelocity

private

Initial value:

{
      this, "propSpeed", 0.5 * Gaudi::Units::c_light,
      "Propagation speed of the signal inside the strip"}

Definition at line 73 of file RpcDigiTool.h.

                                             {
      this, "propSpeed", 0.5 * Gaudi::Units::c_light,
      "Propagation speed of the signal inside the strip"}; // in mm/ns

m_rndmSvc

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

privateinherited

Definition at line 130 of file MuonDigitizationTool.h.

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

m_sdoKey

SG::WriteHandleKey<xAOD::MuonSimHitContainer> MuonR4::MuonDigitizationTool::m_sdoKey {this, "OutputSDOName", ""}

privateinherited

Definition at line 132 of file MuonDigitizationTool.h.

{this, "OutputSDOName", ""};

m_simHitKey

SG::ReadHandleKey<xAOD::MuonSimHitContainer> MuonR4::MuonDigitizationTool::m_simHitKey {this, "SimHitKey", ""}

privateinherited

Definition at line 121 of file MuonDigitizationTool.h.

{this, "SimHitKey", ""};

m_simHits

std::vector<SimHitLocalCopy> MuonR4::MuonDigitizationTool::m_simHits {}

privateinherited

Definition at line 145 of file MuonDigitizationTool.h.

{};

m_streamName

Gaudi::Property<std::string> MuonR4::MuonDigitizationTool::m_streamName {this, "StreamName", ""}

privateinherited

Definition at line 128 of file MuonDigitizationTool.h.

{this, "StreamName", ""};

m_stripTimeResolution

Gaudi::Property<double> MuonR4::RpcDigiTool::m_stripTimeResolution

private

Initial value:

{
      this, "timeResolution", 0.6 * Gaudi::Units::nanosecond,
      "Estimated time resolution of the strip readout"}

Definition at line 77 of file RpcDigiTool.h.

                                             {
      this, "timeResolution", 0.6 * Gaudi::Units::nanosecond,
      "Estimated time resolution of the strip readout"};

m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}

privateinherited

Definition at line 141 of file MuonDigitizationTool.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.

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

m_writeKey

SG::WriteHandleKey<RpcDigitContainer> MuonR4::RpcDigiTool::m_writeKey

private

Initial value:

{this, "OutputObjectName",
                                                   "RPC_DIGITS"}

Definition at line 62 of file RpcDigiTool.h.

                                                {this, "OutputObjectName",
                                                   "RPC_DIGITS"};

---

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

• RpcDigiTool.h
• RpcDigiTool.cxx