#include <MM_DigitizationTool.h>

Inheritance diagram for MuonR4::MM_DigitizationTool:

Public Member Functions
	MM_DigitizationTool (const std::string &type, const std::string &name, const IInterface *pIID)
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	NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants
using	DigiCache = OutDigitCache_t<MmDigitCollection>
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
MM_ElectronicsToolInput	combinedStripResponseAllHits (const EventContext &ctx, const std::vector< MM_ElectronicsToolInput > &v_stripDigitOutput) const
StatusCode	fillTimedHits (PileUpHits &&hitColl, TimedHits &timedHits) const
	Translates the PileUpHits into the timed hits format.

Private Attributes
SG::WriteHandleKey< MmDigitContainer >	m_writeKey {this, "OutputObjectName", "MM_DIGITS"}
SG::ReadCondHandleKey< Muon::DigitEffiData >	m_effiDataKey {this, "EffiDataKey", "MmDigitEff", "Efficiency constants of the individual MM gasGaps"}
SG::ReadCondHandleKey< NswErrorCalibData >	m_uncertCalibKey {this, "ErrorCalibKey", "NswUncertData", "Key of the parametrized NSW uncertainties"}
SG::ReadCondHandleKey< NswCalibDbThresholdData >	m_condThrshldsKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}
ToolHandle< Muon::INSWCalibSmearingTool >	m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}
ToolHandle< Muon::INSWCalibTool >	m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"}
Gaudi::Property< bool >	m_digitizeMuonOnly {this, "ProcessTrueMuonsOnly", true, "If set to true hit with pdgId != 13 are skipped"}
Gaudi::Property< std::string >	m_vmmReadoutMode {this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"}
Gaudi::Property< std::string >	m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}
Gaudi::Property< double >	m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to process an electron sim hit"}
Gaudi::Property< double >	m_timeWindowLowerOffset
Gaudi::Property< double >	m_timeWindowUpperOffset
Gaudi::Property< double >	m_DiffMagSecondMuonHit {this, "DiffMagSecondMuonHit", 0.1}
Gaudi::Property< int >	m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}
Gaudi::Property< bool >	m_writeOutputFile {this, "SaveInternalHistos", false}
Gaudi::Property< bool >	m_needsMcEventCollHelper {this, "UseMcEventCollectionHelper", false}
Gaudi::Property< bool >	m_checkMMSimHits {this, "CheckSimHits", true, "Control on the hit validity"}
Gaudi::Property< bool >	m_useTimeWindow {this, "UseTimeWindow", true}
Gaudi::Property< bool >	m_vmmNeighborLogic {this, "VMMNeighborLogic", false}
Gaudi::Property< bool >	m_doSmearing
Gaudi::Property< float >	m_qThreshold {this, "qThreshold", 0.001, "Charge Threshold"}
Gaudi::Property< float >	m_driftGapWidth {this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"}
Gaudi::Property< float >	m_crossTalk1 {this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"}
Gaudi::Property< float >	m_crossTalk2 {this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"}
Gaudi::Property< float >	m_avalancheGain {this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"}
Gaudi::Property< float >	m_electronicsThreshold
Gaudi::Property< float >	m_stripdeadtime {this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"}
Gaudi::Property< float >	m_ARTdeadtime {this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"}
Gaudi::Property< bool >	m_useCondThresholds
Gaudi::Property< bool >	m_useThresholdScaling
Gaudi::Property< float >	m_thresholdScaleFactor
Gaudi::Property< float >	m_vmmDeadtime {this, "vmmDeadtime", 200, "Specifies how much before the lower time limit the VMM simulation should start evaluating the signal"}
Gaudi::Property< float >	m_vmmUpperGrazeWindow {this, "vmmUpperGrazeWindow", 150, "Specifies how much above the upper time window boundary the VMM sim evaluates the signal."}
Gaudi::Property< double >	m_deadTime {this, "deadTime", 300. * Gaudi::Units::ns}
std::unique_ptr< MM_StripsResponseSimulation >	m_StripsResponseSimulation {}
std::unique_ptr< MM_ElectronicsResponseSimulation >	m_ElectronicsResponseSimulation {}
std::map< int, NoiseCalibConstants >	m_noiseParams {}
	Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta)
std::array< std::atomic< unsigned >, 8 > m_allHits	ATLAS_THREAD_SAFE {}
std::array< std::atomic< unsigned >, 8 > m_acceptedHits	ATLAS_THREAD_SAFE {}
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 {}

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 33 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.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::MM_DigitizationTool::DigiCache = OutDigitCache_t<MmDigitCollection>

private

Definition at line 126 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ NoiseCalibConstants

using MuonR4::MM_DigitizationTool::NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants

private

Definition at line 118 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.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.

Constructor & Destructor Documentation

◆ MM_DigitizationTool()

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

Definition at line 36 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

36 :

37 MuonDigitizationTool{type, name, pIID} {}

extractSporadic.name

name

Definition extractSporadic.py:101

python.CaloAddPedShiftConfig.type

type

Definition CaloAddPedShiftConfig.py:42

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;
    }

◆ combinedStripResponseAllHits()

MM_ElectronicsToolInput MM_DigitizationTool::combinedStripResponseAllHits	(	const EventContext &	ctx,
		const std::vector< MM_ElectronicsToolInput > &	v_stripDigitOutput ) const

private

Definition at line 427 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

                                                                                                                          {
        // set up pointer to conditions object
 
        const MmIdHelper &idHelper{m_idHelperSvc->mmIdHelper()};
 
        const NswCalibDbThresholdData *thresholdData{nullptr};
        if (!SG::get(thresholdData, m_condThrshldsKey, ctx).isSuccess()) {
            THROW_EXCEPTION("Cannot find conditions data container for VMM thresholds!");
        }
 
        std::vector<int> v_stripStripResponseAllHits{};
        std::vector<std::vector<float>> v_timeStripResponseAllHits{}, v_qStripResponseAllHits{};
        std::vector<float> v_stripThresholdResponseAllHits{};
 
        Identifier digitID = v_stripDigitOutput.at(0).digitID();
        double max_kineticEnergy = 0.0;
 
        // Loop over strip digit output elements
        for (const MM_ElectronicsToolInput &i_stripDigitOutput : v_stripDigitOutput) {
            //--- Just to get Digit id with the largest kinetic energy, but the Digit id is no longer meaningful
            if (i_stripDigitOutput.kineticEnergy() > max_kineticEnergy) {
                digitID = i_stripDigitOutput.digitID();
                max_kineticEnergy = i_stripDigitOutput.kineticEnergy();
            }
            //---
            for (size_t i = 0; i < i_stripDigitOutput.NumberOfStripsPos().size(); ++i) {
                int strip_id = i_stripDigitOutput.NumberOfStripsPos().at(i);
                bool found = false;
 
                for (size_t ii = 0; ii < v_stripStripResponseAllHits.size(); ++ii) {
                    if (v_stripStripResponseAllHits.at(ii) == strip_id) {
                        v_timeStripResponseAllHits.at(ii).insert(v_timeStripResponseAllHits.at(ii).end(),
                                                                 i_stripDigitOutput.chipTime().at(i).begin(), i_stripDigitOutput.chipTime().at(i).end());
 
                        v_qStripResponseAllHits.at(ii).insert(v_qStripResponseAllHits.at(ii).end(),
                                                              i_stripDigitOutput.chipCharge().at(i).begin(), i_stripDigitOutput.chipCharge().at(i).end());
                        found = true;
                    }
                }
 
                if (found) {
                    continue;
                }
                
                v_stripStripResponseAllHits.push_back(strip_id);
                v_timeStripResponseAllHits.push_back(i_stripDigitOutput.chipTime().at(i));
                v_qStripResponseAllHits.push_back(i_stripDigitOutput.chipCharge().at(i));
                if (m_useCondThresholds) {
                    const Identifier id = idHelper.channelID(digitID,
                                                                idHelper.multilayer(digitID),
                                                                idHelper.gasGap(digitID), strip_id);
                    float threshold = 0;
                    if (!thresholdData->getThreshold(id, threshold)) {
                        THROW_EXCEPTION("Cannot find retrieve VMM threshold from conditions data base!");
                    }
                    v_stripThresholdResponseAllHits.push_back(threshold);
                } else if (m_useThresholdScaling) {
                    Identifier id = idHelper.channelID(digitID,
                                                        idHelper.multilayer(digitID),
                                                        idHelper.gasGap(digitID), strip_id);
 
                    const MuonGMR4::MmReadoutElement *detectorReadoutElement = m_detMgr->getMmReadoutElement(id);
                    const MuonGMR4::StripDesign &design{detectorReadoutElement->stripLayer(id).design()};
                    double stripLength = design.stripLength(strip_id);
                    const int noise_id = m_idHelperSvc->stationName(digitID) * std::abs(m_idHelperSvc->stationEta(digitID));
                    const NoiseCalibConstants &noise = m_noiseParams.at(noise_id);
                    double threshold = (noise.slope * stripLength + noise.intercept) * m_thresholdScaleFactor;
                    v_stripThresholdResponseAllHits.push_back(threshold);
                } else {
                    v_stripThresholdResponseAllHits.push_back(m_electronicsThreshold);
                }
            }
        }
        return MM_ElectronicsToolInput(std::move(v_stripStripResponseAllHits), std::move(v_qStripResponseAllHits),
                                       std::move(v_timeStripResponseAllHits), std::move(v_stripThresholdResponseAllHits),
                                       digitID, max_kineticEnergy);
    }

◆ digitize()

StatusCode MM_DigitizationTool::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.

Reject hit within the dead time interval

Implements MuonR4::MuonDigitizationTool.

Definition at line 197 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

                                                                                          {
 
        const MmIdHelper &idHelper{m_idHelperSvc->mmIdHelper()};
        CLHEP::HepRandomEngine *rndEngine = getRandomEngine(ctx);
        const ActsTrk::GeometryContext &gctx{getGeoCtx(ctx)};
 
        // Prepare the temporary cache
        DigiCache digitCache{};
 
        // Fetch the conditions for efficiency calculations
        const Muon::DigitEffiData *efficiencyMap{nullptr};
        ATH_CHECK(SG::get(efficiencyMap , m_effiDataKey, ctx));
 
        const NswErrorCalibData *errorCalibDB{nullptr};
        ATH_CHECK(SG::get(errorCalibDB, m_uncertCalibKey, ctx));
 
        MagField::AtlasFieldCache fieldCache;
        const AtlasFieldCacheCondObj *fieldCondObj{nullptr};
        ATH_CHECK(SG::get(fieldCondObj, m_fieldCondObjInputKey, ctx));
        fieldCondObj->getInitializedCache(fieldCache);
 
        xAOD::ChamberViewer viewer{hitsToDigit, m_idHelperSvc.get()};
        do {
 
            std::array<std::vector<MM_ElectronicsToolInput>, 8> v_stripDigitOutput{};
            DeadTimeMap deadTimes{};
 
            for (const TimedHit &simHit : viewer) {
                // ignore radiation if you want
              if (m_digitizeMuonOnly && !MC::isMuon(simHit)) {
                    ATH_MSG_VERBOSE("Hit is not from a muon - skipping ");
                    continue;
                }
 
                const Identifier hitId{simHit->identify()};
 
                const double hitKineticEnergy = simHit->kineticEnergy();
                // Don't consider electron hits below m_energyThreshold.
                // Electrons aren't consider for now in any case due to the cut above.
                // But this may change.
                if (hitKineticEnergy < m_energyThreshold && MC::isElectron(simHit)) {
                    continue;
                }
                const MuonGMR4::MmReadoutElement *readOutEle = m_detMgr->getMmReadoutElement(hitId);
                const MuonGMR4::StripDesign &design{readOutEle->stripLayer(hitId).design()};
 
                const Amg::Vector3D locPos{xAOD::toEigen(simHit->localPosition())};
                const Amg::Vector3D locDir{xAOD::toEigen(simHit->localDirection())};
 
                const Amg::Transform3D &locToGlobal{readOutEle->localToGlobalTrans(gctx, readOutEle->layerHash(hitId))};
                const Amg::Vector3D globalHitPosition{locToGlobal * locPos};
 
                // We could use the MuonDigitizationTool::hitTime which returns the global time
                // of the hit which is the sum of eventTime & individual hit time,
                // but we want to have access on both contributions.
                const double globalHitTime = simHit->globalTime();
                const double tofCorrection = globalHitPosition.mag() / CLHEP::c_light;
                const double eventTime = simHit.eventTime();
                const double bunchTime = globalHitTime - tofCorrection + eventTime;
 
                const HepMcParticleLink particleLink = simHit->genParticleLink();
                // Print some information about the MicroMegas hit
                ATH_MSG_VERBOSE("hitID  " << m_idHelperSvc->toString(hitId) <<" ("<< simHit.get()<< ") Hit bunch time  " << bunchTime << " tof/G4 hit time " << globalHitTime
                            << " globalHitPosition " << Amg::toString(globalHitPosition) << " hit: r " << globalHitPosition.perp() << " z " << globalHitPosition.z()
                            << " mclink " << particleLink << "Kinetic energy " << hitKineticEnergy);
 
                // Angles, Geometry, and Coordinates.
                // This is not an incident angle yet. It's atan(z/x),
                // ... so it's the complement of the angle w.r.t. a vector normal to the detector surface
                double inAngleCompliment_XZ = std::atan2(locDir.z(), locDir.x()) / CLHEP::degree;
                double inAngleCompliment_YZ = std::atan2(locDir.z(), locDir.y()) / CLHEP::degree;
 
                // This is basically to handle the atan ambiguity
                if (inAngleCompliment_XZ < 0.0)
                    inAngleCompliment_XZ += 180;
                if (inAngleCompliment_YZ < 0.0)
                    inAngleCompliment_YZ += 180;
 
                // This gets the actual incidence angle from its complement.
                double inAngle_XZ = 90. - inAngleCompliment_XZ;
                double inAngle_YZ = 90. - inAngleCompliment_YZ;
 
                const IdentifierHash measHash{readOutEle->measurementHash(hitId)};
                int readoutSide = readOutEle->readoutSide(measHash);
                if (readoutSide == 1) {
                    inAngle_XZ = (-inAngle_XZ);
                }
 
                // Move the hit position to the readout plane
                int gasGap = idHelper.gasGap(hitId);
                // TO DO: THERE IS NO DESING THICKNESS, BUT HOW TO GET DIFFERENT THICKNESSES LIKE BEFORE?
                // double shift = 0.5 * design.thickness();
                double shift = 0.5 * m_driftGapWidth;
                std::optional<double> lambda{std::nullopt};
                if (gasGap == 1 || gasGap == 3) {
                    lambda = Amg::intersect<3>(locPos, locDir, Amg::Vector3D::UnitZ(), -shift);
                } else if (gasGap == 2 || gasGap == 4) {
                    lambda = Amg::intersect<3>(locPos, locDir, Amg::Vector3D::UnitZ(), shift);
                }
 
                const Amg::Vector3D hitOnSurface = locPos + lambda.value_or(0.) * locDir;
                const Amg::Vector2D positionOnSurface{hitOnSurface.x(), hitOnSurface.y()};
 
                // Account For Time Offset
                const double shiftTimeOffset = (globalHitTime - tofCorrection) * m_StripsResponseSimulation->getDriftVelocity();
                const Amg::Vector3D hitAfterTimeShift(hitOnSurface.x(), hitOnSurface.y(), shiftTimeOffset);
                lambda = Amg::intersect<3>(hitAfterTimeShift, locDir, Amg::Vector3D::UnitZ(), -shiftTimeOffset);
                const Amg::Vector3D hitAfterTimeShiftOnSurface = hitAfterTimeShift + lambda.value_or(0.) * locDir;
 
                if (std::abs(hitAfterTimeShiftOnSurface.z()) > 0.1) {
                    ATH_MSG_WARNING("Bad propagation to surface after time shift " << Amg::toString(hitAfterTimeShiftOnSurface));
                }
 
                // Calculate the index for the global hit counter
                const unsigned int hitGapInNsw = (idHelper.multilayer(hitId) - 1) * 4 + idHelper.gasGap(hitId) - 1;
                ++m_allHits[hitGapInNsw];
 
                bool isValid{false};
 
                int channelNumber = design.stripNumber(positionOnSurface);
                // Checks if the hit is outside of the panel
                if (channelNumber < 0) {
                    // Checks if the point is inside the trapezoid where the strips are mounted.
                    if (!design.insideTrapezoid(positionOnSurface)) {
                        ATH_MSG_WARNING("Hit " << m_idHelperSvc->toString(hitId) << " " << Amg::toString(positionOnSurface)
                                               << " is outside bounds " << std::endl
                                               << design << " rejecting it");
                    }
                    continue;
                }
                const Identifier clusId = idHelper.channelID(hitId, idHelper.multilayer(hitId),
                                                             idHelper.gasGap(hitId), channelNumber, isValid);
 
                if (!isValid) {
                    ATH_MSG_WARNING("Invalid strip identifier for layer " << m_idHelperSvc->toStringGasGap(hitId)<< " channel " << channelNumber 
                                    << " positionOnSurface " << Amg::toString(positionOnSurface));
                    continue;
                }
 
                if (efficiencyMap && efficiencyMap->getEfficiency(clusId) < CLHEP::RandFlat::shoot(rndEngine, 0., 1.)) {
                    ATH_MSG_VERBOSE("Simulated hit " <<Amg::toString(locPos) << " hitting strip " << m_idHelperSvc->toString(clusId) 
                                    << " is rejected because of effiency modelling");
                    continue;
                }
                if (!passDeadTime(clusId, hitTime(simHit), m_deadTime, deadTimes)) {
                    continue;
                }
 
                double distToStrip = design.distanceToStrip(positionOnSurface, channelNumber);
 
                // Obtain Magnetic Field At Detector Surface
                Amg::Vector3D hitOnSurfaceGlobal{locToGlobal * hitOnSurface};
                Amg::Vector3D magneticField{Amg::Vector3D::Zero()};
                fieldCache.getField(hitOnSurfaceGlobal.data(), magneticField.data());
 
                // B-field in local cordinate, X ~ #strip, increasing to outer R, Z ~ global Z but positive to IP
                Amg::Vector3D localMagneticField{locToGlobal.linear().inverse() * magneticField};
                if (readoutSide == -1) {
                    localMagneticField[Amg::y] = -localMagneticField[Amg::y];
                }
 
                // Strip Response Simulation For This Hit
                const MM_DigitToolInput stripDigitInput(channelNumber, distToStrip, inAngle_XZ, inAngle_YZ, localMagneticField,
                                                        design.firstStripNumber(),
                                                        design.numStrips() + design.firstStripNumber() - 1,
                                                        idHelper.gasGap(hitId), eventTime + globalHitTime);
                constexpr double gainFraction = 1.0;
 
                MM_StripToolOutput tmpStripOutput = m_StripsResponseSimulation->GetResponseFrom(stripDigitInput, gainFraction, design.stripPitch(), rndEngine);
 
                MM_ElectronicsToolInput stripDigitOutput(tmpStripOutput.NumberOfStripsPos(), tmpStripOutput.chipCharge(),
                                                         tmpStripOutput.chipTime(), clusId, hitKineticEnergy);
 
                ATH_MSG_VERBOSE(__func__ << "() : " << __LINE__ << " Prepared strip for digitization: " << m_idHelperSvc->toString(clusId));
                v_stripDigitOutput[hitGapInNsw].push_back(std::move(stripDigitOutput));
 
                addSDO(simHit, sdoContainer)->setIdentifier(clusId);
                ++m_acceptedHits[hitGapInNsw];
            } // end of loop over hits
 
            // Now at Detector Element Level (VMM)
            for (std::vector<MM_ElectronicsToolInput> &elecHitsPerLayer : v_stripDigitOutput) {
                if (elecHitsPerLayer.empty()) {
                    continue;
                }
                // VMM Simulation
                // Combine all strips (for this VMM) into a single VMM-level object
                MM_ElectronicsToolInput stripDigitOutputAllHits = combinedStripResponseAllHits(ctx, std::move(elecHitsPerLayer));
 
                // Create Electronics Output with peak or threshold finding setting
                MM_DigitToolOutput electronicsOutputForReadout{m_vmmReadoutMode == "peak" ? 
                        m_ElectronicsResponseSimulation->getPeakResponseFrom(std::move(stripDigitOutputAllHits)) : 
                        m_ElectronicsResponseSimulation->getThresholdResponseFrom(std::move(stripDigitOutputAllHits))};
                if (!electronicsOutputForReadout.isValid()) {
                    ATH_MSG_DEBUG(__func__ << "() : " << __LINE__
                            << " there is no electronics response (peak or threshold finding mode) even though there is a strip response.");
                }
 
                for (unsigned int firedCh = 0; firedCh < electronicsOutputForReadout.stripPos().size(); ++firedCh) {
 
                    const int channel = electronicsOutputForReadout.stripPos()[firedCh];
                    double time = electronicsOutputForReadout.stripTime()[firedCh];
                    double charge = electronicsOutputForReadout.stripCharge()[firedCh];
                    bool isValid{false};
                    const Identifier digitID = idHelper.channelID(stripDigitOutputAllHits.digitID(),
                                                                  idHelper.multilayer(stripDigitOutputAllHits.digitID()),
                                                                  idHelper.gasGap(stripDigitOutputAllHits.digitID()),
                                                                  channel, isValid);
 
                    if (!isValid) {
                        ATH_MSG_DEBUG("Ghost strip fired... Ghost busters... ");
                        continue;
                    }
                    ATH_MSG_VERBOSE(__func__ << "() " << __LINE__ <<": Final digitized strip: " << m_idHelperSvc->toString(digitID)
                                    <<", time: "<<time<<", charge: "<<charge);
                    MmDigitCollection *outColl = fetchCollection(digitID, digitCache);
                    outColl->push_back(std::make_unique<MmDigit>(digitID, time, charge));
                }
            }
        } while (viewer.next());
        // Write everything at the end into the final digit container
        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

◆ finalize()

StatusCode MM_DigitizationTool::finalize ( )

finaloverride

Definition at line 180 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

                                             {
 
        std::stringstream statstr{};
        unsigned allHits{0};
        for (unsigned int g = 0; g < m_allHits.size(); ++g) {
            allHits += m_allHits[g];
            statstr << " *** Layer " << (g + 1) << " " << percentage(m_acceptedHits[g], m_allHits[g])
                    << "% of " << m_allHits[g] << std::endl;
        }
        if (!allHits) {
            return StatusCode::SUCCESS;
        }
        ATH_MSG_INFO("Tried to convert " << allHits << " hits. Successes rate per layer  " << std::endl
                                         << statstr.str());
        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 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 MM_DigitizationTool::initialize ( )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 39 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

                                               {
        ATH_MSG_DEBUG("MM_DigitizationTool:: in initialize()");
 
        ATH_CHECK(MuonDigitizationTool::initialize());
 
        ATH_CHECK(m_writeKey.initialize());
        ATH_CHECK(m_uncertCalibKey.initialize());
        ATH_CHECK(m_condThrshldsKey.initialize(m_useCondThresholds));
        ATH_CHECK(m_fieldCondObjInputKey.initialize());
        ATH_CHECK(m_effiDataKey.initialize(!m_effiDataKey.empty()));
        ATH_CHECK(m_calibrationTool.retrieve());
        ATH_CHECK(m_smearingTool.retrieve());
 
        // get gas properties from calibration tool
        const NSWCalib::MicroMegaGas prop = m_calibrationTool->mmGasProperties();
        const double peakTime = m_calibrationTool->mmPeakTime();
 
        MM_StripsResponseSimulation::ConfigModule strip_cfg{};
        strip_cfg.NSWCalib::MicroMegaGas::operator=(prop);
        strip_cfg.writeOutputFile = m_writeOutputFile;
        strip_cfg.qThreshold = m_qThreshold;
        strip_cfg.driftGapWidth = m_driftGapWidth;
        strip_cfg.crossTalk1 = m_crossTalk1;
        strip_cfg.crossTalk2 = m_crossTalk2;
        strip_cfg.avalancheGain = m_avalancheGain;
        m_StripsResponseSimulation = std::make_unique<MM_StripsResponseSimulation>(std::move(strip_cfg));
 
        m_timeWindowLowerOffset += peakTime; // account for peak time in time window
        m_timeWindowUpperOffset += peakTime; // account for peak time in time window
 
        MM_ElectronicsResponseSimulation::ConfigModule elec_sim_cfg{};
        elec_sim_cfg.peakTime = peakTime;
        elec_sim_cfg.timeWindowLowerOffset = m_timeWindowLowerOffset;
        elec_sim_cfg.timeWindowUpperOffset = m_timeWindowUpperOffset;
        elec_sim_cfg.vmmDeadtime = m_vmmDeadtime;
        elec_sim_cfg.vmmUpperGrazeWindow = m_vmmUpperGrazeWindow;
        elec_sim_cfg.stripDeadTime = m_stripdeadtime;
        elec_sim_cfg.artDeadTime = m_ARTdeadtime;
        elec_sim_cfg.useNeighborLogic = m_vmmNeighborLogic;
        // ElectronicsResponseSimulation Creation
        m_ElectronicsResponseSimulation = std::make_unique<MM_ElectronicsResponseSimulation>(std::move(elec_sim_cfg));
 
        // Configuring various VMM modes of signal readout
        //
        std::string vmmReadoutMode = m_vmmReadoutMode;
        // convert vmmReadoutMode to lower case
        std::for_each(vmmReadoutMode.begin(), vmmReadoutMode.end(), [](char &c){ c = ::tolower(c); });
        if (vmmReadoutMode.find("peak") != std::string::npos) {
            m_vmmReadoutMode = "peak";
        } else if (vmmReadoutMode.find("threshold") != std::string::npos){
            m_vmmReadoutMode = "threshold";
        } else {
            ATH_MSG_ERROR("MM_DigitizationTool can't interperet vmmReadoutMode option! (Should be 'peak' or 'threshold'.) Contains: "
                          << m_vmmReadoutMode);
            return StatusCode::FAILURE;
        }
        std::string vmmARTMode = m_vmmARTMode;
        // convert vmmARTMode to lower case
        std::for_each(vmmARTMode.begin(), vmmARTMode.end(), [](char &c){ c = ::tolower(c); });
        if (vmmARTMode.find("peak") != std::string::npos) {
            m_vmmARTMode = "peak";
        }
        else if (vmmARTMode.find("threshold") != std::string::npos) {
            m_vmmARTMode = "threshold";
        }
        else {
            ATH_MSG_ERROR("MM_DigitizationTool can't interperet vmmARTMode option! (Should be 'peak' or 'threshold'.) Contains: " << m_vmmARTMode);
            return StatusCode::FAILURE;
        }
 
        if (m_doSmearing) {
            ATH_MSG_INFO("Running in smeared mode!");
        }
 
        // get shortest and longest strip length for threshold scaling
        Identifier tmpId{0}; // temporary identifier to work with ReadoutElement
        int stripNumberShortestStrip{-1}, stripNumberLongestStrip{-1};
        Identifier tmpIdShortestStrip{0}, tmpIdLongestStrip{0};
        double shortestStripLength{FLT_MAX}, longestStripLength{0};
        IdentifierHash tmpIdHashShortestStrip{0}, tmpIdHashLongestStrip{0};
        NoiseCalibConstants noise_smallEta1{}, noise_smallEta2{}, noise_largeEta1{}, noise_largeEta2{};
        //
        for (std::string sectorType : {"MML", "MMS"}) {
            for (int etaStation : {1, 2}) {
                // identifier for first gas gap in a MM sector, layer is eta layer
                tmpId = m_idHelperSvc->mmIdHelper().channelID(sectorType, etaStation, 1, 1, 1, 1);
                const MuonGMR4::MmReadoutElement *detectorReadoutElement = m_detMgr->getMmReadoutElement(tmpId);
                const MuonGMR4::StripDesign &design{detectorReadoutElement->stripLayer(tmpId).design()};
                stripNumberShortestStrip = design.firstStripNumber();
                tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID(sectorType, etaStation, 1, 1, 1, stripNumberShortestStrip); // identifier for the shortest strip
                tmpIdHashShortestStrip = detectorReadoutElement->measurementHash(tmpIdShortestStrip);
                shortestStripLength = detectorReadoutElement->stripLength(tmpIdHashShortestStrip);
                stripNumberLongestStrip = design.numStrips() + stripNumberShortestStrip - 1;
                tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID(sectorType, etaStation, 1, 1, 1, stripNumberLongestStrip); // identifier for the longest strip
                tmpIdHashLongestStrip = detectorReadoutElement->measurementHash(tmpIdLongestStrip);
                longestStripLength = design.stripLength(tmpIdHashLongestStrip);
 
                // now get the slope and intercept for the threshold scaling
                // function is m_noiseSlope * stripLength + m_noiseIntercept
                if (sectorType == "MMS") {
                    if (etaStation == 1) {
                        noise_smallEta1 = m_noiseParams[m_idHelperSvc->stationName(tmpId)];
                        noise_smallEta1.slope = (maxNoiseSmall_eta1 - minNoiseSmall_eta1) / (longestStripLength - shortestStripLength);
                        noise_smallEta1.intercept = minNoiseSmall_eta1 - noise_smallEta1.slope * shortestStripLength;
                    }
                    else if (etaStation == 2) {
                        noise_smallEta2 = m_noiseParams[m_idHelperSvc->stationName(tmpId) * 2];
                        noise_smallEta2.slope = (maxNoiseSmall_eta2 - minNoiseSmall_eta2) / (longestStripLength - shortestStripLength);
                        noise_smallEta2.intercept = minNoiseSmall_eta2 - noise_smallEta2.slope * shortestStripLength;
                    }
                } else if (sectorType == "MML") {
                    if (etaStation == 1) {
                        noise_largeEta1 = m_noiseParams[m_idHelperSvc->stationName(tmpId)];
                        noise_largeEta1.slope = (maxNoiseLarge_eta1 - minNoiseLarge_eta1) / (longestStripLength - shortestStripLength);
                        noise_largeEta1.intercept = minNoiseLarge_eta1 - noise_largeEta1.slope * shortestStripLength;
                    } else if (etaStation == 2) {
                        noise_largeEta2 = m_noiseParams[m_idHelperSvc->stationName(tmpId) * 2];
                        noise_largeEta2.slope = (maxNoiseLarge_eta2 - minNoiseLarge_eta2) / (longestStripLength - shortestStripLength);
                        noise_largeEta2.intercept = minNoiseLarge_eta2 - noise_largeEta2.slope * shortestStripLength;
                    }
                } // end of if over sector types
            } // end of loop over eta stations
        } // end of loop over sector types
 
        ATH_MSG_DEBUG("Configuration  MM_DigitizationTool ");
        ATH_MSG_DEBUG("OutputObjectName       " << m_writeKey.key());
        ATH_MSG_DEBUG("UseTimeWindow          " << m_useTimeWindow);
        ATH_MSG_DEBUG("CheckSimHits           " << m_checkMMSimHits);
        ATH_MSG_DEBUG("Threshold              " << m_qThreshold);
        ATH_MSG_DEBUG("TransverseDiffusSigma  " << m_StripsResponseSimulation->getTransversDiffusionSigma());
        ATH_MSG_DEBUG("LogitundinalDiffusSigma" << m_StripsResponseSimulation->getLongitudinalDiffusionSigma());
        ATH_MSG_DEBUG("Interaction density mean: " << m_StripsResponseSimulation->getInteractionDensityMean());
        ATH_MSG_DEBUG("Interaction density sigma: " << m_StripsResponseSimulation->getInteractionDensitySigma());
        ATH_MSG_DEBUG("DriftVelocity stripResponse: " << m_StripsResponseSimulation->getDriftVelocity());
        ATH_MSG_DEBUG("crossTalk1             " << m_crossTalk1);
        ATH_MSG_DEBUG("crossTalk2             " << m_crossTalk2);
        ATH_MSG_DEBUG("EnergyThreshold        " << m_energyThreshold);
 
        return StatusCode::SUCCESS;
    }

◆ 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;
    }

◆ 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

◆ ATLAS_THREAD_SAFE [1/2]

std::array<std::atomic<unsigned>, 8> m_allHits MuonR4::MM_DigitizationTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 123 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

123{};

◆ ATLAS_THREAD_SAFE [2/2]

std::array<std::atomic<unsigned>, 8> m_acceptedHits MuonR4::MM_DigitizationTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 124 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

124{};

◆ m_ARTdeadtime

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_ARTdeadtime {this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"}

private

Definition at line 98 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

98{this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"};

◆ m_avalancheGain

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_avalancheGain {this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"}

private

Definition at line 92 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

92{this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"};

◆ m_calibrationTool

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

private

Definition at line 59 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

59{this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"};

◆ m_checkMMSimHits

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_checkMMSimHits {this, "CheckSimHits", true, "Control on the hit validity"}

private

Definition at line 76 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

76{this, "CheckSimHits", true, "Control on the hit validity"};

◆ m_condThrshldsKey

SG::ReadCondHandleKey<NswCalibDbThresholdData> MuonR4::MM_DigitizationTool::m_condThrshldsKey

private

Initial value:

{ this, "CondThrshldsKey", "NswCalibDbThresholdData",

"Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"}

Definition at line 54 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

54 { this, "CondThrshldsKey", "NswCalibDbThresholdData",

55 "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"};

◆ m_crossTalk1

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_crossTalk1 {this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"}

private

Definition at line 89 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

89{this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"};

◆ m_crossTalk2

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_crossTalk2 {this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"}

private

Definition at line 90 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

90{this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"};

◆ m_deadTime

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_deadTime {this, "deadTime", 300. * Gaudi::Units::ns}

private

Definition at line 113 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

113{this, "deadTime", 300. * Gaudi::Units::ns};

◆ m_detMgr

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

protectedinherited

Definition at line 111 of file MuonDigitizationTool.h.

111{nullptr};

◆ m_DiffMagSecondMuonHit

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_DiffMagSecondMuonHit {this, "DiffMagSecondMuonHit", 0.1}

private

Definition at line 70 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

70{this, "DiffMagSecondMuonHit", 0.1};

◆ m_digitizeMuonOnly

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_digitizeMuonOnly {this, "ProcessTrueMuonsOnly", true, "If set to true hit with pdgId != 13 are skipped"}

private

Definition at line 61 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

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

◆ m_doSmearing

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_doSmearing

private

Initial value:

{this, "doSmearing", true,

"set the usage or not of the smearing tool for realistic detector performance"}

Definition at line 79 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

79 {this, "doSmearing", true,

80 "set the usage or not of the smearing tool for realistic detector performance"};

◆ m_driftGapWidth

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_driftGapWidth {this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"}

private

Definition at line 88 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

88{this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"};

◆ m_effiDataKey

SG::ReadCondHandleKey<Muon::DigitEffiData> MuonR4::MM_DigitizationTool::m_effiDataKey {this, "EffiDataKey", "MmDigitEff", "Efficiency constants of the individual MM gasGaps"}

private

Definition at line 51 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

51{this, "EffiDataKey", "MmDigitEff", "Efficiency constants of the individual MM gasGaps"};

◆ m_ElectronicsResponseSimulation

std::unique_ptr<MM_ElectronicsResponseSimulation> MuonR4::MM_DigitizationTool::m_ElectronicsResponseSimulation {}

private

Definition at line 116 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

116{};

◆ m_electronicsThreshold

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_electronicsThreshold

private

Initial value:

{this, "electronicsThreshold", 15000,

"threshold Voltage for histoBNL, 2*(Intrinsic noise ~3k e)"}

Definition at line 95 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

95 {this, "electronicsThreshold", 15000,

96 "threshold Voltage for histoBNL, 2*(Intrinsic noise ~3k e)"};

◆ m_energyThreshold

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to process an electron sim hit"}

private

Definition at line 65 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

65{this, "EnergyThreshold", 50, "Minimal energy to process an electron sim hit"};

◆ m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> MuonR4::MM_DigitizationTool::m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}

private

Definition at line 57 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

57{this, "AtlasFieldCacheCondObj", "fieldCondObj"};

◆ 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_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_maskMultiplet

Gaudi::Property<int> MuonR4::MM_DigitizationTool::m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}

private

Definition at line 72 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

72{this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"};

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

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_needsMcEventCollHelper {this, "UseMcEventCollectionHelper", false}

private

Definition at line 75 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

75{this, "UseMcEventCollectionHelper", false};

◆ m_noiseParams

std::map<int, NoiseCalibConstants> MuonR4::MM_DigitizationTool::m_noiseParams {}

private

Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta)

Definition at line 121 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

121{};

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

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_qThreshold {this, "qThreshold", 0.001, "Charge Threshold"}

private

Definition at line 87 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

87{this, "qThreshold", 0.001, "Charge Threshold"};

◆ 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_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::MM_DigitizationTool::m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}

private

Definition at line 58 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

58{this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"};

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

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_stripdeadtime {this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"}

private

Definition at line 97 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

97{this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"};

◆ m_StripsResponseSimulation

std::unique_ptr<MM_StripsResponseSimulation> MuonR4::MM_DigitizationTool::m_StripsResponseSimulation {}

private

Definition at line 115 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

115{};

◆ m_thresholdScaleFactor

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_thresholdScaleFactor

private

Initial value:

{this, "thresholdScaleFactor", 7.0,

"Use x times the strip length dependent noise as MM threshold"}

Definition at line 105 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

105 {this, "thresholdScaleFactor", 7.0,

106 "Use x times the strip length dependent noise as MM threshold"};

◆ m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}

privateinherited

Definition at line 141 of file MuonDigitizationTool.h.

141{};

◆ m_timeWindowLowerOffset

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_timeWindowLowerOffset

private

Initial value:

{this, "WindowLowerOffset", -12.5,

"lower boundary of the time window in which digits are accepted"}

Definition at line 66 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

66 {this, "WindowLowerOffset", -12.5,

67 "lower boundary of the time window in which digits are accepted"};

◆ m_timeWindowUpperOffset

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_timeWindowUpperOffset

private

Initial value:

{this, "WindowUpperOffset", 187.5,

"upper boundary of the time window in which digits are accepted"}

Definition at line 68 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

68 {this, "WindowUpperOffset", 187.5,

69 "upper boundary of the time window in which digits are accepted"};

◆ m_uncertCalibKey

SG::ReadCondHandleKey<NswErrorCalibData> MuonR4::MM_DigitizationTool::m_uncertCalibKey {this, "ErrorCalibKey", "NswUncertData", "Key of the parametrized NSW uncertainties"}

private

Definition at line 52 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

52{this, "ErrorCalibKey", "NswUncertData", "Key of the parametrized NSW uncertainties"};

◆ m_useCondThresholds

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

private

Initial value:

{this, "useCondThresholds", false,

"Use conditions data to get thresholds, overrules useThresholdScaling"}

Definition at line 101 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

101 {this, "useCondThresholds", false,

102 "Use conditions data to get thresholds, overrules useThresholdScaling"};

◆ m_useThresholdScaling

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_useThresholdScaling

private

Initial value:

{this, "useThresholdScaling", true,

"Use a strip length dependent threshold in MM digitiation"}

Definition at line 103 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

103 {this, "useThresholdScaling", true,

104 "Use a strip length dependent threshold in MM digitiation"};

◆ m_useTimeWindow

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

private

Definition at line 77 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

77{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_vmmARTMode

Gaudi::Property<std::string> MuonR4::MM_DigitizationTool::m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}

private

Definition at line 63 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

63{this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"};

◆ m_vmmDeadtime

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_vmmDeadtime {this, "vmmDeadtime", 200, "Specifies how much before the lower time limit the VMM simulation should start evaluating the signal"}

private

Definition at line 107 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

107{this, "vmmDeadtime", 200, "Specifies how much before the lower time limit the VMM simulation should start evaluating the signal"};

◆ m_vmmNeighborLogic

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_vmmNeighborLogic {this, "VMMNeighborLogic", false}

private

Definition at line 78 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

78{this, "VMMNeighborLogic", false};

◆ m_vmmReadoutMode

Gaudi::Property<std::string> MuonR4::MM_DigitizationTool::m_vmmReadoutMode {this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"}

private

Definition at line 62 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

62{this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"};

◆ m_vmmUpperGrazeWindow

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_vmmUpperGrazeWindow {this, "vmmUpperGrazeWindow", 150, "Specifies how much above the upper time window boundary the VMM sim evaluates the signal."}

private

Definition at line 110 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

110{this, "vmmUpperGrazeWindow", 150, "Specifies how much above the upper time window boundary the VMM sim evaluates the signal."};

◆ m_writeKey

SG::WriteHandleKey<MmDigitContainer> MuonR4::MM_DigitizationTool::m_writeKey {this, "OutputObjectName", "MM_DIGITS"}

private

Definition at line 49 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

49{this, "OutputObjectName", "MM_DIGITS"};

◆ m_writeOutputFile

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_writeOutputFile {this, "SaveInternalHistos", false}

private

Definition at line 74 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

74{this, "SaveInternalHistos", false};

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

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

structors and AlgTool implementation

Detailed Description

Member Typedef Documentation

◆ DeadTimeMap

◆ DigiCache

◆ NoiseCalibConstants

◆ OutDigitCache_t

◆ PileUpHits

◆ SimHitLocalCopy

◆ TimedHit

◆ TimedHits

Constructor & Destructor Documentation

◆ MM_DigitizationTool()

Member Function Documentation

◆ addSDO()

◆ combinedStripResponseAllHits()

◆ digitize()

◆ fetchCollection()

◆ fillTimedHits()

◆ filterPassed()

◆ finalize()

◆ getGeoCtx()

◆ getRandomEngine()

◆ hitTime()

◆ initialize()

◆ mergeEvent()

◆ passDeadTime()

◆ PileUpToolBase()

◆ prepareEvent()

◆ processAllSubEvents() [1/2]

◆ processAllSubEvents() [2/2]

◆ processBunchXing()

◆ resetFilter()

◆ toProcess()

◆ writeDigitContainer()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

◆ ATLAS_THREAD_SAFE [2/2]

◆ m_ARTdeadtime

◆ m_avalancheGain

◆ m_calibrationTool

◆ m_checkMMSimHits

◆ m_condThrshldsKey

◆ m_crossTalk1

◆ m_crossTalk2

◆ m_deadTime

◆ m_detMgr

◆ m_DiffMagSecondMuonHit

◆ m_digitizeMuonOnly

◆ m_doSmearing

◆ m_driftGapWidth

◆ m_effiDataKey

◆ m_ElectronicsResponseSimulation

◆ m_electronicsThreshold

◆ m_energyThreshold

◆ m_fieldCondObjInputKey

◆ m_filterPassed

◆ m_firstXing

◆ m_geoCtxKey

◆ m_idHelperSvc

◆ m_includePileUpTruth

◆ m_inputObjectName

◆ m_lastXing

◆ m_maskMultiplet

◆ m_mergeSvc

◆ m_needsMcEventCollHelper

◆ m_noiseParams

◆ m_onlyUseContainerName

◆ m_qThreshold

◆ m_rndmSvc

◆ m_sdoKey

◆ m_simHitKey