MdtDigitizationTool Class Reference

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 MdtIdHelper.The MdtDigitContainer is initialized and the simulation identifier helper retrieved, together with the pointer to the digitization tool. More...

#include <MdtDigitizationTool.h>

Inheritance diagram for MdtDigitizationTool:

Classes
struct	GeoCorOut

Public Member Functions
	MdtDigitizationTool (const std::string &type, const std::string &name, const IInterface *pIID)
virtual	~MdtDigitizationTool ()=default
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.
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	When being run from PileUpToolsAlgs, this method is called for each active bunch-crossing to process current SubEvents bunchXing is in ns.
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 final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Protected Attributes
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
BooleanProperty	m_onlyUseContainerName
SG::ReadHandleKey< MDTSimHitCollection >	m_hitsContainerKey {this, "InputObjectName", "MDT_Hits", ""}
std::string	m_inputObjectName {""}
SG::WriteHandleKey< MdtDigitContainer >	m_outputObjectKey
SG::WriteHandleKey< MuonSimDataCollection >	m_outputSDOKey
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
SG::ReadCondHandleKey< MuonCalib::MdtCalibDataContainer >	m_calibDbKey
SG::ReadCondHandleKey< MdtCondDbData >	m_readKey {this, "ReadKey", "MdtCondDbData", "Key of MdtCondDbData"}

Private Types
using	Collections_t = std::vector<std::unique_ptr<MdtDigitCollection> >

Private Member Functions
CLHEP::HepRandomEngine *	getRandomEngine (const std::string &streamName, const EventContext &ctx) const
int	digitizeTime (double time, bool isHPTDC, CLHEP::HepRandomEngine *rndmEngine) const
double	minimumTof (Identifier DigitId, const MuonGM::MuonDetectorManager *detMgr) const
bool	insideMatchingWindow (double time) const
bool	insideMaskWindow (double time) const
bool	checkMDTSimHit (const EventContext &ctx, const MDTSimHit &hit) const
bool	handleMDTSimHit (const EventContext &ctx, const TimedHitPtr< MDTSimHit > &phit, CLHEP::HepRandomEngine *twinRndmEngine, CLHEP::HepRandomEngine *toolRndmEngine)
bool	createDigits (const EventContext &ctx, Collections_t &collections, MuonSimDataCollection *sdoContainer, CLHEP::HepRandomEngine *rndmEngine)
GeoCorOut	correctGeometricalWireSag (const MDTSimHit &hit, const Identifier &id, const MuonGM::MdtReadoutElement *element) const
StatusCode	getNextEvent (const EventContext &ctx)
StatusCode	doDigitization (const EventContext &ctx, Collections_t &collections, MuonSimDataCollection *sdoContainer)
MdtDigitCollection *	getDigitCollection (Identifier elementId, Collections_t &collections)
void	fillMaps (const MDTSimHit *mdtHit, const Identifier digitId, const double driftR)

Static Private Member Functions
static MDTSimHit	applyDeformations (const MDTSimHit &, const MuonGM::MdtReadoutElement *, const Identifier &)

Private Attributes
MDT_SortedHitVector	m_hits
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
const MdtHitIdHelper *	m_muonHelper {}
const MuonGM::MuonDetectorManager *	m_MuonGeoMgr {}
ToolHandle< IMDT_DigitizationTool >	m_digiTool
std::vector< MDTSimHitCollection * >	m_MDTHitCollList
Gaudi::Property< double >	m_offsetTDC {this, "OffsetTDC", 800., "TDC offset used if no calibration data is found"}
Gaudi::Property< double >	m_signalSpeed {this, "SignalSpeed", 0.85*Gaudi::Units::c_light}
Gaudi::Property< double >	m_ns2TDCAMT {this, "ns2TDCAMT", 0.78125, "Conversion factor TDC/ns for AMT chips"}
Gaudi::Property< double >	m_ns2TDCHPTDC {this, "ns2TDCHPTDC", 0.1953125, "Conversion factor TDC/ns for HPTDC chips"}
Gaudi::Property< double >	m_resTDC {this, "ResolutionTDC", 0.5, "TDC resolution"}
Gaudi::Property< double >	m_t0ShiftTuning {this,"TunedT0Shift",-17.,"Fine tuned t0 shift value in ns"}
Gaudi::Property< bool >	m_checkMDTSimHits {this, "CheckSimHits", true, "Control on the hit validity"}
Gaudi::Property< bool >	m_useTof {this, "UseTof", true, "Option for the tof calculation"}
Gaudi::Property< bool >	m_useAttenuation {this, "UseAttenuation", false, ""}
Gaudi::Property< bool >	m_useProp {this, "UseProp", true, ""}
Gaudi::Property< bool >	m_useTwin {this, "UseTwin", false, ""}
Gaudi::Property< bool >	m_useAllBOLTwin {this, "UseAllBOLTwin", false, ""}
Gaudi::Property< double >	m_resTwin {this, "ResolutionTwinTube", 1.05, "Twin Tube resolution"}
Gaudi::Property< bool >	m_useTimeWindow {this, "UseTimeWindow", true, ""}
Gaudi::Property< double >	m_bunchCountOffset {this, "BunchCountOffset", -200., "Bunch crossing offset"}
Gaudi::Property< double >	m_matchingWindow {this, "MatchingWindow", 1000., "Matching window"}
Gaudi::Property< double >	m_maskWindow {this, "MaskWindow", 250., "Masked window"}
Gaudi::Property< double >	m_deadTime {this, "DeadTime", 700., "MDT drift tube dead time"}
Gaudi::Property< bool >	m_DiscardEarlyHits {this, "DiscardEarlyHits", true, ""}
Gaudi::Property< bool >	m_useOffSet1 {this, "UseOffSet1", true, ""}
Gaudi::Property< bool >	m_useOffSet2 {this, "UseOffSet2", true, ""}
Gaudi::Property< bool >	m_useDeformations {this, "UseDeformations", false, ""}
Gaudi::Property< bool >	m_DoQballCharge {this, "DoQballCharge", false, "dEdx for Qballs with account of electric charge"}
std::unique_ptr< TimedHitCollection< MDTSimHit > >	m_thpcMDT {}
Gaudi::Property< bool >	m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}

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

Detailed Description

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 MdtIdHelper.The MdtDigitContainer 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 MDTSimHit collection are merged using the TimedHitCollection sorted container (done in handleMDTSimHit(TimedHitPtr <MDTSimHit>& hit)) method); into a loop over the TimedHitCollection for the given DetectorElement, the handleMDTSimHit() 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 and an ADC count which are used together with the Offline ID, to create the digit object (in createDigits() method).

The finalize() method returns a SUCCESS StatusCode if the digitization procedure ends succesfully.

Definition at line 87 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

Member Typedef Documentation

Collections_t

using MdtDigitizationTool::Collections_t = std::vector<std::unique_ptr<MdtDigitCollection> >

private

Definition at line 119 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

Constructor & Destructor Documentation

MdtDigitizationTool()

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

Definition at line 64 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                                             :
    PileUpToolBase(type, name, pIID) {}

~MdtDigitizationTool()

virtual MdtDigitizationTool::~MdtDigitizationTool ( )

virtualdefault

Member Function Documentation

applyDeformations()

MDTSimHit MdtDigitizationTool::applyDeformations ( const MDTSimHit & hit, const MuonGM::MdtReadoutElement * element, const Identifier & DigitId )

staticprivate

Definition at line 811 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                            {
    // make the deformation
    Amg::Vector3D hitAtGlobalFrame = element->nodeform_localToGlobalTransf(DigitId) * hit.localPosition();
    Amg::Vector3D hitDeformed = element->globalToLocalTransf(DigitId) * hitAtGlobalFrame;
    MDTSimHit simhit2(hit);
    // apply the deformation
    simhit2.setDriftRadius(hitDeformed.perp());
    simhit2.setLocalPosition(hitDeformed);
    return simhit2;
}

checkMDTSimHit()

bool MdtDigitizationTool::checkMDTSimHit ( const EventContext & ctx, const MDTSimHit & hit ) const

private

Definition at line 540 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                            {
    // get the hit Identifier and info
    const int id = hit.MDTid();
    std::string stationName = m_muonHelper->GetStationName(id);
    int stationEta = m_muonHelper->GetZSector(id);
    int stationPhi = m_muonHelper->GetPhiSector(id);
    int multilayer = m_muonHelper->GetMultiLayer(id);
    int layer = m_muonHelper->GetLayer(id);
    int tube = m_muonHelper->GetTube(id);
 
    Identifier DigitId = m_idHelperSvc->mdtIdHelper().channelID(stationName, stationEta, stationPhi, multilayer, layer, tube);
    ATH_MSG_DEBUG("Working on hit: " << m_idHelperSvc->mdtIdHelper().show_to_string(DigitId) << "  "
                                     << m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(DigitId))
                                     << " " << stationEta << " " << stationPhi);
 
    //+MASKING OF DEAD/MISSING CHAMBERS
    if (!m_readKey.empty()) {
        SG::ReadCondHandle<MdtCondDbData> readCdo{m_readKey, ctx};
        if (!readCdo.isValid()) {
            ATH_MSG_WARNING(m_readKey.fullKey() << " is not available.");
            return false;
        }
        if (!readCdo->isGood(DigitId)) return false;      
    } 
    //-MASKING OF DEAD/MISSING CHAMBERS
 
    double tubeL{0.}, tubeR{0.};
    const MuonGM::MdtReadoutElement* element = m_MuonGeoMgr->getMdtReadoutElement(DigitId);
 
    if (!element) {
        ATH_MSG_ERROR("MuonGeoManager does not return valid element for given id!");
    } else {
        tubeL = element->tubeLength(DigitId);
        tubeR = element->innerTubeRadius();
    }
 
    bool ok(true);
 
    if (std::abs(hit.driftRadius()) > tubeR) {
        ok = false;
        ATH_MSG_DEBUG("MDTSimHit has invalid radius: " << hit.driftRadius() << "   tubeRadius " << tubeR);
    }
 
    if (std::abs(hit.localPosition().z()) > 0.5 * tubeL) {
        ok = false;
        ATH_MSG_DEBUG("MDTSimHit has invalid position along tube: " << hit.localPosition().z() << "   tubeLength " << tubeL);
    }
 
    if (m_useTof) {
        double minTof = minimumTof(DigitId, m_MuonGeoMgr);
        if ((hit.globalTime() < 0 || hit.globalTime() > 10 * minTof) && m_DiscardEarlyHits) {
            ok = false;
            ATH_MSG_DEBUG("MDTSimHit has invalid global time: " << hit.globalTime() << "   minimum Tof " << minTof);
        }
    } else {
        ATH_MSG_DEBUG("MDTSimHit global time: " << hit.globalTime() << " accepted anyway as UseTof is false");
    }
 
    return ok;
}

correctGeometricalWireSag()

MdtDigitizationTool::GeoCorOut MdtDigitizationTool::correctGeometricalWireSag ( const MDTSimHit & hit, const Identifier & id, const MuonGM::MdtReadoutElement * element ) const

private

Definition at line 823 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                                                            {
    Amg::Vector3D lpos = hit.localPosition();
    Amg::Transform3D gToWireFrame = element->globalToLocalTransf(id);
 
    // local track direction in precision plane
    Amg::Vector3D ldir(-lpos.y(), lpos.x(), 0.);
    ldir.normalize();
 
    //  calculate the position of the hit sagged wire frame
    // transform to global coords
    const Amg::Transform3D& transf{element->localToGlobalTransf(id)};
    Amg::Vector3D gpos = transf*lpos;
    Amg::Vector3D gdir = transf* ldir;
 
    // get wire surface
    const Trk::StraightLineSurface& surface = element->surface(id);
 
    // check whether direction is pointing away from IP
    double pointingCheck = gpos.dot(gdir) < 0 ? -1. : 1.;
    if (pointingCheck < 0) { gdir *= pointingCheck; }
 
    double trackingSign = 1.;
    double localSag = 0.0;
    
    // recalculate tracking sign
    Amg::Vector2D lpsag{Amg::Vector2D::Zero()};
    surface.globalToLocal(gpos, gdir, lpsag);
    trackingSign = lpsag[Trk::locR] < 0 ? -1. : 1.;
 
 
    // local gravity vector
    Amg::Vector3D gravityDir =-1. * Amg::Vector3D::UnitY();
    Amg::Vector3D lgravDir = gToWireFrame * gravityDir;
 
    // Project gravity vector onto X-Y plane, so the z-components (along the wire)
    // don't contribute to the dot-product.
    lgravDir.z() = 0.;
 
    // calculate whether hit above or below wire (using gravity direction
    // 1 -> hit below wire (in same hemisphere as gravity vector)
    //-1 -> hit above wire (in opposite hemisphere as gravity vector)
    double sign = lpos.dot(lgravDir) < 0 ? -1. : 1.;
 
    return {sign, trackingSign, lpos, localSag};
}

createDigits()

bool MdtDigitizationTool::createDigits ( const EventContext & ctx, Collections_t & collections, MuonSimDataCollection * sdoContainer, CLHEP::HepRandomEngine * rndmEngine )

private

Definition at line 601 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                         {
    Identifier currentDigitId{0}, currentElementId{0};
 
    double currentDeadTime = 0.;
    MdtDigitCollection* digitCollection = nullptr;
    // loop over sorted hits
    m_hits.sort();
    HitIt it = m_hits.begin();
 
    // +For Cosmics add
    double timeOffsetEvent = 0.0;
    double timeOffsetTotal = 0.0;
 
    // this offset emulates the timing spead of cosmics: +/- 1 BC
    if (m_useTof == false && m_useOffSet2 == true) {
        int inum = CLHEP::RandFlat::shootInt(rndmEngine, 0, 10);
        if (inum == 8) {
            timeOffsetEvent = -25.0;
        } else if (inum == 9) {
            timeOffsetEvent = 25.0;
        }
        ATH_MSG_DEBUG("Emulating timing spead of cosmics: +/- 1 BC. Adding  " << timeOffsetEvent << " ns to time");
    }
    //-ForCosmics
 
    SG::ReadCondHandle<MuonCalib::MdtCalibDataContainer> mdtCalibConstants{m_calibDbKey, ctx};
    if (!mdtCalibConstants.isValid()) {
        ATH_MSG_FATAL("Failed to retrieve set of calibration constants "<<mdtCalibConstants.fullKey());
        return false;
    }
    for (; it != m_hits.end(); ++it) {
        Identifier idDigit = it->id;
        Identifier elementId = m_idHelperSvc->mdtIdHelper().elementID(idDigit);
        const MuonGM::MdtReadoutElement* geo = m_MuonGeoMgr->getMdtReadoutElement(idDigit);
 
        // Check if we are in a new chamber, if so get the DigitCollection
        if (elementId != currentElementId) {
            currentElementId = elementId;
            digitCollection = getDigitCollection(elementId, collections);
 
            //+ForCosmics
            // this offset emulates the time jitter of cosmic ray muons w.r.t LVL1 accept
            if (m_useTof == false && m_useOffSet1 == true) {
                timeOffsetTotal = timeOffsetEvent + CLHEP::RandFlat::shoot(rndmEngine, -12.5, 12.5);
                ATH_MSG_DEBUG("Emulating time jitter of cosmic ray muons w.r.t LVL1 accept. Adding  " << timeOffsetTotal << " ns to time");
            }
            //-ForCosmics
        }
        if (!digitCollection) {
            ATH_MSG_ERROR("Trying to use nullptr digitCollection");
            return false;
        }
 
        float driftRadius = it->radius;
        double driftTime = it->time;
        double charge = it->adc;
 
        ATH_MSG_VERBOSE("New hit : driftTime " << driftTime << " adc  " << charge);
 
        // check if we are in a new tube
        if (idDigit != currentDigitId) {
            currentDigitId = idDigit;
            // set the deadTime
            currentDeadTime = driftTime + charge + m_deadTime;
            ATH_MSG_VERBOSE("New tube, setting dead time:  " << currentDeadTime << "  driftTime " << driftTime);
        } else {
            // check if tube is dead
            if (driftTime > currentDeadTime) {
                // tube produces a second hit, set the new deadtime
                currentDeadTime = driftTime + charge + m_deadTime;
                ATH_MSG_VERBOSE("Additional hit, setting dead time:  " << currentDeadTime << "  driftTime " << driftTime);
            } else {
                // tube is dead go to next hit
                ATH_MSG_VERBOSE("Hit within dead time:  " << currentDeadTime << "  driftTime " << driftTime);
                continue;
            }
        }
 
        const TimedHitPtr<MDTSimHit>& phit = *(it->simhit);
        const MDTSimHit& hit(*phit);
 
        // check if the hits lies within the TDC time window
        // subtrack the minimum Tof (= globalPosition().mag()/c) from the tof of the hit
        double relativeTime = driftTime - minimumTof(idDigit, m_MuonGeoMgr);
        bool insideMatch = insideMatchingWindow(relativeTime);
        bool insideMask = insideMaskWindow(relativeTime);
        if (insideMask && insideMatch) {
            ATH_MSG_WARNING(" Digit in matching AND masking window, please check window definition: relative time " << relativeTime);
            insideMask = false;
        }
        if (insideMatch || insideMask) {
            // get calibration constants from DbTool
            double t0 = m_offsetTDC;
            const MuonCalib::MdtFullCalibData* data{mdtCalibConstants->getCalibData(idDigit, msgStream())};
            if (data && data->tubeCalib) {
                // extract calibration constants for single tube
                const MuonCalib::MdtTubeCalibContainer::SingleTubeCalib* singleTubeData = data->tubeCalib->getCalib(idDigit);
                if (singleTubeData) { 
                    ATH_MSG_DEBUG("Extracted the following calibration constant for "<<m_idHelperSvc->toString(idDigit)<<" "<<singleTubeData->t0);
                    t0 = singleTubeData->t0 + m_t0ShiftTuning; 
                } else  ATH_MSG_WARNING("No calibration data found, using t0=" << m_offsetTDC<<" "<<m_idHelperSvc->toString(idDigit));
            } else {
                ATH_MSG_WARNING("No calibration data found, using t0=" << m_offsetTDC<<" for "<<m_idHelperSvc->toString(idDigit));
            }
            bool isHPTDC = m_idHelperSvc->hasHPTDC(idDigit);
            int tdc = digitizeTime(driftTime + t0 + timeOffsetTotal, isHPTDC, rndmEngine);
            int adc = digitizeTime(it->adc, isHPTDC, rndmEngine);
            ATH_MSG_DEBUG(" >> Digit Id = " << m_idHelperSvc->mdtIdHelper().show_to_string(idDigit) << " driftTime " << driftTime
                                            << " driftRadius " << driftRadius << " TDC " << tdc << " ADC " << adc << " mask bit "
                                            << insideMask);
 
            MdtDigit* newDigit = new MdtDigit(idDigit, tdc, adc, insideMask);
            digitCollection->push_back(newDigit);
 
            ATH_MSG_VERBOSE(" createDigits() phit-" << &phit << " hit-" << hit.print() << "    localZPos = " << hit.localPosition().z());
 
            // Do not store pile-up truth information
            if (!m_includePileUpTruth && HepMC::ignoreTruthLink(phit->particleLink(), m_vetoPileUpTruthLinks)) { continue; }
 
            // Create the Deposit for MuonSimData
            MuonSimData::Deposit deposit(HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx), // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
                                         MuonMCData(driftRadius, hit.localPosition().z()));
 
            // Record the SDO collection in StoreGate
            std::vector<MuonSimData::Deposit> deposits;
            deposits.push_back(deposit);
            MuonSimData tempSDO(deposits, 0);
            const Amg::Vector3D& tempLocPos = (*(it->simhit))->localPosition();
            Amg::Vector3D p = geo->localToGlobalTransf(idDigit)*tempLocPos;
            tempSDO.setPosition(p);
            tempSDO.setTime(hitTime(phit));
            sdoContainer->insert(std::make_pair(idDigit, tempSDO));
 
        } else {
            ATH_MSG_DEBUG("  >> OUTSIDE TIME WINDOWS << "
                          << " Digit Id = " << m_idHelperSvc->toString(idDigit) << " driftTime " << driftTime
                          << " --> hit ignored");
        }
    }  // for (; it != hits.end(); ++it)
 
    return true;
}

digitizeTime()

int MdtDigitizationTool::digitizeTime ( double time, bool isHPTDC, CLHEP::HepRandomEngine * rndmEngine ) const

private

Definition at line 767 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                                       {
    int tdcCount{0};
    double tmpCount = isHPTDC ? time / m_ns2TDCHPTDC : time / m_ns2TDCAMT;
    tdcCount = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tmpCount, m_resTDC);
    if (tdcCount < 0 || tdcCount > 4096) { ATH_MSG_DEBUG(" Count outside TDC window: " << tdcCount); }
    return tdcCount;
}

doDigitization()

StatusCode MdtDigitizationTool::doDigitization ( const EventContext & ctx, Collections_t & collections, MuonSimDataCollection * sdoContainer )

private

Definition at line 312 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                    {
    // Set the RNGs to use for this event.
    CLHEP::HepRandomEngine* rndmEngine = getRandomEngine("", ctx);
    CLHEP::HepRandomEngine* twinRndmEngine = getRandomEngine("Twin", ctx);
    CLHEP::HepRandomEngine* toolRndmEngine = getRandomEngine(m_digiTool->name(), ctx);
 
    // get the iterator infos for this DetEl
    // iterate over hits and fill id-keyed drift time map
    TimedHitCollection<MDTSimHit>::const_iterator i, e;
 
    // Perform null check on m_thpcMDT
    if (!m_thpcMDT) {
        ATH_MSG_ERROR("m_thpcMDT is null");
        return StatusCode::FAILURE;
    }
 
    while (m_thpcMDT->nextDetectorElement(i, e)) {
        // Loop over the hits:
        while (i != e) {
            handleMDTSimHit(ctx, *i, twinRndmEngine, toolRndmEngine);
            ++i;
        }
    }
 
    // loop over drift time map entries, convert to tdc value and construct/store the digit
    createDigits(ctx, collections, sdoContainer, rndmEngine);
 
    // reset hits
    m_hits.clear();
 
    // reset the pointer if it is not null
    m_thpcMDT.reset();
 
    return StatusCode::SUCCESS;
}

fillMaps()

void MdtDigitizationTool::fillMaps ( const MDTSimHit * mdtHit, const Identifier digitId, const double driftR )

private

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

getDigitCollection()

MdtDigitCollection * MdtDigitizationTool::getDigitCollection ( Identifier elementId, Collections_t & collections )

private

Definition at line 746 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                                            {
    IdContext mdtContext = m_idHelperSvc->mdtIdHelper().module_context();
    IdentifierHash coll_hash;
    if (m_idHelperSvc->mdtIdHelper().get_hash(elementId, coll_hash, &mdtContext)) {
        ATH_MSG_ERROR("Unable to get MDT hash id from MDT Digit collection "
                      << "context begin_index = " << mdtContext.begin_index() << " context end_index  = " << mdtContext.end_index()
                      << " the identifier is ");
        elementId.show();
    }
 
    if (coll_hash >= collections.size()) {
      collections.resize (coll_hash+1);
    }
 
    auto& coll = collections[coll_hash];
    if (!coll) {
      coll = std::make_unique<MdtDigitCollection>(elementId, coll_hash);
    }
    return coll.get();
}

getNextEvent()

StatusCode MdtDigitizationTool::getNextEvent ( const EventContext & ctx )

private

Definition at line 184 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                    {
    ATH_MSG_DEBUG("MdtDigitizationTool::getNextEvent()");
 
    //  get the container(s)
    using TimedHitCollList = PileUpMergeSvc::TimedList<MDTSimHitCollection>::type;
 
    // In case of single hits container just load the collection using read handles
    if (!m_onlyUseContainerName) {
        SG::ReadHandle<MDTSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
        if (!hitCollection.isValid()) {
            ATH_MSG_ERROR("Could not get MDTSimHitCollection container " << hitCollection.name() << " from store "
                                                                         << hitCollection.store());
            return StatusCode::FAILURE;
        }
 
        // create a new hits collection
        m_thpcMDT = std::make_unique<TimedHitCollection<MDTSimHit>>(1);
        m_thpcMDT->insert(0, hitCollection.cptr());
        ATH_MSG_DEBUG("MDTSimHitCollection found with " << hitCollection->size() << " hits");
 
        return StatusCode::SUCCESS;
    }
 
    // this is a list<info<time_t, DataLink<MDTSimHitCollection> > >
    TimedHitCollList hitCollList;
 
    if (!(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList).isSuccess())) {
        ATH_MSG_ERROR("Could not fill TimedHitCollList");
        return StatusCode::FAILURE;
    }
    if (hitCollList.empty()) {
        ATH_MSG_ERROR("TimedHitCollList has size 0");
        return StatusCode::FAILURE;
    } else {
        ATH_MSG_DEBUG(hitCollList.size() << " MDTSimHitCollections with key " << m_inputObjectName << " found");
    }
 
    // create a new hits collection
    m_thpcMDT = std::make_unique<TimedHitCollection<MDTSimHit>>();
 
    // now merge all collections into one
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
    while (iColl != endColl) {
        const MDTSimHitCollection* p_collection(iColl->second);
        m_thpcMDT->insert(iColl->first, p_collection);
        ATH_MSG_DEBUG("MDTSimHitCollection found with " << p_collection->size() << " hits");
        ++iColl;
    }
    return StatusCode::SUCCESS;
}

getRandomEngine()

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

private

Definition at line 236 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

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

handleMDTSimHit()

bool MdtDigitizationTool::handleMDTSimHit ( const EventContext & ctx, const TimedHitPtr< MDTSimHit > & phit, CLHEP::HepRandomEngine * twinRndmEngine, CLHEP::HepRandomEngine * toolRndmEngine )

private

Definition at line 349 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                {
    const MDTSimHit& hit(*phit);
    MDTSimHit newSimhit(*phit);  // hit can be modified later
 
    double globalHitTime(hitTime(phit));
 
    // Important checks for hits (global time, position along tube, masked chambers etc..) DO NOT SET THIS CHECK TO FALSE IF YOU DON'T KNOW
    // WHAT YOU'RE DOING !
    if (m_checkMDTSimHits && !checkMDTSimHit(ctx, hit)) return false;
    
    const int id = hit.MDTid();
    double driftRadius = hit.driftRadius();
    ATH_MSG_DEBUG("Hit bunch time  " << globalHitTime - hit.globalTime() << " tot " << globalHitTime << " tof " << hit.globalTime()
                                     << " driftRadius " << driftRadius);
 
    std::string stationName = m_muonHelper->GetStationName(id);
    int stationEta = m_muonHelper->GetZSector(id);
    int stationPhi = m_muonHelper->GetPhiSector(id);
    int multilayer = m_muonHelper->GetMultiLayer(id);
    int layer = m_muonHelper->GetLayer(id);
    int tube = m_muonHelper->GetTube(id);
 
    // construct Atlas identifier from components
    Identifier DigitId = m_idHelperSvc->mdtIdHelper().channelID(stationName, stationEta, stationPhi, multilayer, layer, tube);
 
    // get distance to readout
    double distRO(0.);
 
    // find the detector element associated to the hit
    const MuonGM::MdtReadoutElement* element = m_MuonGeoMgr->getMdtReadoutElement(DigitId);
 
    if (!element) {
        ATH_MSG_ERROR("MuonGeoManager does not return valid element for given id!");
        return false;
    } else {
        distRO = element->tubeFrame_localROPos(DigitId).z();
    }
 
    if (m_useDeformations) {
        newSimhit = applyDeformations(hit, element, DigitId);
        driftRadius = newSimhit.driftRadius();
    }
 
    // store local hit position + sign
    GeoCorOut result = correctGeometricalWireSag(hit, DigitId, element);
    if (m_useDeformations) { result = correctGeometricalWireSag(newSimhit, DigitId, element); }
    
    // correctly set sign of drift radius
    driftRadius *= result.trackingSign;
 
    //+Implementation for RT_Relation_DB_Tool
 
    // total from the hit to the tube endplug
    double distanceToRO = 0.;
    if (distRO < 0. && hit.localPosition().z() > 0.) {
        distanceToRO = -distRO + hit.localPosition().z();
    }
    else {
        distanceToRO = distRO - hit.localPosition().z();
    }
    MdtDigiToolInput digiInput(std::abs(driftRadius), distanceToRO, 0., 0., 0., 0., DigitId);
    double qcharge = 1.;
    double qgamma = -9999.;
 
    if (m_DoQballCharge) {
      // BSM particles need to be treated specially in digitization because in the default simulation the particle gamma and charge are set to the SM muon values
      // For heavy or multi-charged BSM particles the qgamma and QE are required as inputs to obtain the correct MDT ADC counts
      const HepMcParticleLink trkParticle = HepMcParticleLink::getRedirectedLink(hit.particleLink(),phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
      HepMC::ConstGenParticlePtr genParticle = trkParticle.cptr();
      if (genParticle) {
        if ( MC::isBSM(genParticle) ) { 
          const double QE = genParticle->momentum().e();
          const double QM2 = genParticle->momentum().m2();
          if (QM2 >= 0.) {
              qgamma = QE / std::sqrt(QM2);
          }
        }
        qcharge = MC::fractionalCharge(genParticle);
      }
      digiInput = MdtDigiToolInput{std::abs(driftRadius), distanceToRO, 0., 0., qcharge, qgamma, DigitId};
    }
 
    // digitize input
    MdtDigiToolOutput digiOutput(m_digiTool->digitize(ctx, digiInput, toolRndmEngine));
    //-Implementation for RT_Relation_DB_Tool
 
    // simulate tube response, check if tube fired
 
    if (digiOutput.wasEfficient()) {
        double driftTime = digiOutput.driftTime();
        double adc = digiOutput.adc();
 
        ATH_MSG_VERBOSE("Tube efficient: driftTime  " << driftTime << " adc value " << adc);
 
        if (m_useProp) {
            double position_along_wire = hit.localPosition().z();
            if (m_useDeformations) { position_along_wire = newSimhit.localPosition().z(); }
 
            // prop delay calculated with respect to the center of the tube
            double sign(-1.);
            if (distRO < 0.) sign = 1.;
            double propagation_delay = sign * (1. / m_signalSpeed) * position_along_wire;
            //------------------------------------------------------------
            // calculate propagation delay, as readout side the side with
            // negative local
            // position along the wire is taken
 
            driftTime += propagation_delay;  // add prop time
            ATH_MSG_VERBOSE("Position along wire:  " << position_along_wire << " propagation delay:  " << propagation_delay
                                                     << " new driftTime " << driftTime);
        }
 
        // add tof + bunch time
        if (m_useTof) {
            driftTime += globalHitTime;
            ATH_MSG_VERBOSE("Time off Flight + bunch offset:  " << globalHitTime << " new driftTime " << driftTime);
        }
        ATH_MSG_DEBUG(m_idHelperSvc->mdtIdHelper().show_to_string(DigitId)
                      << "  Drift time computation " << driftTime << " radius " << driftRadius << " adc " << adc);
 
        // add hit to hit collection
        m_hits.insert(mdt_hit_info(DigitId, driftTime, adc, driftRadius, &phit));
        ATH_MSG_VERBOSE(" handleMDTSimHit() phit-" << &phit << "  hit.localPosition().z() = " << hit.localPosition().z()
                                                   << " driftRadius = " << driftRadius);
 
        // + TWIN TUBES  (A. Koutsman)
        if (m_useTwin) {
            // two chambers in ATLAS are installed with Twin Tubes; in detector coordinates BOL4A13 & BOL4C13; only INNER multilayer(=1) is
            // with twin tubes
            bool BOL4X13 = false;
            // find these two chambers in identifier scheme coordinates as in MdtIdHelper
            if (stationName == "BOL" && std::abs(stationEta) == 4 && stationPhi == 7 && multilayer == 1) { BOL4X13 = true; }
 
            // implement twin tubes digitizing either for all BOL (m_useAllBOLTwin = true) _OR_ only for two chambers really installed
            if ((m_useAllBOLTwin && stationName == "BOL") || BOL4X13) {
                int twin_tube = 0;
                Identifier twin_DigitId{0};
                double twin_sign_driftTime = 0.;
                // twinpair is connected via a HV-jumper with a delay of ~6ns
                constexpr double HV_delay = 6.;
                double twin_tubeLength{0.}, twin_geo_pos_along_wire{0.},
                       twin_sign_pos_along_wire{0.}, twin_sign{-1.};
 
                // twinpair is interconnected with one tube in between, so modulo 4 they are identical
                if (tube % 4 == 1 || tube % 4 == 2)
                    twin_tube = tube + 2;
                else if (tube % 4 == 0 || tube % 4 == 3)
                    twin_tube = tube - 2;
                // construct Atlas identifier from components for the twin
                twin_DigitId = m_idHelperSvc->mdtIdHelper().channelID(stationName, stationEta, stationPhi, multilayer, layer, twin_tube);
                // get twin tube length for propagation delay
                twin_tubeLength = element->tubeLength(twin_DigitId);
 
                // prop delay calculated with respect to the center of the tube
                if (distRO < 0.) twin_sign = 1.;
                twin_geo_pos_along_wire = hit.localPosition().z();
                if (m_useDeformations) { twin_geo_pos_along_wire = newSimhit.localPosition().z(); }
                twin_sign_pos_along_wire = twin_sign * twin_geo_pos_along_wire;
                double twin_propagation_delay = twin_sign * (1. / m_signalSpeed) * twin_geo_pos_along_wire;
 
                // calculate drift-time for twin from prompt driftTime + propagation delay + length of tube + hv-delay
                // ( -2* for propagation_delay, cause prop_delay already in driftTime)
                twin_sign_driftTime = driftTime + twin_tubeLength / m_signalSpeed - 2 * twin_propagation_delay + HV_delay;
 
                // smear the twin time by a gaussian with a stDev given by m_resTwin
                double rand = CLHEP::RandGaussZiggurat::shoot(twinRndmEngine, twin_sign_driftTime, m_resTwin);
                twin_sign_driftTime = rand;
 
                ATH_MSG_DEBUG(" TWIN TUBE stname " << stationName << " steta " << stationEta << " stphi " << stationPhi << " mLayer "
                                                   << multilayer << " layer " << layer << " tube " << tube
                                                   << " signed position along wire = " << twin_sign_pos_along_wire
                                                   << " propagation delay = " << twin_propagation_delay << " drifttime = " << driftTime
                                                   << "    twin_driftTime = " << twin_sign_driftTime
                                                   << "  TWIN time-difference = " << (twin_sign_driftTime - driftTime));
 
                // add twin-hit to hit collection
                m_hits.insert(mdt_hit_info(twin_DigitId, twin_sign_driftTime, adc, driftRadius, &phit));
 
            }  // end select all BOLs or installed chambers
        }      // end if(m_useTwin){
               // - TWIN TUBES   (A. Koutsman)
    } else {
        ATH_MSG_DEBUG(m_idHelperSvc->mdtIdHelper().show_to_string(DigitId) << "  Tube not efficient "
                                                                           << " radius " << driftRadius);
    }
 
    return true;
}

initialize()

StatusCode MdtDigitizationTool::initialize ( )

finaloverridevirtual

Initialize.

Reimplemented from PileUpToolBase.

Definition at line 67 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                           {
    ATH_MSG_INFO("Configuration  MdtDigitizationTool");
    ATH_MSG_INFO("RndmSvc                " << m_rndmSvc);
    ATH_MSG_INFO("DigitizationTool       " << m_digiTool);
    ATH_MSG_INFO("OffsetTDC              " << m_offsetTDC);
    ATH_MSG_INFO("ns2TDCAMT              " << m_ns2TDCAMT);
    ATH_MSG_INFO("ns2TDCHPTDC            " << m_ns2TDCHPTDC);
    ATH_MSG_INFO("ResolutionTDC          " << m_resTDC);
    ATH_MSG_INFO("SignalSpeed            " << m_signalSpeed);
    ATH_MSG_INFO("InputObjectName        " << m_inputObjectName);
    ATH_MSG_INFO("OutputObjectName       " << m_outputObjectKey.key());
    ATH_MSG_INFO("OutputSDOName          " << m_outputSDOKey.key());
    ATH_MSG_INFO("UseAttenuation         " << m_useAttenuation);
    ATH_MSG_INFO("UseTof                 " << m_useTof);
    ATH_MSG_INFO("UseProp                " << m_useProp);
    ATH_MSG_INFO("UseDeformations        " << m_useDeformations);
    ATH_MSG_INFO("UseTimeWindow          " << m_useTimeWindow);
    ATH_MSG_INFO("BunchCountOffset       " << m_bunchCountOffset);
    ATH_MSG_INFO("MatchingWindow         " << m_matchingWindow);
    ATH_MSG_INFO("MaskWindow             " << m_maskWindow);
    ATH_MSG_INFO("DeadTime               " << m_deadTime);
    ATH_MSG_INFO("DiscardEarlyHits       " << m_DiscardEarlyHits);
    ATH_MSG_INFO("CheckSimHits           " << m_checkMDTSimHits);
    ATH_MSG_INFO("UseTwin                " << m_useTwin);
    ATH_MSG_INFO("UseAllBOLTwin          " << m_useAllBOLTwin);
    ATH_MSG_INFO("ResolutionTwinTube     " << m_resTwin);
    ATH_MSG_INFO("DoQballCharge          " << m_DoQballCharge);
    if (!m_useTof) {
        ATH_MSG_INFO("UseCosmicsOffSet1      " << m_useOffSet1);
        ATH_MSG_INFO("UseCosmicsOffSet2      " << m_useOffSet2);
    }
    ATH_MSG_INFO("IncludePileUpTruth     " << m_includePileUpTruth);
    ATH_MSG_INFO("VetoPileUpTruthLinks   " << m_vetoPileUpTruthLinks);
 
    // initialize transient detector store and MuonGeoModel OR MuonDetDescrManager
    if (detStore()->contains<MuonGM::MuonDetectorManager>("Muon")) {
        ATH_CHECK(detStore()->retrieve(m_MuonGeoMgr));
        ATH_MSG_DEBUG("Retrieved MuonGeoModelDetectorManager from StoreGate");
    }
 
    // initialize MuonIdHelperSvc
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    if (m_onlyUseContainerName) { ATH_CHECK(m_mergeSvc.retrieve()); }
 
    // check the input object name
    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 << "'");
 
    // Initialize ReadHandleKey
    ATH_CHECK(m_hitsContainerKey.initialize());
    ATH_CHECK(m_calibDbKey.initialize());
 
    // initialize the output WriteHandleKeys
    ATH_CHECK(m_outputObjectKey.initialize());
    ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputObjectKey);
    ATH_CHECK(m_outputSDOKey.initialize());
    ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputSDOKey);
    ATH_MSG_DEBUG("Output Digits: '" << m_outputObjectKey.key() << "'");
 
    // simulation identifier helper
    m_muonHelper = MdtHitIdHelper::GetHelper(m_idHelperSvc->mdtIdHelper().tubeMax());
 
    // get the r->t conversion tool
    ATH_CHECK(m_digiTool.retrieve());
    ATH_MSG_DEBUG("Retrieved digitization tool!" << m_digiTool);
 
    ATH_CHECK(m_rndmSvc.retrieve());
    ATH_CHECK(m_readKey.initialize(!m_readKey.empty()));
    return StatusCode::SUCCESS;
}

insideMaskWindow()

bool MdtDigitizationTool::insideMaskWindow ( double time ) const

private

Definition at line 801 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                            {
    if (m_useTimeWindow)
        if (time < static_cast<double>(m_bunchCountOffset) - m_maskWindow || time > m_bunchCountOffset) {
            ATH_MSG_VERBOSE("hit outside MaskWindow " << time);
            return false;
        }
    return true;
}

insideMatchingWindow()

bool MdtDigitizationTool::insideMatchingWindow ( double time ) const

private

Definition at line 792 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                {
    if (m_useTimeWindow)
        if (time < m_bunchCountOffset || time > static_cast<double>(m_bunchCountOffset) + m_matchingWindow) {
            ATH_MSG_VERBOSE("hit outside MatchingWindow " << time);
            return false;
        }
    return true;
}

mergeEvent()

StatusCode MdtDigitizationTool::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 243 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                  {
    ATH_MSG_DEBUG("MdtDigitizationTool::in mergeEvent()");
 
    // create and record the Digit container in StoreGate
    SG::WriteHandle<MdtDigitContainer> digitContainer(m_outputObjectKey, ctx);
    ATH_CHECK(digitContainer.record(std::make_unique<MdtDigitContainer>(m_idHelperSvc->mdtIdHelper().module_hash_max())));
    ATH_MSG_DEBUG("Recorded MdtDigitContainer called " << digitContainer.name() << " in store " << digitContainer.store());
 
    // create and record the SDO container in StoreGate
    SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDOKey, ctx);
    ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
    ATH_MSG_DEBUG("Recorded MuonSimDataCollection called " << sdoContainer.name() << " in store " << sdoContainer.store());
 
    Collections_t collections;
    StatusCode status = doDigitization(ctx, collections, sdoContainer.ptr());
    if (status.isFailure()) { ATH_MSG_ERROR("doDigitization Failed"); }
 
    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) );
      }
    }
 
    // Clean-up
    std::vector<MDTSimHitCollection*>::iterator MDTHitColl = m_MDTHitCollList.begin();
    std::vector<MDTSimHitCollection*>::iterator MDTHitCollEnd = m_MDTHitCollList.end();
    while (MDTHitColl != MDTHitCollEnd) {
        delete (*MDTHitColl);
        ++MDTHitColl;
    }
    m_MDTHitCollList.clear();
 
    return status;
}

minimumTof()

double MdtDigitizationTool::minimumTof ( Identifier DigitId, const MuonGM::MuonDetectorManager * detMgr ) const

private

Definition at line 775 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                                        {
    if (!m_useTof) return 0.;
 
    // get distance to vertex for tof correction before applying the time window
    double distanceToVertex(0.);
    const MuonGM::MdtReadoutElement* element = detMgr->getMdtReadoutElement(DigitId);
 
    if (!element) {
        ATH_MSG_ERROR("MuonGeoManager does not return valid element for given id!");
    } else {
        distanceToVertex = element->tubePos(DigitId).mag();
    }
    // what about this? does this also need to be 1/m_signalSpeed ?
    ATH_MSG_DEBUG("minimumTof calculated " << distanceToVertex * s_inv_c_light);
    return distanceToVertex * s_inv_c_light;
}

prepareEvent()

StatusCode MdtDigitizationTool::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 143 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                             {
    ATH_MSG_DEBUG("MdtDigitizationTool::prepareEvent() called for " << nInputEvents << " input events");
 
    m_MDTHitCollList.clear();
    m_thpcMDT = std::make_unique<TimedHitCollection<MDTSimHit>>();
 
    return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode MdtDigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

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

Reimplemented from PileUpToolBase.

Definition at line 278 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                           {
    ATH_MSG_DEBUG("MdtDigitizationTool::processAllSubEvents()");
 
    // create and record the Digit container in StoreGate
    SG::WriteHandle<MdtDigitContainer> digitContainer(m_outputObjectKey, ctx);
    ATH_CHECK(digitContainer.record(std::make_unique<MdtDigitContainer>(m_idHelperSvc->mdtIdHelper().module_hash_max())));
    ATH_MSG_DEBUG("Recorded MdtDigitContainer called " << digitContainer.name() << " in store " << digitContainer.store());
 
    // create and record the SDO container in StoreGate
    SG::WriteHandle<MuonSimDataCollection> sdoContainer(m_outputSDOKey, ctx);
    ATH_CHECK(sdoContainer.record(std::make_unique<MuonSimDataCollection>()));
    ATH_MSG_DEBUG("Recorded MuonSimDataCollection called " << sdoContainer.name() << " in store " << sdoContainer.store());
 
    StatusCode status = StatusCode::SUCCESS;
    if (!m_thpcMDT) {
        status = getNextEvent(ctx);
        if (StatusCode::FAILURE == status) {
            ATH_MSG_INFO("There are no MDT hits in this event");
            return status;
        }
    }
 
    Collections_t collections;
    ATH_CHECK(doDigitization(ctx, collections, sdoContainer.ptr()));
 
    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) );
      }
    }
 
    return status;
}

processBunchXing()

StatusCode MdtDigitizationTool::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 152 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx.

                                                                                                                        {
    ATH_MSG_DEBUG("MdtDigitizationTool::processBunchXing() " << bunchXing);
 
    typedef PileUpMergeSvc::TimedList<MDTSimHitCollection>::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() << " MDTSimHitCollection 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) {
        MDTSimHitCollection* hitCollPtr = new MDTSimHitCollection(*iColl->second);
        PileUpTimeEventIndex timeIndex(iColl->first);
 
        ATH_MSG_DEBUG("MDTSimHitCollection found with " << hitCollPtr->size() << " hits");
        ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time() << " index: " << timeIndex.index() << " type: " << timeIndex.type());
 
        m_thpcMDT->insert(timeIndex, hitCollPtr);
        m_MDTHitCollList.push_back(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.

{ 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_bunchCountOffset

Gaudi::Property<double> MdtDigitizationTool::m_bunchCountOffset {this, "BunchCountOffset", -200., "Bunch crossing offset"}

private

Definition at line 170 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "BunchCountOffset", -200., "Bunch crossing offset"};

m_calibDbKey

SG::ReadCondHandleKey<MuonCalib::MdtCalibDataContainer> MdtDigitizationTool::m_calibDbKey

protected

Initial value:

{this, "CalibDataKey", "MdtCalibConstants",
                                                                       "Conditions object containing the calibrations"}

Definition at line 215 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

                                                                    {this, "CalibDataKey", "MdtCalibConstants",
                                                                       "Conditions object containing the calibrations"};

m_checkMDTSimHits

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

private

Definition at line 158 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

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

m_deadTime

Gaudi::Property<double> MdtDigitizationTool::m_deadTime {this, "DeadTime", 700., "MDT drift tube dead time"}

private

Definition at line 173 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "DeadTime", 700., "MDT drift tube dead time"};

m_digiTool

ToolHandle<IMDT_DigitizationTool> MdtDigitizationTool::m_digiTool

private

Initial value:

{this, "DigitizationTool", "MDT_Response_DigiTool",
                                                 "Tool which handle the digitization process"}

Definition at line 144 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

                                                {this, "DigitizationTool", "MDT_Response_DigiTool",
                                                 "Tool which handle the digitization process"};

m_DiscardEarlyHits

Gaudi::Property<bool> MdtDigitizationTool::m_DiscardEarlyHits {this, "DiscardEarlyHits", true, ""}

private

Definition at line 174 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "DiscardEarlyHits", true, ""};

m_DoQballCharge

Gaudi::Property<bool> MdtDigitizationTool::m_DoQballCharge {this, "DoQballCharge", false, "dEdx for Qballs with account of electric charge"}

private

Definition at line 185 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "DoQballCharge", false, "dEdx for Qballs with account of electric charge"};

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

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

Definition at line 54 of file PileUpToolBase.h.

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

m_hits

MDT_SortedHitVector MdtDigitizationTool::m_hits

private

Definition at line 135 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

m_hitsContainerKey

SG::ReadHandleKey<MDTSimHitCollection> MdtDigitizationTool::m_hitsContainerKey {this, "InputObjectName", "MDT_Hits", ""}

protected

Definition at line 206 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "InputObjectName", "MDT_Hits", ""};  // name of the input objects

m_idHelperSvc

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

private

Definition at line 137 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

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

m_includePileUpTruth

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

private

Definition at line 191 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

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

m_inputObjectName

std::string MdtDigitizationTool::m_inputObjectName {""}

protected

Definition at line 207 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{""};

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

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

Definition at line 56 of file PileUpToolBase.h.

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

m_maskWindow

Gaudi::Property<double> MdtDigitizationTool::m_maskWindow {this, "MaskWindow", 250., "Masked window"}

private

Definition at line 172 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "MaskWindow", 250., "Masked window"};

m_matchingWindow

Gaudi::Property<double> MdtDigitizationTool::m_matchingWindow {this, "MatchingWindow", 1000., "Matching window"}

private

Definition at line 171 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "MatchingWindow", 1000., "Matching window"};

m_MDTHitCollList

std::vector<MDTSimHitCollection*> MdtDigitizationTool::m_MDTHitCollList

private

Definition at line 146 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

m_mergeSvc

ServiceHandle<PileUpMergeSvc> MdtDigitizationTool::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}

protected

Definition at line 203 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};  // Pile up service

m_MuonGeoMgr

const MuonGM::MuonDetectorManager* MdtDigitizationTool::m_MuonGeoMgr {}

private

Definition at line 142 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{};

m_muonHelper

const MdtHitIdHelper* MdtDigitizationTool::m_muonHelper {}

private

Definition at line 138 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{};

m_ns2TDCAMT

Gaudi::Property<double> MdtDigitizationTool::m_ns2TDCAMT {this, "ns2TDCAMT", 0.78125, "Conversion factor TDC/ns for AMT chips"}

private

Definition at line 152 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "ns2TDCAMT", 0.78125, "Conversion factor TDC/ns for AMT chips"};

m_ns2TDCHPTDC

Gaudi::Property<double> MdtDigitizationTool::m_ns2TDCHPTDC {this, "ns2TDCHPTDC", 0.1953125, "Conversion factor TDC/ns for HPTDC chips"}

private

Definition at line 153 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "ns2TDCHPTDC", 0.1953125, "Conversion factor TDC/ns for HPTDC chips"};

m_offsetTDC

Gaudi::Property<double> MdtDigitizationTool::m_offsetTDC {this, "OffsetTDC", 800., "TDC offset used if no calibration data is found"}

private

Definition at line 149 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "OffsetTDC", 800., "TDC offset used if no calibration data is found"};

m_onlyUseContainerName

BooleanProperty MdtDigitizationTool::m_onlyUseContainerName

protected

Initial value:

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

Definition at line 204 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

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

m_outputObjectKey

SG::WriteHandleKey<MdtDigitContainer> MdtDigitizationTool::m_outputObjectKey

protected

Initial value:

{this, "OutputObjectName", "MDT_DIGITS",
                                                            "WriteHandleKey for Output MdtDigitContainer"}

Definition at line 208 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

                                                         {this, "OutputObjectName", "MDT_DIGITS",
                                                            "WriteHandleKey for Output MdtDigitContainer"};

m_outputSDOKey

SG::WriteHandleKey<MuonSimDataCollection> MdtDigitizationTool::m_outputSDOKey

protected

Initial value:

{this, "OutputSDOName", "MDT_SDO",
                                                             "WriteHandleKey for Output MuonSimDataCollection"}

Definition at line 210 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

                                                          {this, "OutputSDOName", "MDT_SDO",
                                                             "WriteHandleKey for Output MuonSimDataCollection"};

m_readKey

SG::ReadCondHandleKey<MdtCondDbData> MdtDigitizationTool::m_readKey {this, "ReadKey", "MdtCondDbData", "Key of MdtCondDbData"}

protected

Definition at line 218 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "ReadKey", "MdtCondDbData", "Key of MdtCondDbData"};

m_resTDC

Gaudi::Property<double> MdtDigitizationTool::m_resTDC {this, "ResolutionTDC", 0.5, "TDC resolution"}

private

Definition at line 154 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "ResolutionTDC", 0.5, "TDC resolution"};

m_resTwin

Gaudi::Property<double> MdtDigitizationTool::m_resTwin {this, "ResolutionTwinTube", 1.05, "Twin Tube resolution"}

private

Definition at line 166 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "ResolutionTwinTube", 1.05, "Twin Tube resolution"};

m_rndmSvc

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

protected

Definition at line 213 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

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

m_signalSpeed

Gaudi::Property<double> MdtDigitizationTool::m_signalSpeed {this, "SignalSpeed", 0.85*Gaudi::Units::c_light}

private

Definition at line 150 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "SignalSpeed", 0.85*Gaudi::Units::c_light};

m_t0ShiftTuning

Gaudi::Property<double> MdtDigitizationTool::m_t0ShiftTuning {this,"TunedT0Shift",-17.,"Fine tuned t0 shift value in ns"}

private

Definition at line 155 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this,"TunedT0Shift",-17.,"Fine tuned t0 shift value in ns"};

m_thpcMDT

std::unique_ptr<TimedHitCollection<MDTSimHit> > MdtDigitizationTool::m_thpcMDT {}

private

Definition at line 188 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{};  // the hits

m_useAllBOLTwin

Gaudi::Property<bool> MdtDigitizationTool::m_useAllBOLTwin {this, "UseAllBOLTwin", false, ""}

private

Definition at line 165 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseAllBOLTwin", false, ""};

m_useAttenuation

Gaudi::Property<bool> MdtDigitizationTool::m_useAttenuation {this, "UseAttenuation", false, ""}

private

Definition at line 160 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseAttenuation", false, ""};

m_useDeformations

Gaudi::Property<bool> MdtDigitizationTool::m_useDeformations {this, "UseDeformations", false, ""}

private

Definition at line 182 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseDeformations", false, ""};

m_useOffSet1

Gaudi::Property<bool> MdtDigitizationTool::m_useOffSet1 {this, "UseOffSet1", true, ""}

private

Definition at line 177 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseOffSet1", true, ""};

m_useOffSet2

Gaudi::Property<bool> MdtDigitizationTool::m_useOffSet2 {this, "UseOffSet2", true, ""}

private

Definition at line 178 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseOffSet2", true, ""};

m_useProp

Gaudi::Property<bool> MdtDigitizationTool::m_useProp {this, "UseProp", true, ""}

private

Definition at line 161 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseProp", true, ""};

m_useTimeWindow

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

private

Definition at line 169 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseTimeWindow", true, ""};

m_useTof

Gaudi::Property<bool> MdtDigitizationTool::m_useTof {this, "UseTof", true, "Option for the tof calculation"}

private

Definition at line 159 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseTof", true, "Option for the tof calculation"};

m_useTwin

Gaudi::Property<bool> MdtDigitizationTool::m_useTwin {this, "UseTwin", false, ""}

private

Definition at line 164 of file MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h.

{this, "UseTwin", false, ""};

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

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

Definition at line 58 of file PileUpToolBase.h.

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

---

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

• MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.h
• MuonDigitization/MDT_Digitization/src/MdtDigitizationTool.cxx