#include <MM_DigitizationTool.h>

Inheritance diagram for MM_DigitizationTool:

Public Member Functions
	MM_DigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
	Initialize.
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	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	When being run from PileUpToolsAlgs, this method is called for each active bunch-crossing to process current SubEvents bunchXing is in ns.
StatusCode	mergeEvent (const EventContext &ctx) override final
	When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop.
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override
	When being run from MM_Digitizer, this method is called during the event loop.
StatusCode	digitize (const EventContext &ctx)
	Just calls processAllSubEvents - leaving for back-compatibility (IMuonDigitizationTool)

Private Types
using	NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants

Private Member Functions
CLHEP::HepRandomEngine *	getRandomEngine (const std::string &streamName, const EventContext &ctx) const
StatusCode	getNextEvent (const EventContext &ctx)
	Record MmDigitContainer and MuonSimDataCollection.
StatusCode	doDigitization (const EventContext &ctx)
bool	checkMMSimHit (const MMSimHit &) const
MM_ElectronicsToolInput	combinedStripResponseAllHits (const std::vector< MM_ElectronicsToolInput > &v_stripDigitOutput)

Private Attributes
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in Muon digitization"}
Gaudi::Property< std::string >	m_rndmEngineName {this, "RndmEngine", "MuonDigitization", "Random engine name"}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< Muon::INSWCalibSmearingTool >	m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}
ToolHandle< Muon::INSWCalibTool >	m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}
SG::ReadCondHandleKey< NswCalibDbThresholdData >	m_condThrshldsKey
Gaudi::Property< bool >	m_onlyUseContainerName
SG::ReadHandleKey< MMSimHitCollection >	m_hitsContainerKey {this, "InputObjectName", "MM_Hits", "name of the input objects"}
std::string	m_inputObjectName {""}
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 produce a PRD"}
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"}
SG::WriteHandleKey< MmDigitContainer >	m_outputDigitCollectionKey
SG::WriteHandleKey< MuonSimDataCollection >	m_outputSDO_CollectionKey
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}
Gaudi::Property< bool >	m_useCondThresholds
Gaudi::Property< bool >	m_useThresholdScaling
Gaudi::Property< float >	m_thresholdScaleFactor
Gaudi::Property< float >	m_vmmDeadtime
Gaudi::Property< float >	m_vmmUpperGrazeWindow
const MicromegasHitIdHelper *	m_muonHelper {nullptr}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
std::list< std::unique_ptr< MMSimHitCollection > >	m_MMHitCollList {}
std::unique_ptr< TimedHitCollection< MMSimHit > >	m_timedHitCollection_MM {}
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)

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

@section MM_DigitizerDetails Class methods and properties

Authors: Nektarios Chr. Benekos necta.nosp@m.rios.nosp@m..bene.nosp@m.kos@.nosp@m.cern..nosp@m.ch Konstantinos Karakostas Konst.nosp@m.anti.nosp@m.nos.K.nosp@m.arak.nosp@m.ostas.nosp@m.@cer.nosp@m.n.ch //////////////////////////////////////////////////////////////////////////////

    In the initialize() method, the PileUpMerge and StoreGate services are initialized, and a pointer to an instance of the class
    MuonDetectorManager is retrieved from the detector store and used to obtain a MmIdHelper.
    The MMDigitContainer is initialized and the simulation identifier helper retrieved, together with the pointer to the digitization

tool. Random numbers are obtained in the code from a dedicated stream via AtRndmSvc, which is also initialized in the initialize() method. In the execute() method, the digits and the SDOs (Simulation Data Object, container for simulation data to be preserved after the digitization procedue, and persistified together with the RDOs) containers are created and recorded on StoreGate; the MMSimHit collection are merged using the TimedHitCollection sorted container (done in handleMicroMegasSimhit(TimedHitPtr<MMSimHit>& hit)) method); into a loop over the TimedHitCollection for the given DetectorElement, the handleMicroMegasSimhit() method converts the SimID into the Offline ID to be associated to the Digit and pass to the digitization tool the drift radius and the distance to the chamber RO side (for the propagation delay computation). The digitization tool returns a drift time, charge and strip position which are used together with the Offline ID, to create the digit object (in doDigitization() method). The finalize() method returns a SUCCESS StatusCode if the digitization procedure ends succesfully.

 In the initialize() method...
 In the execute() method...

Definition at line 76 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

Member Typedef Documentation

◆ NoiseCalibConstants

using MM_DigitizationTool::NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants

private

Definition at line 198 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

Constructor & Destructor Documentation

◆ MM_DigitizationTool()

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

Definition at line 65 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

65 :

66 PileUpToolBase(type, name, parent) {}

PileUpToolBase::PileUpToolBase

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

Definition PileUpToolBase.cxx:7

Member Function Documentation

◆ checkMMSimHit()

bool MM_DigitizationTool::checkMMSimHit ( const MMSimHit & ) const

private

Definition at line 895 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

895{ return true; }

◆ combinedStripResponseAllHits()

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

private

Definition at line 818 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                                                                                      {
    // set up pointer to conditions object
    const EventContext& ctx = Gaudi::Hive::currentContext();
    
    const NswCalibDbThresholdData* thresholdData {nullptr};
    if(m_useCondThresholds){
        SG::ReadCondHandle<NswCalibDbThresholdData> readThresholds{m_condThrshldsKey, ctx};
        if (!readThresholds.isValid()) { ATH_MSG_ERROR("Cannot find conditions data container for VMM thresholds!"); }
        thresholdData = readThresholds.cptr();
    }
 
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muonGeoMgrHandle{m_DetectorManagerKey, ctx};
    if (!muonGeoMgrHandle.isValid()) { ATH_MSG_FATAL("Failed to retrieve the detector manager from the conditiosn store"); }
    const MuonGM::MuonDetectorManager* muonGeoMgr = *muonGeoMgrHandle;
 
    std::vector<int> v_stripStripResponseAllHits;
    std::vector<std::vector<float>> v_timeStripResponseAllHits;
    std::vector<std::vector<float>> v_qStripResponseAllHits;
    std::vector<float> v_stripThresholdResponseAllHits;
 
    Identifier digitID = v_stripDigitOutput.at(0).digitID();
    float max_kineticEnergy = 0.0;
 
    // Loop over strip digit output elements
    for (auto& 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) {
                    for (size_t iii = 0; iii < i_stripDigitOutput.chipTime().at(i).size(); ++iii) {
                        v_timeStripResponseAllHits.at(ii).push_back(i_stripDigitOutput.chipTime().at(i).at(iii));
                        v_qStripResponseAllHits.at(ii).push_back(i_stripDigitOutput.chipCharge().at(i).at(iii));
                    }
                    found = true;
                }
            }
            if (!found) {  // strip id not in vector, add new entry
                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 = m_idHelperSvc->mmIdHelper().channelID(digitID, m_idHelperSvc->mmIdHelper().multilayer(digitID),
                                                                                m_idHelperSvc->mmIdHelper().gasGap(digitID), strip_id);
                    float threshold = 0;
                    if (!thresholdData->getThreshold(id, threshold))
                        ATH_MSG_ERROR("Cannot find retrieve VMM threshold from conditions data base!");
                    v_stripThresholdResponseAllHits.push_back(threshold);
                } else if (m_useThresholdScaling) {
                    Identifier id = m_idHelperSvc->mmIdHelper().channelID(digitID, m_idHelperSvc->mmIdHelper().multilayer(digitID),
                                                                          m_idHelperSvc->mmIdHelper().gasGap(digitID), strip_id);
                    const MuonGM::MMReadoutElement* detectorReadoutElement = muonGeoMgr->getMMReadoutElement(id);
                    float stripLength = detectorReadoutElement->stripLength(id);
                    const int noise_id = m_idHelperSvc->stationName(digitID) * std::abs(m_idHelperSvc->stationEta(digitID));
                    const NoiseCalibConstants& noise = m_noiseParams.at(noise_id);
                    float threshold = (noise.slope * stripLength + noise.intercept) * m_thresholdScaleFactor;
                    v_stripThresholdResponseAllHits.push_back(threshold);
                } else {
                    v_stripThresholdResponseAllHits.push_back(m_electronicsThreshold);
                }
            }
        }
    }
 
    MM_ElectronicsToolInput stripDigitOutputAllHits(v_stripStripResponseAllHits, v_qStripResponseAllHits, v_timeStripResponseAllHits,
                                                    v_stripThresholdResponseAllHits, digitID, max_kineticEnergy);
 
    return stripDigitOutputAllHits;
}

◆ digitize()

StatusCode MM_DigitizationTool::digitize ( const EventContext & ctx )

Just calls processAllSubEvents - leaving for back-compatibility (IMuonDigitizationTool)

Definition at line 396 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

396{ return this->processAllSubEvents(ctx); }

MM_DigitizationTool::processAllSubEvents

virtual StatusCode processAllSubEvents(const EventContext &ctx) override

When being run from MM_Digitizer, this method is called during the event loop.

Definition MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx:398

◆ doDigitization()

StatusCode MM_DigitizationTool::doDigitization ( const EventContext & ctx )

private

check if the hit has to be dropped, based on efficiency

move the initial track point to the readout plane

use the smearing tool to update time and charge

Definition at line 413 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                      {
    CLHEP::HepRandomEngine* rndmEngine = getRandomEngine(m_rndmEngineName, ctx);
 
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muonGeoMgrHandle{m_DetectorManagerKey, ctx};
    if (!muonGeoMgrHandle.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve the detector manager from the conditiosn store");
        return StatusCode::FAILURE;
    }
    const MuonGM::MuonDetectorManager* muonGeoMgr = *muonGeoMgrHandle;
 
    // create and record the Digit container in StoreGate
    SG::WriteHandle<MmDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
    ATH_CHECK(digitContainer.record(std::make_unique<MmDigitContainer>(m_idHelperSvc->mmIdHelper().detectorElement_hash_max())));
    ATH_MSG_DEBUG("MmDigitContainer recorded in StoreGate.");
 
    // Create and record the SDO container in StoreGate
    SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDO_CollectionKey, ctx);
    ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
    ATH_MSG_DEBUG("MmSDOCollection recorded in StoreGate.");
 
 
    if (m_maskMultiplet == 3) { return StatusCode::SUCCESS; }
 
    // Perform null check on m_thpcCSC
    if (!m_timedHitCollection_MM) {
        ATH_MSG_ERROR("m_timedHitCollection_MM is null");
        return StatusCode::FAILURE;
    }
 
 
    // iterate over hits and fill id-keyed drift time map
    TimedHitCollection<MMSimHit>::const_iterator i, e;
 
    std::vector<std::unique_ptr<MmDigitCollection> > collections;
 
    // nextDetectorElement-->sets an iterator range with the hits of current detector element , returns a bool when done
    const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
    while (m_timedHitCollection_MM->nextDetectorElement(i, e)) {
        Identifier layerID;
        std::vector<MM_ElectronicsToolInput> v_stripDigitOutput;  
 
        // Loop over the hits:
        while (i != e) {
            //
            // Hit Information And Preparation
            //           
            TimedHitPtr<MMSimHit> phit = *i++;
            const double eventTime = phit.eventTime();
            const MMSimHit& hit(*phit);
 
            const double hitKineticEnergy = hit.kineticEnergy();
            if (hitKineticEnergy <= 0) continue;
 
            const Amg::Vector3D& globalHitPosition = hit.globalPosition();
 
            const double globalHitTime = hit.globalTime();
            const double tofCorrection = globalHitPosition.mag() / CLHEP::c_light;
            const double bunchTime = globalHitTime - tofCorrection + eventTime;
 
            const int hitID = hit.MMId();
            // the G4 time or TOF from IP
            // double G4Time(hit.globalTime());
            // see what are the members of MMSimHit
 
            // convert sim id helper to offline id
            MM_SimIdToOfflineId simToOffline(&idHelper);
 
            // get the hit Identifier and info
            int simId = hit.MMId();
            layerID = simToOffline.convert(simId);
            if (m_doSmearing) {
                bool acceptHit = true;
                ATH_CHECK(m_smearingTool->isAccepted(layerID, acceptHit,rndmEngine));
                if (!acceptHit) {
                    ATH_MSG_DEBUG("Dropping the hit - smearing tool");
                    continue;
                }
            }
            const HepMcParticleLink particleLink = HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
            // Read the information about the Micro Megas hit
            ATH_MSG_DEBUG("> hitID  " << hitID << " Hit bunch time  " << bunchTime << " tot " << globalHitTime << " tof/G4 time "
                                      << hit.globalTime() << " globalHitPosition " << globalHitPosition << "hit: r "
                                      << globalHitPosition.perp() << " z " << globalHitPosition.z() << " mclink " << particleLink
                                      << m_idHelperSvc->toStringGasGap(layerID));
 
            // For collection of inputs to throw back in SG
 
            // remove hits in masked multiplet
            if (m_maskMultiplet == idHelper.multilayer(layerID)) continue;
 
            //
            // Hit Information And Preparation
            //
            //
            // Sanity Checks
            //
            if (!m_idHelperSvc->isMM(layerID)) {
                ATH_MSG_WARNING("layerID does not represent a valid MM layer: "<< m_idHelperSvc->toString(layerID));
                continue;
            }
 
            // get readout element
            const MuonGM::MMReadoutElement* detectorReadoutElement = muonGeoMgr->getMMReadoutElement(layerID);
            if (!detectorReadoutElement) {
                ATH_MSG_WARNING("Failed to retrieve detector element for: " << m_idHelperSvc->toString(layerID));
                continue;
            }
            const std::array<int, 4>& readoutSide=detectorReadoutElement->getReadoutSide();
 
            //
            // Sanity Checks
            //
 
            const std::string stName = m_idHelperSvc->stationNameString(layerID);
 
        
            //
            // Angles, Geometry, and Coordinates. Oh my!
            //
 
            // Surface
            const Trk::PlaneSurface& surf = detectorReadoutElement->surface(layerID);
 
            // Calculate The Inclination Angle
            // Angle
            const Amg::Vector3D globalHitDirection = hit.globalDirection();
            Trk::LocalDirection localHitDirection;
            surf.globalToLocalDirection(globalHitDirection, localHitDirection);
 
            // 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
            float inAngleCompliment_XZ = localHitDirection.angleXZ() / CLHEP::degree;
            float inAngleCompliment_YZ = localHitDirection.angleYZ() / 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.
            float inAngle_XZ = 90. - inAngleCompliment_XZ;
            float inAngle_YZ = 90. - inAngleCompliment_YZ;
 
            ATH_MSG_DEBUG("At eta: " << m_idHelperSvc->toString(layerID)
                                     << " Readout Side: " << (readoutSide).at(m_muonHelper->GetLayer(simId) - 1)
                                     << " Layer: " << m_muonHelper->GetLayer(simId) << "\n\t\t\t inAngle_XZ (degrees): " << inAngle_XZ
                                     << " inAngle_YZ (degrees): " << inAngle_YZ);
 
            // compute the hit position on the readout plane (same as in MuonFastDigitization)
            Amg::Vector3D stripLayerPosition = surf.transform().inverse() * globalHitPosition;
            Amg::Vector2D positionOnSurfaceUnprojected{stripLayerPosition.x(), stripLayerPosition.y()};
 
            Amg::Vector3D localDirection = surf.transform().inverse().linear() * globalHitDirection;
            Amg::Vector3D localDirectionTime{Amg::Vector3D::Zero()};
 
            // drift direction in backwards-chamber should be opposite to the incident direction.
            if ((readoutSide).at(idHelper.gasGap(layerID) - 1) == 1) {
                localDirectionTime = localDirection;
                inAngle_XZ = (-inAngle_XZ);
            } else
                localDirectionTime = surf.transform().inverse().linear() * globalHitDirection;
            int gasGap = idHelper.gasGap(layerID);
            double shift = 0.5 * detectorReadoutElement->getDesign(layerID)->thickness;
            double scale = 0.0;
            if (gasGap == 1 || gasGap == 3) {
                scale = -(stripLayerPosition.z() + shift) / localDirection.z();
            } else if (gasGap == 2 || gasGap == 4) {
                scale = -(stripLayerPosition.z() - shift) / localDirection.z();
            }
 
            const Amg::Vector3D hitOnSurface = stripLayerPosition + scale * localDirection;
            Amg::Vector2D positionOnSurface{hitOnSurface.x(), hitOnSurface.y()};
 
            // Account For Time Offset
            double shiftTimeOffset = (globalHitTime - tofCorrection) * m_StripsResponseSimulation->getDriftVelocity();
            Amg::Vector3D hitAfterTimeShift(hitOnSurface.x(), hitOnSurface.y(), shiftTimeOffset);
            Amg::Vector3D hitAfterTimeShiftOnSurface = hitAfterTimeShift - (shiftTimeOffset / localDirectionTime.z()) * localDirectionTime;
 
            if (std::abs(hitAfterTimeShiftOnSurface.z()) > 0.1)
                ATH_MSG_WARNING("Bad propagation to surface after time shift " << hitAfterTimeShiftOnSurface);
 
            //  moving the hit position to the center of the gap for the SDO position
            double scaleSDO = -stripLayerPosition.z() / localDirection.z();
            Amg::Vector3D hitAtCenterOfGasGap = stripLayerPosition + scaleSDO * localDirection;
            Amg::Vector3D hitAtCenterOfGasGapGlobal = surf.transform() * hitAtCenterOfGasGap;
            ATH_MSG_DEBUG("strip layer position z" << stripLayerPosition.z() << "hitAtCenterOfGasGap " 
                                                   << Amg::toString(hitAtCenterOfGasGap)<< " gas gap " << gasGap);
 
            // Don't consider electron hits below m_energyThreshold
            if (hit.kineticEnergy() < m_energyThreshold && std::abs(hit.particleEncoding()) == 11) {
                continue;
            }
 
            // Perform Bound Check (making the call from the detector element to consider edge passivation)
            if (!detectorReadoutElement->insideActiveBounds(layerID, positionOnSurface)) {
                ATH_MSG_DEBUG("m_exitcode = 1 : shiftTimeOffset = " << shiftTimeOffset << " "<<Amg::toString(hitOnSurface));
                continue;
            }
 
            int stripNumber = detectorReadoutElement->stripNumber(positionOnSurface, layerID);
            Amg::Vector2D tmp(stripLayerPosition.x(), stripLayerPosition.y());
 
            if (stripNumber == -1) {
                ATH_MSG_WARNING("!!! Failed to obtain strip number "
                                << m_idHelperSvc->mmIdHelper().print_to_string(layerID) << "\n\t\t with pos " << positionOnSurface << " z "
                                << stripLayerPosition.z() << " eKin: " << hit.kineticEnergy() << " eDep: " << hit.depositEnergy()
                                << " unprojectedStrip: " << detectorReadoutElement->stripNumber(positionOnSurfaceUnprojected, layerID));
                continue;
            }
 
            // Re-definition Of ID
            Identifier parentID = idHelper.parentID(layerID);
            Identifier digitID = idHelper.channelID(parentID, 
                                                    idHelper.multilayer(layerID),
                                                    idHelper.gasGap(layerID), stripNumber);
 
            // contain (name, eta, phi, multiPlet)
            const IdentifierHash moduleHash = m_idHelperSvc->moduleHash(layerID);
 
            ATH_MSG_DEBUG(" looking up collection using moduleHash "
                          << static_cast<int>(moduleHash) << " " << m_idHelperSvc->toString(layerID)
                          << " digitID: " << m_idHelperSvc->toString(digitID));
 
            const MuonGM::MuonChannelDesign* mmChannelDesign = detectorReadoutElement->getDesign(digitID);
            double distToChannel = mmChannelDesign->distanceToChannel(positionOnSurface, stripNumber);
 
            // check whether retrieved distance is greater than strip width
            // first retrieve the strip number from position by geometrical check
            int geoStripNumber = mmChannelDesign->channelNumber(positionOnSurface);
            if (geoStripNumber == -1) ATH_MSG_WARNING("Failed to retrieve strip number");
            // retrieve channel position of closest active strip
            Amg::Vector2D chPos{Amg::Vector2D::Zero()};
            if (!mmChannelDesign->center(geoStripNumber, chPos)) {
                ATH_MSG_DEBUG("Failed to retrieve channel position for closest strip number "
                              << geoStripNumber
                              << ". Can happen if hit was found in non-active strip. Will not digitize it, since in data, "
                              << "we would probably not find a cluster formed well enough to survive reconstruction.");
                continue;
            }
 
            MagField::AtlasFieldCache fieldCache;
            SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
            const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
            if (!fieldCondObj) {
                ATH_MSG_ERROR("doDigitization: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
                return StatusCode::FAILURE;
            }
            fieldCondObj->getInitializedCache(fieldCache);
 
            // Obtain Magnetic Field At Detector Surface
            Amg::Vector3D hitOnSurfaceGlobal = surf.transform() * 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 = surf.transform().linear().inverse() * magneticField;
            if ((readoutSide).at(m_muonHelper->GetLayer(simId) - 1) == -1)
                localMagneticField[Amg::y] = -localMagneticField[Amg::y];
 
            //
            // Angles, Geometry, and Coordinates. Oh my!
            //
            //
            // Strip Response Simulation For This Hit
            //
            const MM_DigitToolInput stripDigitInput(
                stripNumber, distToChannel, inAngle_XZ, inAngle_YZ, localMagneticField,
                detectorReadoutElement->numberOfMissingBottomStrips(layerID) + 1,
                detectorReadoutElement->numberOfStrips(layerID) - detectorReadoutElement->numberOfMissingTopStrips(layerID),
                idHelper.gasGap(layerID), eventTime + globalHitTime);
 
            // fill the SDO collection in StoreGate
            // create here deposit for MuonSimData, link and tof
            //
            // Since we have output based on channel, instead of hit, the SDO and digit ID are No longer meaningless. 2016/06/27 T.Saito
            //
            // digitize input for strip response
 
            MuonSimData::Deposit deposit(particleLink, MuonMCData(hitOnSurface.x(), hitOnSurface.y()));
 
            // Record the SDO collection in StoreGate
            std::vector<MuonSimData::Deposit> deposits{deposit};
            MuonSimData simData(std::move(deposits), 0);
            simData.setPosition(hitAtCenterOfGasGapGlobal);
            simData.setTime(globalHitTime);
            sdoContainer->insert(std::make_pair(digitID, simData));
            ATH_MSG_DEBUG(" added MM SDO " << sdoContainer->size());
 
            float gainFraction = 1.0;
            if (m_doSmearing) {
                // build identifier including the strip since layerId does not contain teh strip number
                Identifier id = idHelper.channelID(layerID, 
                                                   idHelper.multilayer(layerID),
                                                   idHelper.gasGap(layerID), stripNumber);
                ATH_CHECK(m_smearingTool->getGainFraction(id, gainFraction));
            }
            double stripPitch = detectorReadoutElement->getDesign(layerID)->channelWidth();
 
            MM_StripToolOutput tmpStripOutput = m_StripsResponseSimulation->GetResponseFrom(stripDigitInput, gainFraction, stripPitch, rndmEngine);
            MM_ElectronicsToolInput stripDigitOutput(tmpStripOutput.NumberOfStripsPos(), tmpStripOutput.chipCharge(),
                                                     tmpStripOutput.chipTime(), digitID, hit.kineticEnergy());
 
            v_stripDigitOutput.push_back(stripDigitOutput);
 
        }  // Hit Loop
 
        // Now at Detector Element Level (VMM)
 
        if (v_stripDigitOutput.empty()) {
            ATH_MSG_DEBUG("MM_DigitizationTool::doDigitization() -- there is no strip response on this VMM.");
            continue;
        }
        //
        // VMM Simulation
        //
 
        // Combine all strips (for this VMM) into a single VMM-level object
        //
        MM_ElectronicsToolInput stripDigitOutputAllHits = combinedStripResponseAllHits(v_stripDigitOutput);
        if (!m_idHelperSvc->isMM(stripDigitOutputAllHits.digitID())) {
            ATH_MSG_WARNING("Identifier from stripdigitOutputAllHits " 
                            << m_idHelperSvc->toString(stripDigitOutputAllHits.digitID())
                            << " is not a MM Identifier, skipping");
            continue;
        }
 
        // Create Electronics Output with peak finding setting
        //
        
        MM_DigitToolOutput electronicsOutputForReadout {m_vmmReadoutMode == "peak" 
                                                         ? m_ElectronicsResponseSimulation->getPeakResponseFrom(stripDigitOutputAllHits)
                                                         : m_ElectronicsResponseSimulation->getThresholdResponseFrom(stripDigitOutputAllHits)};
        if (!electronicsOutputForReadout.isValid()) {
            ATH_MSG_DEBUG("MM_DigitizationTool::doDigitization() -- "<<
                         " there is no electronics response (peak 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];
            float time = electronicsOutputForReadout.stripTime()[firedCh];
            float 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;
            }
            bool acceptStrip = true;
            if (m_doSmearing) {
                ATH_CHECK(m_smearingTool->smearTimeAndCharge(digitID, time, charge, acceptStrip, rndmEngine));
 
            }
            if (!acceptStrip) {
                ATH_MSG_DEBUG("Exaggeated with smearing "<<m_idHelperSvc->toString(digitID));
                continue;
            }
            std::unique_ptr<MmDigit> newDigit = std::make_unique<MmDigit>(digitID, time, charge);
            
            const IdentifierHash moduleHash = m_idHelperSvc->moduleHash(digitID);
            if (moduleHash >= collections.size()) {
                collections.resize(moduleHash+1);
            }
            MmDigitCollection* coll = collections[moduleHash].get();
            if (!coll) {
                collections[moduleHash] = std::make_unique<MmDigitCollection>(m_idHelperSvc->chamberId(digitID), moduleHash);
                coll = collections[moduleHash].get();
            }
            coll->push_back(std::move(newDigit));            
        }
        v_stripDigitOutput.clear();
    }
 
    for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
      if (collections[coll_hash]) {
        ATH_CHECK( digitContainer->addCollection (collections[coll_hash].release(), coll_hash) );
      }
    }
 
    ATH_MSG_DEBUG("MM_Digitization Done!");
 
    m_timedHitCollection_MM.reset();
 
    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

◆ getNextEvent()

StatusCode MM_DigitizationTool::getNextEvent ( const EventContext & ctx )

private

Record MmDigitContainer and MuonSimDataCollection.

Definition at line 326 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                    {
    // Get next event and extract collection of hit collections:
    // This is applicable to non-PileUp Event...
 
    ATH_MSG_DEBUG("MM_DigitizationTool::getNextEvent()");
 
    //  get the container(s)
    using TimedHitCollList = PileUpMergeSvc::TimedList<MMSimHitCollection>::type;
 
    // In case of single hits container just load the collection using read handles
    if (!m_onlyUseContainerName) {
        SG::ReadHandle<MMSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
        if (!hitCollection.isValid()) {
            ATH_MSG_ERROR("Could not get MMSimHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
            return StatusCode::FAILURE;
        }
 
        // create a new hits collection
        m_timedHitCollection_MM = std::make_unique<TimedHitCollection<MMSimHit>>(1);
        m_timedHitCollection_MM->insert(0, hitCollection.cptr());
        ATH_MSG_DEBUG("MMSimHitCollection found with " << hitCollection->size() << " hits");
        return StatusCode::SUCCESS;
    }
 
    // this is a list<info<time_t, DataLink<MMSimHitCollection> > >
    TimedHitCollList hitCollList;
 
    ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList));
    if (hitCollList.empty()) {
        ATH_MSG_ERROR("TimedHitCollList has size 0");
        return StatusCode::FAILURE;
    } else {
        ATH_MSG_DEBUG(hitCollList.size() << " MicroMegas SimHitCollections with key " << m_inputObjectName << " found");
    }
 
    // create a new hits collection - Define Hit Collection
    if (m_timedHitCollection_MM == nullptr) {
        m_timedHitCollection_MM = std::make_unique<TimedHitCollection<MMSimHit>>();
    } else {
        ATH_MSG_ERROR("m_timedHitCollection_MM is not null");
        return StatusCode::FAILURE;
    }
 
    // now merge all collections into one
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
 
    // loop on the hit collections
    while (iColl != endColl) {
        const MMSimHitCollection* tmpColl(iColl->second);
        m_timedHitCollection_MM->insert(iColl->first, tmpColl);
        ATH_MSG_DEBUG("MMSimHitCollection found with " << tmpColl->size() << " hits");
        ++iColl;
    }
    return StatusCode::SUCCESS;
}

◆ getRandomEngine()

CLHEP::HepRandomEngine * MM_DigitizationTool::getRandomEngine	(	const std::string &	streamName,
		const EventContext &	ctx ) const

private

Definition at line 897 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

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

◆ initialize()

StatusCode MM_DigitizationTool::initialize ( )

finaloverridevirtual

Initialize.

Small wedges first eta station

Small wedges second eta station

Large wedges first eta station

Reimplemented from PileUpToolBase.

Definition at line 71 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                           {
    ATH_MSG_DEBUG("MM_DigitizationTool:: in initialize()");
 
    ATH_CHECK(m_rndmSvc.retrieve());
 
    // Initialize transient detector store and MuonGeoModel OR MuonDetDescrManager
    ATH_CHECK(m_DetectorManagerKey.initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    if (m_hitsContainerKey.key().empty()) {
        ATH_MSG_FATAL("Property InputObjectName not set !");
        return StatusCode::FAILURE;
    }
 
    if (m_onlyUseContainerName) m_inputObjectName = m_hitsContainerKey.key();
    ATH_MSG_DEBUG("Input objects in container: '" << m_inputObjectName << "'");
 
    // Pile-up merge service
    if (m_onlyUseContainerName) { ATH_CHECK(m_mergeSvc.retrieve()); }
 
    // Initialize ReadHandleKey
    ATH_CHECK(m_hitsContainerKey.initialize());
 
    // Initialize the output WriteHandleKeys
    ATH_CHECK(m_outputDigitCollectionKey.initialize());
    ATH_CHECK(m_outputSDO_CollectionKey.initialize());
    ATH_MSG_DEBUG("Output Digits: '" << m_outputDigitCollectionKey.key() << "'");
 
    ATH_CHECK(m_condThrshldsKey.initialize(m_useCondThresholds));
    ATH_CHECK(m_fieldCondObjInputKey.initialize());
    ATH_CHECK(m_calibrationTool.retrieve());
 
    // simulation identifier helper
    m_muonHelper = MicromegasHitIdHelper::GetHelper();
 
    // get gas properties from calibration tool
    const NSWCalib::MicroMegaGas prop = m_calibrationTool->mmGasProperties();
    const float 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);
 
    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
    const MuonGM::MuonDetectorManager* muonGeoMgr{nullptr};
    ATH_CHECK(detStore()->retrieve(muonGeoMgr));
    int stripNumberShortestStrip{-1}, stripNumberLongestStrip{-1};
    Identifier tmpIdShortestStrip{0},tmpIdLongestStrip{0};
    float shortestStripLength{FLT_MAX}, longestStripLength{0};   
 
    //============================
    //SMALL SECTORS - ETA 1 CHAMBERS
    // identifier for first gas gap in a small MM sector, layer is eta layer
    tmpId = m_idHelperSvc->mmIdHelper().channelID("MMS", 1, 1, 1, 1, 1);
    const MuonGM::MMReadoutElement* detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
    stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
    tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 1, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
    shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
 
    stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
    tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 1, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
    longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
 
    // now get the slope and intercept for the threshold scaling
    // function is m_noiseSlope * stripLength + m_noiseIntercept
    NoiseCalibConstants& 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;    
    //============================
 
    //============================
    //SMALL SECTORS - ETA 2 CHAMBERS
    // identifier for first gas gap in a small MM sector, layer is eta layer
    tmpId = m_idHelperSvc->mmIdHelper().channelID("MMS", 2, 1, 1, 1, 1);
    detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
    stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
    tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 2, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
    shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
 
    stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
    tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MMS", 2, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
    longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
 
    // now get the slope and intercept for the threshold scaling
    // function is m_noiseSlope * stripLength + m_noiseIntercept
    NoiseCalibConstants& 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;
    //============================
 
    //============================
    //LARGE SECTORS - ETA 1 CHAMBERS
    // identifier for first gas gap in a small MM sector, layer is eta layer
    tmpId = m_idHelperSvc->mmIdHelper().channelID("MML", 1, 1, 1, 1, 1);
    detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
    stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
    tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 1, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
    shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
 
    stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
    tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 1, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
    longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
 
    // now get the slope and intercept for the threshold scaling
    // function is m_noiseSlope * stripLength + m_noiseIntercept
    NoiseCalibConstants& 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;    
    //============================
 
    //============================
    //LARGE SECTORS - ETA 2 CHAMBERS
    // identifier for first gas gap in a small MM sector, layer is eta layer
    tmpId = m_idHelperSvc->mmIdHelper().channelID("MML", 2, 1, 1, 1, 1);
    detectorReadoutElement = muonGeoMgr->getMMReadoutElement(tmpId);
    stripNumberShortestStrip = (detectorReadoutElement->getDesign(tmpId))->nMissedBottomEta + 1;
    tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 2, 1, 1, 1, stripNumberShortestStrip);  // identifier for the shortest strip
    shortestStripLength = detectorReadoutElement->stripLength(tmpIdShortestStrip);
 
    stripNumberLongestStrip = (detectorReadoutElement->getDesign(tmpId))->totalStrips - (detectorReadoutElement->getDesign(tmpId))->nMissedTopEta;
    tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID("MML", 2, 1, 1, 1, stripNumberLongestStrip);  // identifier for the longest strip
    longestStripLength = detectorReadoutElement->stripLength(tmpIdLongestStrip);
 
    // now get the slope and intercept for the threshold scaling
    // function is m_noiseSlope * stripLength + m_noiseIntercept
    NoiseCalibConstants& 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;    
    //============================
 
    ATH_MSG_DEBUG("Configuration  MM_DigitizationTool ");
    ATH_MSG_INFO("RndmSvc                " << m_rndmSvc);
    ATH_MSG_INFO("RndmEngine             " << m_rndmEngineName);
    ATH_MSG_DEBUG("InputObjectName        " << m_inputObjectName);
    ATH_MSG_DEBUG("OutputObjectName       " << m_outputDigitCollectionKey.key());
    ATH_MSG_DEBUG("OutputSDOName          " << m_outputSDO_CollectionKey.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 MM_DigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverride

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

Not (necessarily) able to access SubEvents

Definition at line 383 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                  {
    ATH_MSG_VERBOSE("MM_DigitizationTool::in mergeEvent()");
 
    ATH_CHECK(doDigitization(ctx));
 
    // reset the pointer
    m_timedHitCollection_MM.reset();
 
    // clear cloned list
    m_MMHitCollList.clear();
    return StatusCode::SUCCESS;
}

◆ prepareEvent()

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

finaloverride

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

Not able to access SubEvents

Definition at line 279 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                                             {
    ATH_MSG_DEBUG("MM_DigitizationTool::prepareEvent() called for " << nInputEvents << " input events");
 
    m_MMHitCollList.clear();
 
    if (!m_timedHitCollection_MM) {
        m_timedHitCollection_MM = std::make_unique<TimedHitCollection<MMSimHit>>();
    } else {
        ATH_MSG_ERROR("m_timedHitCollection_MM is not null");
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
}

◆ processAllSubEvents()

StatusCode MM_DigitizationTool::processAllSubEvents ( const EventContext & ctx )

overridevirtual

When being run from MM_Digitizer, this method is called during the event loop.

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

Reimplemented from PileUpToolBase.

Definition at line 398 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                           {
    ATH_MSG_DEBUG("MM_DigitizationTool::processAllSubEvents()");
 
    // merging of the hit collection in getNextEvent method
 
    if (!m_timedHitCollection_MM) ATH_CHECK(getNextEvent(ctx));
 
    ATH_CHECK(doDigitization(ctx));
 
    // reset the pointer
    m_timedHitCollection_MM.reset();
    return StatusCode::SUCCESS;
}

◆ processBunchXing()

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

finaloverridevirtual

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

Reimplemented from PileUpToolBase.

Definition at line 294 of file MuonDigitization/MM_Digitization/src/MM_DigitizationTool.cxx.

                                                                                                                        {
    ATH_MSG_DEBUG("MM_DigitizationTool::in processBunchXing()" << bunchXing);
 
    typedef PileUpMergeSvc::TimedList<MMSimHitCollection>::type TimedHitCollList;
    TimedHitCollList hitCollList;
 
    if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitCollList, bunchXing, bSubEvents, eSubEvents).isSuccess()) &&
        hitCollList.empty()) {
        ATH_MSG_ERROR("Could not fill TimedHitCollList");
        return StatusCode::FAILURE;
    } else {
        ATH_MSG_VERBOSE(hitCollList.size() << " MMSimHitCollection with key " << m_inputObjectName << " found");
    }
 
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
 
    // Iterating over the list of collections
    for (; iColl != endColl; ++iColl) {
        auto hitCollPtr = std::make_unique<MMSimHitCollection>(*iColl->second);
        PileUpTimeEventIndex timeIndex(iColl->first);
 
        ATH_MSG_DEBUG("MMSimHitCollection found with " << hitCollPtr->size() << " hits");
        ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time() << " index: " << timeIndex.index() << " type: " << timeIndex.type());
 
        m_timedHitCollection_MM->insert(timeIndex, hitCollPtr.get());
        m_MMHitCollList.push_back(std::move(hitCollPtr));
    }
    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));
  }

Member Data Documentation

◆ m_ARTdeadtime

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

private

Definition at line 166 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_avalancheGain

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

private

Definition at line 160 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_calibrationTool

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

private

Definition at line 118 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_checkMMSimHits

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

private

Definition at line 144 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_condThrshldsKey

SG::ReadCondHandleKey<NswCalibDbThresholdData> MM_DigitizationTool::m_condThrshldsKey

private

Initial value:

{
        this, "CondThrshldsKey", "NswCalibDbThresholdData",
        "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"}

Definition at line 121 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

                                                                  {
        this, "CondThrshldsKey", "NswCalibDbThresholdData",
        "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"};

◆ m_crossTalk1

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

private

Definition at line 157 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_crossTalk2

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

private

Definition at line 158 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MM_DigitizationTool::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",

"Key of input MuonDetectorManager condition data"}

Definition at line 190 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

190 {this, "DetectorManagerKey", "MuonDetectorManager",

191 "Key of input MuonDetectorManager condition data"};

◆ m_DiffMagSecondMuonHit

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

private

Definition at line 138 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

138{this, "DiffMagSecondMuonHit", 0.1};

◆ m_doSmearing

Gaudi::Property<bool> 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 147 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

147 {this, "doSmearing", true,

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

◆ m_driftGapWidth

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

private

Definition at line 156 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_ElectronicsResponseSimulation

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

private

Definition at line 196 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

196{};

◆ m_electronicsThreshold

Gaudi::Property<float> MM_DigitizationTool::m_electronicsThreshold

private

Initial value:

{this, "electronicsThreshold", 15000,

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

Definition at line 163 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

163 {this, "electronicsThreshold", 15000,

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

◆ m_energyThreshold

Gaudi::Property<double> MM_DigitizationTool::m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to produce a PRD"}

private

Definition at line 133 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

133{this, "EnergyThreshold", 50, "Minimal energy to produce a PRD"};

◆ m_fieldCondObjInputKey

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

private

Definition at line 120 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

120{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_hitsContainerKey

SG::ReadHandleKey<MMSimHitCollection> MM_DigitizationTool::m_hitsContainerKey {this, "InputObjectName", "MM_Hits", "name of the input objects"}

private

Definition at line 127 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

127{this, "InputObjectName", "MM_Hits", "name of the input objects"};

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MM_DigitizationTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 116 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_inputObjectName

std::string MM_DigitizationTool::m_inputObjectName {""}

private

Definition at line 128 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

128{""};

◆ 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> MM_DigitizationTool::m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}

private

Definition at line 140 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_mergeSvc

ServiceHandle<PileUpMergeSvc> MM_DigitizationTool::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}

private

Definition at line 173 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

173{this, "PileUpMergeSvc", "PileUpMergeSvc", "Merge service used in digitization"};

◆ m_MMHitCollList

std::list<std::unique_ptr<MMSimHitCollection> > MM_DigitizationTool::m_MMHitCollList {}

private

Definition at line 193 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

193{};

◆ m_muonHelper

const MicromegasHitIdHelper* MM_DigitizationTool::m_muonHelper {nullptr}

private

Definition at line 189 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

189{nullptr}; // not owned

◆ m_needsMcEventCollHelper

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

private

Definition at line 143 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

143{this, "UseMcEventCollectionHelper", false};

◆ m_noiseParams

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

private

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

Definition at line 201 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

201{};

◆ m_onlyUseContainerName

Gaudi::Property<bool> MM_DigitizationTool::m_onlyUseContainerName

private

Initial value:

{this, "OnlyUseContainerName", true,

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

Definition at line 125 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

125 {this, "OnlyUseContainerName", true,

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

◆ m_outputDigitCollectionKey

SG::WriteHandleKey<MmDigitContainer> MM_DigitizationTool::m_outputDigitCollectionKey

private

Initial value:

{

this, "OutputObjectName", "MM_DIGITS", "WriteHandleKey for Output MmigitContainer"}

Definition at line 168 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

168 {

169 this, "OutputObjectName", "MM_DIGITS", "WriteHandleKey for Output MmigitContainer"}; // name of the output digits

◆ m_outputSDO_CollectionKey

SG::WriteHandleKey<MuonSimDataCollection> MM_DigitizationTool::m_outputSDO_CollectionKey

private

Initial value:

{

this, "OutputSDOName", "MM_SDO", "WriteHandleKey for Output MuonSimDataCollection"}

Definition at line 170 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

170 {

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

◆ m_qThreshold

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

private

Definition at line 155 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_rndmEngineName

Gaudi::Property<std::string> MM_DigitizationTool::m_rndmEngineName {this, "RndmEngine", "MuonDigitization", "Random engine name"}

private

Definition at line 114 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

114{this, "RndmEngine", "MuonDigitization", "Random engine name"};

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> MM_DigitizationTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in Muon digitization"}

private

Definition at line 113 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

113{this, "RndmSvc", "AthRNGSvc", "Random Number Service used in Muon digitization"};

◆ m_smearingTool

ToolHandle<Muon::INSWCalibSmearingTool> MM_DigitizationTool::m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}

private

Definition at line 117 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_stripdeadtime

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

private

Definition at line 165 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_StripsResponseSimulation

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

private

Definition at line 195 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

195{};

◆ m_thresholdScaleFactor

Gaudi::Property<float> 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 179 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

179 {this, "thresholdScaleFactor", 7.0,

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

◆ m_timedHitCollection_MM

std::unique_ptr<TimedHitCollection<MMSimHit> > MM_DigitizationTool::m_timedHitCollection_MM {}

private

Definition at line 194 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

194{}; // the pileup hits

◆ m_timeWindowLowerOffset

Gaudi::Property<double> 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 134 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

134 {this, "WindowLowerOffset", -12.5,

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

◆ m_timeWindowUpperOffset

Gaudi::Property<double> 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 136 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

136 {this, "WindowUpperOffset", 187.5,

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

◆ m_useCondThresholds

Gaudi::Property<bool> MM_DigitizationTool::m_useCondThresholds

private

Initial value:

{this, "useCondThresholds", false,

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

Definition at line 175 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

175 {this, "useCondThresholds", false,

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

◆ m_useThresholdScaling

Gaudi::Property<bool> MM_DigitizationTool::m_useThresholdScaling

private

Initial value:

{this, "useThresholdScaling", true,

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

Definition at line 177 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

177 {this, "useThresholdScaling", true,

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

◆ m_useTimeWindow

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

private

Definition at line 145 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

145{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> MM_DigitizationTool::m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}

private

Definition at line 131 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_vmmDeadtime

Gaudi::Property<float> MM_DigitizationTool::m_vmmDeadtime

private

Initial value:

{

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

Definition at line 181 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

181 {

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

◆ m_vmmNeighborLogic

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

private

Definition at line 146 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

146{this, "VMMNeighborLogic", false};

◆ m_vmmReadoutMode

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

private

Definition at line 130 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

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

◆ m_vmmUpperGrazeWindow

Gaudi::Property<float> MM_DigitizationTool::m_vmmUpperGrazeWindow

private

Initial value:

{

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

Definition at line 185 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

185 {

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

◆ m_writeOutputFile

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

private

Definition at line 142 of file MuonDigitization/MM_Digitization/MM_Digitization/MM_DigitizationTool.h.

142{this, "SaveInternalHistos", false};

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

structors and AlgTool implementation

Detailed Description

Member Typedef Documentation

◆ NoiseCalibConstants

Constructor & Destructor Documentation

◆ MM_DigitizationTool()

Member Function Documentation

◆ checkMMSimHit()

◆ combinedStripResponseAllHits()

◆ digitize()

◆ doDigitization()

◆ filterPassed()

◆ getNextEvent()

◆ getRandomEngine()

◆ initialize()

◆ mergeEvent()

◆ prepareEvent()

◆ processAllSubEvents()

◆ processBunchXing()

◆ resetFilter()

◆ toProcess()

Member Data Documentation

◆ m_ARTdeadtime

◆ m_avalancheGain

◆ m_calibrationTool

◆ m_checkMMSimHits

◆ m_condThrshldsKey

◆ m_crossTalk1

◆ m_crossTalk2

◆ m_DetectorManagerKey

◆ m_DiffMagSecondMuonHit

◆ m_doSmearing

◆ m_driftGapWidth

◆ m_ElectronicsResponseSimulation

◆ m_electronicsThreshold

◆ m_energyThreshold

◆ m_fieldCondObjInputKey

◆ m_filterPassed

◆ m_firstXing

◆ m_hitsContainerKey

◆ m_idHelperSvc

◆ m_inputObjectName

◆ m_lastXing

◆ m_maskMultiplet

◆ m_mergeSvc

◆ m_MMHitCollList

◆ m_muonHelper

◆ m_needsMcEventCollHelper

◆ m_noiseParams

◆ m_onlyUseContainerName

◆ m_outputDigitCollectionKey

◆ m_outputSDO_CollectionKey

◆ m_qThreshold

◆ m_rndmEngineName

◆ m_rndmSvc

◆ m_smearingTool

◆ m_stripdeadtime

◆ m_StripsResponseSimulation

◆ m_thresholdScaleFactor

◆ m_timedHitCollection_MM

◆ m_timeWindowLowerOffset

◆ m_timeWindowUpperOffset

◆ m_useCondThresholds

◆ m_useThresholdScaling

◆ m_useTimeWindow

◆ m_vetoPileUpTruthLinks

◆ m_vmmARTMode

◆ m_vmmDeadtime

◆ m_vmmNeighborLogic

◆ m_vmmReadoutMode

◆ m_vmmUpperGrazeWindow

◆ m_writeOutputFile