#include <sTgcDigitizationTool.h>

Inheritance diagram for MuonR4::sTgcDigitizationTool:

Collaboration diagram for MuonR4::sTgcDigitizationTool:

Classes
struct	SimHitSorter
	Data type to deduplicate the SDOs && associate them with the digit produced by them. More...
class	sTgcSimDigitHit

Public Types
using	ReadoutChannelType = sTgcIdHelper::sTgcChannelTypes
	ReadoutChannelType to distinguish the available readout channels Pad - pad readout channel Strip - eta strip readout channel Wire - phi wire group readout channel.
using	DigiConditions = sTgcDigitMaker::DigiConditions
using	sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec
using	DigiCache = OutDigitCache_t<sTgcDigitCollection>
using	sTgcSimDigitVec = std::vector<sTgcSimDigitHit>

Public Member Functions
StatusCode	initialize () override final
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.
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
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	SdoIdMap_t = std::map<const TimedHit, std::vector<Identifier>, SimHitSorter>
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
StatusCode	processDigitsWithVMM (const EventContext &ctx, const DigiConditions &digiCond, sTgcSimDigitVec &&digitsInChamber, const double vmmDeadTime, const bool isNeighbourOn, sTgcDigitCollection &outColl, SdoIdMap_t &sdoIdMap) const
sTgcSimDigitVec	mergeDigitsVMM (const EventContext &ctx, const DigiConditions &digiCond, const double vmmDeadTime, const bool isNeighbourOn, sTgcSimDigitVec &&unmergedDigits) const
uint16_t	bcTagging (const double digitTime) const
double	getChannelThreshold (const EventContext &ctx, const Identifier &channelID, const NswCalibDbThresholdData &thresholdData) const
StatusCode	fillTimedHits (PileUpHits &&hitColl, TimedHits &timedHits) const
	Translates the PileUpHits into the timed hits format.

Private Attributes
SG::WriteHandleKey< sTgcDigitContainer >	m_writeKey {this, "OutputObjectName", "STGC_DIGITS"}
SG::ReadCondHandleKey< Muon::DigitEffiData >	m_effiDataKey {this, "EffiDataKey", "sTgcDigitEff", "Efficiency constants"}
SG::ReadCondHandleKey< NswCalibDbThresholdData >	m_condThrshldsKey {this, "CondThrshldsKey", "NswCalibDbThresholdData", "Calibration data"}
ToolHandle< Muon::INSWCalibSmearingTool >	m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/STGCCalibSmearingTool"}
ToolHandle< Muon::INSWCalibTool >	m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/STGCCalibTool"}
Gaudi::Property< bool >	m_digitizeMuonOnly {this, "ProcessTrueMuonsOnly", false}
Gaudi::Property< bool >	m_useTimeWindow {this, "UseTimeWindow", true}
Gaudi::Property< bool >	m_doSmearing {this, "doSmearing", false}
Gaudi::Property< bool >	m_doToFCorrection {this,"doToFCorrection", true}
Gaudi::Property< int >	m_digitMode {this, "digitMode", 3}
Gaudi::Property< bool >	m_doPadSharing {this,"padChargeSharing", false}
Gaudi::Property< double >	m_deadtimeStrip {this,"deadtimeStrip", 250}
Gaudi::Property< double >	m_deadtimePad {this,"deadtimePad" , 250}
Gaudi::Property< double >	m_deadtimeWire {this,"deadtimeWire" , 250}
Gaudi::Property< bool >	m_doNeighborOn {this,"neighborOn", true}
Gaudi::Property< double >	m_runVoltage {this,"operatingHVinkV" , 2.8}
Gaudi::Property< bool >	m_useCondThresholds
Gaudi::Property< double >	m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV}
Gaudi::Property< double >	m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV}
Gaudi::Property< double >	m_chargeThreshold {this,"chargeThreshold", 0.030}
std::unique_ptr< sTgcDigitMaker >	m_digitizer {}
SG::ReadHandleKey< xAOD::MuonSimHitContainer >	m_simHitKey {this, "SimHitKey", ""}
SG::ReadHandleKey< ActsTrk::GeometryContext >	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 {}

Static Private Attributes
static constexpr double	m_timeJitterElectronicsStrip {2.f}
static constexpr double	m_timeJitterElectronicsPad {2.f}
static constexpr double	m_hitTimeMergeThreshold {30.f}

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 28 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.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::sTgcDigitizationTool::DigiCache = OutDigitCache_t<sTgcDigitCollection>

Definition at line 42 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

◆ DigiConditions

using MuonR4::sTgcDigitizationTool::DigiConditions = sTgcDigitMaker::DigiConditions

Definition at line 40 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.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.

◆ ReadoutChannelType

using MuonR4::sTgcDigitizationTool::ReadoutChannelType = sTgcIdHelper::sTgcChannelTypes

ReadoutChannelType to distinguish the available readout channels Pad - pad readout channel Strip - eta strip readout channel Wire - phi wire group readout channel.

Definition at line 39 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

◆ SdoIdMap_t

using MuonR4::sTgcDigitizationTool::SdoIdMap_t = std::map<const TimedHit, std::vector<Identifier>, SimHitSorter>

private

Definition at line 110 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.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.

◆ sTgcDigitVec

using MuonR4::sTgcDigitizationTool::sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec

Definition at line 41 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

◆ sTgcSimDigitVec

using MuonR4::sTgcDigitizationTool::sTgcSimDigitVec = std::vector<sTgcSimDigitHit>

Definition at line 64 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.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 142 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;
    }

◆ bcTagging()

uint16_t sTgcDigitizationTool::bcTagging ( const double digitTime ) const

private

Definition at line 47 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitizationTool.cxx.

                                                                       {
    uint16_t bctag = 0;
    int bunchInteger = (digitTime > 0) ? static_cast<int>(std::abs(digitTime / 25.0))
                                       : static_cast<int>(std::abs(digitTime / 25.0)) + 1;
    bctag = (bctag | bunchInteger);
    if (digitTime < 0) bctag = ~bctag;
    return bctag;
  }

◆ digitize()

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

finaloverridevirtual

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.

Storing hit position and direction in local frame

apply the smearing tool to decide if the hit has to be digitized or not based on layer efficiency

Add the only the hits and digits that pass VMM simulation to sdo container

Digits are sorted by

Implements MuonR4::MuonDigitizationTool.

Definition at line 72 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitizationTool.cxx.

                                                                                         {
    const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
    CLHEP::HepRandomEngine* rndEngine = getRandomEngine(ctx);
    const ActsTrk::GeometryContext &gctx{getGeoCtx(ctx)};
 
    const Muon::DigitEffiData* efficiencyMap{nullptr};
    ATH_CHECK(SG::get(efficiencyMap, m_effiDataKey, ctx));
    const NswCalibDbThresholdData* thresholdData{nullptr};
    ATH_CHECK(SG::get(thresholdData, m_condThrshldsKey, ctx));
 
    DigiConditions digiCond{efficiencyMap, thresholdData, rndEngine};
    DigiCache digitCache{};
  
    double earliestEventTime = std::numeric_limits<double>::max();
    xAOD::ChamberViewer viewer{hitsToDigit, m_idHelperSvc.get()};
    const double angular_tolerance = 1e-3; // ~0.057 degrees
 
    do {
      if (viewer.size() == 0) {
          ATH_MSG_VERBOSE("No hits to digitize — skipping sTGC digitization.");
          continue;
      }   
      std::array<sTgcSimDigitVec , 3> simDigitsByChType{};
      for (const TimedHit& hit : viewer) {
 
        if (m_digitizeMuonOnly && !MC::isMuon(hit)) {
          ATH_MSG_VERBOSE("Hit is not from a muon - skipping ");
          continue;
        }
        ATH_MSG_VERBOSE("Hit Particle ID : " << hit->pdgId() );
        double eventTime = hit.eventTime();
        earliestEventTime = std::min(earliestEventTime, eventTime);
        if (hit->energyDeposit() < m_energyDepositThreshold){
          ATH_MSG_VERBOSE("Hit with Energy Deposit of " << hit->energyDeposit()
          << " less than " << m_energyDepositThreshold << ". Skip this hit." );
          continue;
        }
        const Amg::Vector3D locHitPos = xAOD::toEigen(hit->localPosition());
        const Amg::Vector3D locHitDir = xAOD::toEigen(hit->localDirection());
 
        const double hitKineticEnergy = hit->kineticEnergy();
        if (hitKineticEnergy < m_limitElectronKineticEnergy && MC::isElectron(hit)) {
          ATH_MSG_DEBUG("Skip electron hit with kinetic energy " << hitKineticEnergy
                      << ", which is less than the lower limit of " << m_limitElectronKineticEnergy);
          continue;
        }
 
        // No support for particles with direction perpendicular to the beam line, since such particles
        // can deposit energy on a lot of strips and pads of the gas gap.
        const double theta = std::acos(locHitDir.z());  // polar angle from Z axis
        const double ninetyDegrees = std::numbers::pi / 2;
        // Reject hits that are too close to 90 degrees (i.e., perpendicular to Z)
        if (std::abs(theta - ninetyDegrees) < angular_tolerance) {
          ATH_MSG_VERBOSE("Skipping hit nearly perpendicular to Z-axis (angle: " << theta << ")");
          continue;
        }
        if (std::abs(locHitDir.z()) < 0.00001) {
          ATH_MSG_VERBOSE("Skipping hit nearly perpendicular to Z-axis.");
          continue;
        }
        if(eventTime != 0){
          ATH_MSG_DEBUG("Updated hit global time to include off set of " << eventTime << " ns from OOT bunch.");
        }
        else {
          ATH_MSG_DEBUG("This hit came from the in time bunch.");
        }
 
        const Identifier hitId = hit->identify();
        if (m_doSmearing) {
          bool acceptHit = true;
          ATH_CHECK(m_smearingTool->isAccepted(hitId, acceptHit, rndEngine));
          if ( !acceptHit ) {
            ATH_MSG_DEBUG("Dropping the hit - smearing tool");
            continue;
          }
        }
        const MuonGMR4::sTgcReadoutElement* readoutElement = m_detMgr->getsTgcReadoutElement(hitId);
        const Amg::Vector3D globalHitPos = readoutElement->localToGlobalTransform(gctx, hitId) * locHitPos;
        double globalHitTime = hit->globalTime() + eventTime;
        double tofCorrection = globalHitPos.mag() / Gaudi::Units::c_light;
        double bunchTime = globalHitTime - tofCorrection;
 
        const HepMcParticleLink particleLink = hit->genParticleLink();
        // Print some information about the sTGC hit
        ATH_MSG_VERBOSE("hitID  " << m_idHelperSvc->toString(hitId) << " Hit bunch time  " << bunchTime << " tof/G4 hit time " << globalHitTime
                                  << " globalHitPosition " << Amg::toString(globalHitPos) << " hit: r " << globalHitPos.perp() << " z " << globalHitPos.z()
                                  << " mclink " << particleLink << "Kinetic energy " << hitKineticEnergy);
        ATH_MSG_VERBOSE("Total hits passed to digitize: " << hitsToDigit.size());   
        sTgcDigitVec digitizedHits = m_digitizer->executeDigi(digiCond, hit);
        if(digitizedHits.empty()) {
          continue;
        }
        ATH_MSG_VERBOSE("Hit produced " << digitizedHits.size() << " digits." );
 
        for (std::unique_ptr<sTgcDigit>& digit : digitizedHits) {
          /*
          NOTE:
          -----
          Since not every hit might end up resulting in a
          digit, this construction might take place after the hit loop
          in a loop of its own!
          */
          // make new sTgcDigit
          const Identifier digitId = digit->identify();
          double digitTime = digit->time();
          int digitChType = idHelper.channelType(digitId);
          
          if(digitChType == ReadoutChannelType::Strip) {
            digitTime += CLHEP::RandGaussZiggurat::shoot(rndEngine, 0, m_timeJitterElectronicsStrip);
          }
          else {
            digitTime += CLHEP::RandGaussZiggurat::shoot(rndEngine, 0, m_timeJitterElectronicsPad);
          }
 
          uint16_t digitBCTag = bcTagging(digitTime + bunchTime);
          digitTime += m_doToFCorrection ? bunchTime : globalHitTime;
 
          double digitCharge = digit->charge();
          // Create a new digit with updated time and BCTag
          int eventId = hit.eventId();
          bool isDead{false}, isPileup{eventId != 0};
          ATH_MSG_VERBOSE("Hit is from the main signal subevent if eventId is zero, eventId = "
                            << eventId << " newDigit time: " << digitTime);  
          auto newDigitPtr = std::make_unique<sTgcDigit>(digitId, digitBCTag, digitTime, digitCharge, isDead, isPileup);
          if (digitChType == ReadoutChannelType::Strip) {
            ATH_MSG_VERBOSE("Finalizing Digit "<<m_idHelperSvc->toString(digitId)
                        <<" BC tag = "    << newDigitPtr->bcTag() 
                        <<" digitTime = " << newDigitPtr->time()
                        <<" charge = "    << newDigitPtr->charge());
          }
          simDigitsByChType[digitChType].emplace_back(hit, std::move(newDigitPtr));
        }
      }
      SdoIdMap_t sdoIdMap{};
      sTgcDigitCollection* outColl = fetchCollection(viewer.at(0)->identify(), digitCache);
   
      ATH_CHECK(processDigitsWithVMM(ctx, digiCond, std::move(simDigitsByChType[ReadoutChannelType::Strip]), 
                                      m_deadtimeStrip, m_doNeighborOn, *outColl, sdoIdMap));
      ATH_CHECK(processDigitsWithVMM(ctx, digiCond, std::move(simDigitsByChType[ReadoutChannelType::Pad]), 
                                      m_deadtimePad, false, *outColl, sdoIdMap));
      ATH_CHECK(processDigitsWithVMM(ctx, digiCond, std::move(simDigitsByChType[ReadoutChannelType::Wire]), 
                                      m_deadtimeWire, false, *outColl, sdoIdMap));
      for (auto& [simHit, assocIds]: sdoIdMap) {
          xAOD::MuonSimHit* sdoHit = addSDO(simHit, sdoContainer);
          if (!sdoHit) {
             continue;
          }
          std::ranges::sort(assocIds, [&](const Identifier& a, const Identifier& b){
               const int typeA = idHelper.channelType(a);
               const int typeB = idHelper.channelType(b);
               if (typeA != typeB) {
                  if (typeA == sTgcIdHelper::sTgcChannelTypes::Strip) {
                      return true;
                  } else if (typeB == sTgcIdHelper::sTgcChannelTypes::Strip) {
                      return false;
                  }
                  return typeA > typeB;
               }
               return idHelper.channel(a) < idHelper.channel(b);
          });
          const double globalHitTime = sdoHit->globalTime() + simHit.eventTime();
          sdoHit->setGlobalTime(globalHitTime);
 
          sdoHit->setIdentifier(assocIds.front());
          assocIds.erase(assocIds.begin());
 
          using ChVec_t = std::vector<std::uint16_t>;
          static const SG::Decorator<ChVec_t> dec_stripCh{"sTgc_stripChannels"};
          static const SG::Decorator<ChVec_t> dec_wireCh{"sTgc_wireChannels"};
          static const SG::Decorator<ChVec_t> dec_padCh{"sTgc_padChannels"};
          ChVec_t& stripCh{dec_stripCh(*sdoHit)}, wireCh{dec_wireCh(*sdoHit)}, padCh{dec_padCh(*sdoHit)};
 
          std::ranges::for_each(assocIds,[&](const Identifier& secId){
              const int ch = idHelper.channel(secId);
              switch(idHelper.channelType(secId)){
                 using enum sTgcIdHelper::sTgcChannelTypes;
                 case Strip: {
                    stripCh.push_back(ch);
                    break;
                 }case Wire: {
                    wireCh.push_back(ch);
                    break;
                 }case Pad: {
                    padCh.push_back(ch);
                    break;
                 }
              }
          });
 
 
      }
    } while (viewer.next());
    ATH_CHECK(writeDigitContainer(ctx, m_writeKey, std::move(digitCache), idHelper.module_hash_max()));
    
    return StatusCode::SUCCESS;
  }

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

49{ return m_filterPassed; }

PileUpToolBase::m_filterPassed

bool m_filterPassed

Definition PileUpToolBase.h:60

◆ getChannelThreshold()

double sTgcDigitizationTool::getChannelThreshold	(	const EventContext &	ctx,
		const Identifier &	channelID,
		const NswCalibDbThresholdData &	thresholdData ) const

private

Definition at line 56 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitizationTool.cxx.

                                                                                                       {
    float threshold = m_chargeThreshold;
    std::optional<float> elecThreshold = thresholdData.getThreshold(channelID);
    if (!elecThreshold) {
      THROW_EXCEPTION("Cannot retrieve VMM threshold from conditions database!");
    }
    
    if (!m_calibrationTool->pdoToCharge(ctx, true, *elecThreshold, channelID, threshold)) {
      THROW_EXCEPTION("Cannot convert VMM charge threshold via conditions data!");
    }
    
    return threshold;    
  }

◆ 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 135 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 129 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);
    }

◆ 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 63 of file MuonDigitizationTool.cxx.

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

◆ initialize()

StatusCode sTgcDigitizationTool::initialize ( )

finaloverridevirtual

meanGasGain is the mean value of the polya gas gain function describing the avalanche of electrons caused by the electric field Parameterization is obtained from ATL-MUON-PUB-2014-001 and the corrected fit to data to parameterize gain vs HV in kV

Reimplemented from MuonR4::MuonDigitizationTool.

Definition at line 11 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitizationTool.cxx.

                                              {
    ATH_MSG_DEBUG("sTgcDigitizationTool::initialize()");
    ATH_MSG_DEBUG ( "Configuration  sTgcDigitizationTool" );
    ATH_MSG_DEBUG ( "doSmearing             "<< m_doSmearing);
    ATH_MSG_DEBUG("OutputObjectName       " << m_writeKey.key());
    ATH_MSG_DEBUG ( "HV                     " << m_runVoltage);
    ATH_MSG_DEBUG ( "threshold              " << m_chargeThreshold);
    ATH_MSG_DEBUG ( "useCondThresholds      " << m_useCondThresholds);
 
    ATH_CHECK(MuonDigitizationTool::initialize());
    ATH_CHECK(m_writeKey.initialize());
    ATH_CHECK(m_effiDataKey.initialize(!m_effiDataKey.empty()));
    ATH_CHECK(m_condThrshldsKey.initialize(m_useCondThresholds));
    ATH_CHECK(m_smearingTool.retrieve());
    ATH_CHECK(m_calibrationTool.retrieve());
    
    if (m_doSmearing) {
      ATH_MSG_INFO("Running in smeared mode!");
    }
    if (m_runVoltage < 2.3 || m_runVoltage > 3.2){
      ATH_MSG_WARNING("STGC run voltage must be within fit domain of 2.3 kV to 3.2 kV");
      return StatusCode::FAILURE;
    }
    double meanGasGain = 2.15 * 1E-4 * std::exp(6.88*m_runVoltage);
    sTgcDigitMaker::digitMode mode = static_cast<sTgcDigitMaker::digitMode>(m_digitMode.value());
    m_digitizer = std::make_unique<sTgcDigitMaker>(m_detMgr, mode, meanGasGain, m_doPadSharing);
    ATH_CHECK(m_digitizer->initialize());
    
    return StatusCode::SUCCESS;
  }

◆ mergeDigitsVMM()

sTgcDigitizationTool::sTgcSimDigitVec sTgcDigitizationTool::mergeDigitsVMM	(	const EventContext &	ctx,
		const DigiConditions &	digiCond,
		const double	vmmDeadTime,
		const bool	isNeighbourOn,
		sTgcSimDigitVec &&	unmergedDigits ) const

private

Sort Digits in the unmergedDigits vector by gasgap -> channelType -> time

Catch the cases where the channel is 1 or maxChannel

merge digits in time. Do weighted average to find time of digits originally below threshold. Follows what we expect from real VMM.

We reached another digit. No need to merge

Definition at line 335 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitizationTool.cxx.

                                                                                   {
 
    const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
    std::ranges::stable_sort(unmergedDigits,
      [&idHelper](const sTgcSimDigitHit& a, const sTgcSimDigitHit& b) {
        const int layA = idHelper.gasGap(a.identify()); 
        const int layB = idHelper.gasGap(b.identify());
        if (layA != layB) {
          return layA < layB;
        }
        const int chA = idHelper.channel(a.identify());
        const int chB = idHelper.channel(b.identify());
        if (chA != chB) {
          return chA < chB;
        }
        return a.time() < b.time();
      }
    );
    sTgcSimDigitVec savedDigits{}, premerged{};
    
    premerged.reserve(unmergedDigits.size());
    savedDigits.reserve(premerged.capacity());
 
    auto passNeigbourLogic = [&](const sTgcSimDigitHit& candidate) {
      if (!isNeighbourOn || savedDigits.empty()) {
        return false;
      }
      if (savedDigits.back().identify() == candidate.identify() &&
          std::abs(savedDigits.back().time() - candidate.time()) < vmmDeadTime) {
            ATH_MSG_VERBOSE("Digits are too close in time ");
            return false;
      }
      const Identifier digitId = candidate.identify();
      const int channel = idHelper.channel(digitId);
      const MuonGMR4::sTgcReadoutElement* reEle = m_detMgr->getsTgcReadoutElement(digitId);
      const IdentifierHash hitHash = reEle->measurementHash(digitId);
      const int maxChannel = reEle->numChannels(hitHash);
      for (int neighbour : {std::max(1, channel -1), std::min(maxChannel, channel+1)}) {
        if (neighbour == channel) {
          continue;
        }
        const Identifier neighbourId = idHelper.channelID(digitId, 
                                                          reEle->multilayer(),
                                                          idHelper.gasGap(digitId), 
                                                          idHelper.channelType(digitId), neighbour);
        const double threshold = m_useCondThresholds ? getChannelThreshold(ctx, neighbourId, *digiCond.thresholdData)  
                                                      : m_chargeThreshold.value();          
        if (std::ranges::any_of(savedDigits, [&](const sTgcSimDigitHit& known){
            return known.identify() == neighbourId && 
                    known.getDigit().charge() > threshold &&
                    std::abs(known.time() - candidate.time()) <  m_hitTimeMergeThreshold;
        })) {
          return true;
        }
      }
      return false;
    };
    // Sort digits on every channel by earliest to latest time
    // Also do hit merging to help with neighborOn logic
    double threshold = m_chargeThreshold;
    for (sTgcSimDigitVec::iterator merge_me = unmergedDigits.begin(); merge_me!= unmergedDigits.end(); ++merge_me) {
      if(m_useCondThresholds) {
        threshold = getChannelThreshold(ctx, (*merge_me).identify(), *digiCond.thresholdData);
      }
      sTgcDigit& digit1{(*merge_me).getDigit()};
      double totalCharge = digit1.charge();
      double weightedTime = digit1.time();
        
      sTgcSimDigitVec::iterator merge_with = merge_me + 1;
      for ( ; merge_with!= unmergedDigits.end(); ++merge_with) {
        if ((*merge_with).identify() != (*merge_me).identify()) {
            break;
        }
        const sTgcDigit& mergeDigit{(*merge_with).getDigit()};
        // If future digits are within window, digit1 absorbs its charge
        if (mergeDigit.time() - digit1.time() > m_hitTimeMergeThreshold) break;
        // If digit1 is not above threshold prior to merging, the new time is
        // a weighted average. Do it for every merging pair.
        if (totalCharge < threshold) {
          weightedTime = (weightedTime * totalCharge + mergeDigit.time() * mergeDigit.charge())
                        / (totalCharge + mergeDigit.charge());
        }
        totalCharge += mergeDigit.charge();
      }
      digit1.set_charge(totalCharge);
      digit1.set_time(weightedTime);
      sTgcSimDigitHit& mergedHit{*merge_me};
      if (!savedDigits.empty() && 
          savedDigits.back().identify() == digit1.identify() &&
          std::abs(savedDigits.back().time() - digit1.time()) <= vmmDeadTime) continue;
      if (digit1.charge() > threshold || passNeigbourLogic(mergedHit)){
          savedDigits.emplace_back(std::move(mergedHit));
      } else if (isNeighbourOn) {
          premerged.emplace_back(std::move(mergedHit));
      }    
    } // end of time-ordering and hit merging loop
    std::copy_if(std::make_move_iterator(premerged.begin()),
                 std::make_move_iterator(premerged.end()),
                 std::back_inserter(savedDigits), passNeigbourLogic);
    return savedDigits;
  }

◆ mergeEvent()

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

finaloverrideinherited

Definition at line 92 of file MuonDigitizationTool.cxx.

                                                                       {
        ATH_MSG_DEBUG("mergeEvent()");
        
        SG::WriteHandle<xAOD::MuonSimHitContainer> sdoContainer{};
        if (!m_sdoKey.empty()) {
             sdoContainer = SG::WriteHandle<xAOD::MuonSimHitContainer>{m_sdoKey, ctx};
             ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
                                           std::make_unique<xAOD::MuonSimHitAuxContainer>()));
        }
        ATH_CHECK(digitize(ctx, m_timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
        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 164 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 35 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 71 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));
        SG::WriteHandle<xAOD::MuonSimHitContainer> sdoContainer{};
        if (!m_sdoKey.empty()) {
             sdoContainer = SG::WriteHandle<xAOD::MuonSimHitContainer>{m_sdoKey, ctx};
             ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
                                           std::make_unique<xAOD::MuonSimHitAuxContainer>()));
        }
        ATH_CHECK(digitize(ctx, timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
        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 66 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 108 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;
    }

◆ processDigitsWithVMM()

StatusCode sTgcDigitizationTool::processDigitsWithVMM	(	const EventContext &	ctx,
		const DigiConditions &	digiCond,
		sTgcSimDigitVec &&	digitsInChamber,
		const double	vmmDeadTime,
		const bool	isNeighbourOn,
		sTgcDigitCollection &	outColl,
		SdoIdMap_t &	sdoIdMap ) const

private

Sort all digits from the same chamber according to layer->channelType->time

Update the container iterator to go to the next chamber

apply the smearing before adding the digit

Select strips with charge > 0.001 pC to avoid having zero ADC count when converting charge [pC] to PDO [ADC count]

Add the only the hits and digits that pass VMM simulation to sdo container

Add the VMM processed digit to cache

Definition at line 277 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitizationTool.cxx.

                                                                                    {
    
    if (digitsInChamber.empty()) {
      ATH_MSG_DEBUG("Empty hits from VMM Simulation" );
      return StatusCode::SUCCESS;
    }
    const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
    
    sTgcSimDigitVec mergedDigits = mergeDigitsVMM(ctx, digiCond, vmmDeadTime, 
                                                  isNeighbourOn, std::move(digitsInChamber));
    if (mergedDigits.empty()) {
      return StatusCode::SUCCESS;
    }
 
    for (sTgcSimDigitHit& merged : mergedDigits) {
      
      bool acceptDigit{true};
      float chargeAfterSmearing = merged.getDigit().charge();
      if (m_doSmearing) {
          ATH_CHECK(m_smearingTool->smearCharge(merged.identify(), chargeAfterSmearing, acceptDigit, 
                                                digiCond.rndEngine));
      }
      if (!acceptDigit) {
          continue;
      }
      if (idHelper.channelType(merged.identify()) == ReadoutChannelType::Strip &&
          chargeAfterSmearing < 0.001) {
          continue;
      }
      auto finalDigit = merged.releaseDigit();
      if (m_doSmearing) {
          finalDigit->set_charge(chargeAfterSmearing);
      }
      ATH_MSG_VERBOSE("Final Digit "<<m_idHelperSvc->toString(finalDigit->identify())<<
                      " BC tag = "    << finalDigit->bcTag()<<
                      " digitTime = " << finalDigit->time() <<
                      " charge = "    << finalDigit->charge());
      sdoIdMap[merged.getSimHit()].push_back(finalDigit->identify());
      outColl.push_back(std::move(finalDigit)); 
    }    
    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.

51{ m_filterPassed=true; }

◆ 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

◆ m_calibrationTool

ToolHandle<Muon::INSWCalibTool> MuonR4::sTgcDigitizationTool::m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/STGCCalibTool"}

private

Definition at line 77 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

77{this, "CalibrationTool", "Muon::NSWCalibTool/STGCCalibTool"};

◆ m_chargeThreshold

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_chargeThreshold {this,"chargeThreshold", 0.030}

private

Definition at line 97 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

97{this,"chargeThreshold", 0.030};

◆ m_condThrshldsKey

SG::ReadCondHandleKey<NswCalibDbThresholdData> MuonR4::sTgcDigitizationTool::m_condThrshldsKey {this, "CondThrshldsKey", "NswCalibDbThresholdData", "Calibration data"}

private

Definition at line 74 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

74{this, "CondThrshldsKey", "NswCalibDbThresholdData", "Calibration data"};

◆ m_deadtimePad

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_deadtimePad {this,"deadtimePad" , 250}

private

Definition at line 87 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

87{this,"deadtimePad" , 250};

◆ m_deadtimeStrip

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_deadtimeStrip {this,"deadtimeStrip", 250}

private

Definition at line 86 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

86{this,"deadtimeStrip", 250};

◆ m_deadtimeWire

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_deadtimeWire {this,"deadtimeWire" , 250}

private

Definition at line 88 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

88{this,"deadtimeWire" , 250};

◆ m_detMgr

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

protectedinherited

Definition at line 111 of file MuonDigitizationTool.h.

111{nullptr};

◆ m_digitizeMuonOnly

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_digitizeMuonOnly {this, "ProcessTrueMuonsOnly", false}

private

Definition at line 79 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

79{this, "ProcessTrueMuonsOnly", false};

◆ m_digitizer

std::unique_ptr<sTgcDigitMaker> MuonR4::sTgcDigitizationTool::m_digitizer {}

private

Definition at line 133 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

133{};

◆ m_digitMode

Gaudi::Property<int> MuonR4::sTgcDigitizationTool::m_digitMode {this, "digitMode", 3}

private

Definition at line 84 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

84{this, "digitMode", 3}; //

◆ m_doNeighborOn

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_doNeighborOn {this,"neighborOn", true}

private

Definition at line 89 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

89{this,"neighborOn", true};

◆ m_doPadSharing

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_doPadSharing {this,"padChargeSharing", false}

private

Definition at line 85 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

85{this,"padChargeSharing", false};

◆ m_doSmearing

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_doSmearing {this, "doSmearing", false}

private

Definition at line 81 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

81{this, "doSmearing", false};

◆ m_doToFCorrection

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_doToFCorrection {this,"doToFCorrection", true}

private

Definition at line 82 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

82{this,"doToFCorrection", true};

◆ m_effiDataKey

SG::ReadCondHandleKey<Muon::DigitEffiData> MuonR4::sTgcDigitizationTool::m_effiDataKey {this, "EffiDataKey", "sTgcDigitEff", "Efficiency constants"}

private

Definition at line 73 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

73{this, "EffiDataKey", "sTgcDigitEff", "Efficiency constants"};

◆ m_energyDepositThreshold

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV}

private

Definition at line 94 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

94{this,"energyDepositThreshold",300.0*CLHEP::eV};

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

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

54 {this, "FirstXing", -999,

55 "First bunch-crossing in which det is live"};

◆ m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonR4::MuonDigitizationTool::m_geoCtxKey

privateinherited

Initial value:

{this, "AlignmentKey", "ActsAlignment",

"Geometry context"}

Definition at line 123 of file MuonDigitizationTool.h.

123 {this, "AlignmentKey", "ActsAlignment",

124 "Geometry context"};

◆ m_hitTimeMergeThreshold

double MuonR4::sTgcDigitizationTool::m_hitTimeMergeThreshold {30.f}

staticconstexprprivate

Definition at line 101 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

101{30.f};

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

113 {this, "MuonIdHelperSvc",

114 "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.

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

139{""};

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

56 {this, "LastXing", 999,

57 "Last bunch-crossing in which det is live"};

◆ m_limitElectronKineticEnergy

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV}

private

Definition at line 95 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

95{this,"limitElectronKineticEnergy",5.0*CLHEP::MeV};

◆ m_mergeSvc

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

privateinherited

Definition at line 126 of file MuonDigitizationTool.h.

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

134 {this, "OnlyUseContainerName", false,

135 "Don't use the ReadHandleKey directly. Just extract the container name from it."};

◆ m_rndmSvc

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

privateinherited

Definition at line 130 of file MuonDigitizationTool.h.

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

◆ m_runVoltage

Gaudi::Property<double> MuonR4::sTgcDigitizationTool::m_runVoltage {this,"operatingHVinkV" , 2.8}

private

Definition at line 90 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

90{this,"operatingHVinkV" , 2.8};

◆ m_sdoKey

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

privateinherited

Definition at line 132 of file MuonDigitizationTool.h.

132{this, "OutputSDOName", ""};

◆ m_simHitKey

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

privateinherited

Definition at line 121 of file MuonDigitizationTool.h.

121{this, "SimHitKey", ""};

◆ m_simHits

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

privateinherited

Definition at line 145 of file MuonDigitizationTool.h.

145{};

◆ m_smearingTool

ToolHandle<Muon::INSWCalibSmearingTool> MuonR4::sTgcDigitizationTool::m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/STGCCalibSmearingTool"}

private

Definition at line 76 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

76{this, "SmearingTool", "Muon::NSWCalibSmearingTool/STGCCalibSmearingTool"};

◆ m_streamName

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

privateinherited

Definition at line 128 of file MuonDigitizationTool.h.

128{this, "StreamName", ""};

◆ m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}

privateinherited

Definition at line 141 of file MuonDigitizationTool.h.

141{};

◆ m_timeJitterElectronicsPad

double MuonR4::sTgcDigitizationTool::m_timeJitterElectronicsPad {2.f}

staticconstexprprivate

Definition at line 100 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

100{2.f};

◆ m_timeJitterElectronicsStrip

double MuonR4::sTgcDigitizationTool::m_timeJitterElectronicsStrip {2.f}

staticconstexprprivate

Definition at line 99 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

99{2.f};

◆ m_useCondThresholds

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_useCondThresholds

private

Initial value:

{this, "useCondThresholds", false,

"Use conditions data to get VMM charge threshold values"}

Definition at line 91 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

91 {this, "useCondThresholds", false,

92 "Use conditions data to get VMM charge threshold values"};

◆ m_useTimeWindow

Gaudi::Property<bool> MuonR4::sTgcDigitizationTool::m_useTimeWindow {this, "UseTimeWindow", true}

private

Definition at line 80 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

80{this, "UseTimeWindow", true};

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

58 {this, "VetoPileUpTruthLinks", true,

59 "Ignore links to suppressed pile-up truth"};

◆ m_writeKey

SG::WriteHandleKey<sTgcDigitContainer> MuonR4::sTgcDigitizationTool::m_writeKey {this, "OutputObjectName", "STGC_DIGITS"}

private

Definition at line 71 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitizationTool.h.

71{this, "OutputObjectName", "STGC_DIGITS"};

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

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

structors and AlgTool implementation

Detailed Description

Member Typedef Documentation

◆ DeadTimeMap

◆ DigiCache

◆ DigiConditions

◆ OutDigitCache_t

◆ PileUpHits

◆ ReadoutChannelType

◆ SdoIdMap_t

◆ SimHitLocalCopy

◆ sTgcDigitVec

◆ sTgcSimDigitVec

◆ TimedHit

◆ TimedHits

Member Function Documentation

◆ addSDO()

◆ bcTagging()

◆ digitize()

◆ fetchCollection()

◆ fillTimedHits()

◆ filterPassed()

◆ getChannelThreshold()

◆ getGeoCtx()

◆ getRandomEngine()

◆ hitTime()

◆ initialize()

◆ mergeDigitsVMM()

◆ mergeEvent()

◆ passDeadTime()

◆ PileUpToolBase()

◆ prepareEvent()

◆ processAllSubEvents() [1/2]

◆ processAllSubEvents() [2/2]

◆ processBunchXing()

◆ processDigitsWithVMM()

◆ resetFilter()

◆ toProcess()

◆ writeDigitContainer()

Member Data Documentation

◆ m_calibrationTool

◆ m_chargeThreshold

◆ m_condThrshldsKey

◆ m_deadtimePad

◆ m_deadtimeStrip

◆ m_deadtimeWire

◆ m_detMgr

◆ m_digitizeMuonOnly

◆ m_digitizer

◆ m_digitMode

◆ m_doNeighborOn

◆ m_doPadSharing

◆ m_doSmearing

◆ m_doToFCorrection

◆ m_effiDataKey

◆ m_energyDepositThreshold

◆ m_filterPassed

◆ m_firstXing

◆ m_geoCtxKey

◆ m_hitTimeMergeThreshold

◆ m_idHelperSvc

◆ m_includePileUpTruth

◆ m_inputObjectName

◆ m_lastXing

◆ m_limitElectronKineticEnergy

◆ m_mergeSvc

◆ m_onlyUseContainerName

◆ m_rndmSvc

◆ m_runVoltage