TgcDigitizationTool Class Reference

#include <TgcDigitizationTool.h>

Inheritance diagram for TgcDigitizationTool:

Public Member Functions
	TgcDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
	Initialize.
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	called for each active bunch-crossing to process current SubEvents bunchXing is in ns
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	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.
virtual StatusCode	finalize () override final
	Finalize.

Protected Attributes
ServiceHandle< PileUpMergeSvc >	m_mergeSvc
ServiceHandle< IAthRNGSvc >	m_rndmSvc

Private Member Functions
StatusCode	getNextEvent (const EventContext &ctx)
	Get next event and extract collection of hit collections.
StatusCode	digitizeCore (const EventContext &ctx)
	Core part of digitization used by processAllSubEvents and mergeEvent.

Private Attributes
const TgcHitIdHelper *	m_hitIdHelper {}
const TgcIdHelper *	m_idHelper {}
const MuonGM::MuonDetectorManager *	m_mdManager {}
TgcDigitMaker *	m_digitizer {}
TimedHitCollection< TGCSimHit > *	m_thpcTGC {}
std::list< TGCSimHitCollection * >	m_TGCHitCollList
Gaudi::Property< bool >	m_onlyUseContainerName
Gaudi::Property< bool >	m_doFourBunchDigitization
SG::ReadHandleKey< TGCSimHitCollection >	m_hitsContainerKey
std::string	m_inputHitCollectionName {""}
SG::ReadCondHandleKey< TgcDigitASDposData >	m_readCondKey_ASDpos
SG::ReadCondHandleKey< TgcDigitTimeOffsetData >	m_readCondKey_TimeOffset
SG::ReadCondHandleKey< TgcDigitCrosstalkData >	m_readCondKey_Crosstalk
SG::WriteHandleKey< TgcDigitContainer >	m_outputDigitCollectionKey
SG::WriteHandleKey< MuonSimDataCollection >	m_outputSDO_CollectionKey
Gaudi::Property< bool >	m_includePileUpTruth

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

Definition at line 41 of file TgcDigitizationTool.h.

Constructor & Destructor Documentation

TgcDigitizationTool()

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

Definition at line 23 of file TgcDigitizationTool.cxx.

    : PileUpToolBase(type, name, parent) {}

Member Function Documentation

digitizeCore()

StatusCode TgcDigitizationTool::digitizeCore ( const EventContext & ctx )

private

Core part of digitization used by processAllSubEvents and mergeEvent.

NOTE:

Since not every hit might end up resulting in a digit, this construction might take place after the hit loop in a loop of its own!

Definition at line 252 of file TgcDigitizationTool.cxx.

                                                                    {
 
    ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
    rngWrapper->setSeed(name(), ctx);
    CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);
 
    // create and record the Digit container in StoreGate
    SG::WriteHandle<TgcDigitContainer> digitContainer(
        m_outputDigitCollectionKey, ctx);
    ATH_CHECK(digitContainer.record(
        std::make_unique<TgcDigitContainer>(m_idHelper->module_hash_max())));
    ATH_MSG_DEBUG("TgcDigitContainer 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("TgcSDOCollection recorded in StoreGate.");
 
    // get the iterator pairs for this DetEl
    // iterate over hits and fill id-keyed drift time map
    IdContext tgcContext = m_idHelper->module_context();
 
    // Read needed conditions data
    const TgcDigitASDposData* ASDpos{};
    if (!m_readCondKey_ASDpos.empty()) {
        SG::ReadCondHandle<TgcDigitASDposData> readHandle_ASDpos{
            m_readCondKey_ASDpos, ctx};
        ASDpos = readHandle_ASDpos.cptr();
    } else {
        ATH_MSG_ERROR(
            "ASD Position parameters /TGC/DIGIT/ASDPOS must be available for "
            "TGC_Digitization. Check the configuration!");
    }
    const TgcDigitTimeOffsetData* TOffset{};
    if (!m_readCondKey_TimeOffset.empty()) {
        SG::ReadCondHandle<TgcDigitTimeOffsetData> readHandle_TimeOffset{
            m_readCondKey_TimeOffset, ctx};
        TOffset = readHandle_TimeOffset.cptr();
    } else {
        ATH_MSG_ERROR(
            "Timing Offset parameters /TGC/DIGIT/TOFFSET must be available for "
            "TGC_Digitization. Check the configuration!");
    }
    const TgcDigitCrosstalkData* Crosstalk{};
    if (!m_readCondKey_Crosstalk.empty()) {
        SG::ReadCondHandle<TgcDigitCrosstalkData> readHandle_Crosstalk{
            m_readCondKey_Crosstalk, ctx};
        Crosstalk = readHandle_Crosstalk.cptr();
    } else {
        ATH_MSG_WARNING(
            "/TGC/DIGIT/XTALK is not provided. Probabilities of TGC channel "
            "crosstalk will be zero.");
    }
 
    std::vector<std::unique_ptr<TgcDigitCollection> > collections;
 
    TimedHitCollection<TGCSimHit>::const_iterator i, e;
    while (m_thpcTGC->nextDetectorElement(i, e)) {
        ATH_MSG_DEBUG("TgcDigitizationTool::digitizeCore next element");
 
        // Loop over the hits:
        while (i != e) {
            TimedHitPtr<TGCSimHit> phit = *i++;
            const TGCSimHit& hit = *phit;
            double globalHitTime = hitTime(phit);
            double tof = phit->globalTime();
            TgcDigitCollection* digiHits = m_digitizer->executeDigi(
                &hit, globalHitTime, ASDpos, TOffset, Crosstalk, rndmEngine);
 
            if (!digiHits)
                continue;
 
            TgcDigitCollection::const_iterator it_digiHits;
            for (it_digiHits = digiHits->begin();
                 it_digiHits != digiHits->end(); ++it_digiHits) {

 
                Identifier newDigiId = (*it_digiHits)->identify();
                uint16_t newBcTag = (*it_digiHits)->bcTag();
                Identifier elemId = m_idHelper->elementID(newDigiId);
 
                TgcDigitCollection* digitCollection = nullptr;
 
                IdentifierHash coll_hash;
                if (m_idHelper->get_hash(elemId, coll_hash, &tgcContext)) {
                    ATH_MSG_WARNING(
                        "Unable to get TGC hash id from TGC Digit collection "
                        << "context begin_index = " << tgcContext.begin_index()
                        << " context end_index  = " << tgcContext.end_index()
                        << " the identifier is ");
                    elemId.show();
                }
 
                // make new TgcDigit and record it in StoreGate
                auto newDigit = std::make_unique<TgcDigit>(newDigiId, newBcTag);
 
                // record the digit container in StoreGate
                bool duplicate = false;
                if (coll_hash >= collections.size()) {
                    collections.resize(coll_hash + 1);
                }
                digitCollection = collections[coll_hash].get();
                if (nullptr == digitCollection) {
                    collections[coll_hash] =
                        std::make_unique<TgcDigitCollection>(elemId, coll_hash);
                    digitCollection = collections[coll_hash].get();
                    ATH_MSG_DEBUG("Digit Id(1st) = "
                                  << m_idHelper->show_to_string(newDigiId)
                                  << " BC tag = " << newBcTag
                                  << " Coll. key = " << coll_hash);
                    digitCollection->push_back(std::move(newDigit));
                } else {
                    // to avoid to store digits with identical id
                    TgcDigitCollection::const_iterator it_tgcDigit;
                    for (it_tgcDigit = digitCollection->begin();
                         it_tgcDigit != digitCollection->end(); ++it_tgcDigit) {
                        if (newDigiId == (*it_tgcDigit)->identify() &&
                            newBcTag == (*it_tgcDigit)->bcTag()) {
                            duplicate = true;
                            IdContext context = m_idHelper->channel_context();
                            ATH_MSG_DEBUG("Duplicate digit(removed) = "
                                          << m_idHelper->show_to_string(
                                                 newDigiId, &context)
                                          << " BC tag = " << newBcTag);
                            newDigit.reset();
                            break;
                        }
                    }
                    if (!duplicate) {
                        digitCollection->push_back(std::move(newDigit));
                        ATH_MSG_DEBUG("Digit Id= "
                                      << m_idHelper->show_to_string(newDigiId)
                                      << " BC tag = " << newBcTag);
                    }
                }
 
                if (!duplicate) {
                    static const double invalid_pos = -99999.;
                    Amg::Vector3D gpos(invalid_pos, invalid_pos, invalid_pos);
                    const MuonGM::TgcReadoutElement* tgcChamber =
                        m_mdManager->getTgcReadoutElement(newDigiId);
                    if (tgcChamber) {
                        gpos = tgcChamber->localToGlobalTransf(newDigiId) * hit.localPosition();
                    }
 
                    // fill the SDO collection in StoreGate if not pile-up
                    if (!m_includePileUpTruth &&
                        HepMC::ignoreTruthLink(phit->particleLink(),
                                               m_vetoPileUpTruthLinks)) {
                        continue;
                    }
 
                    // link to MC info
                    // create here deposit for MuonSimData, link and tof
                    std::vector<MuonSimData::Deposit> deposits;
                    deposits.emplace_back(
                                          HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx), // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
                                          MuonMCData(tof, 0));
                    MuonSimData simData(deposits, 0);
                    simData.setPosition(gpos);
                    simData.setTime(hitTime(phit));
                    sdoContainer->insert(std::make_pair(newDigiId, simData));
                }
            }
            delete digiHits;
            digiHits = nullptr;
        }  // while(i != e)
    }      // while(m_thpcTGC->nextDetectorElement(i, e))
 
    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 StatusCode::SUCCESS;
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

finalize()

StatusCode TgcDigitizationTool::finalize ( )

finaloverridevirtual

Finalize.

Definition at line 178 of file TgcDigitizationTool.cxx.

                                         {
    ATH_MSG_DEBUG("finalize.");
 
    delete m_digitizer;
    m_digitizer = nullptr;
 
    return StatusCode::SUCCESS;
}

getNextEvent()

StatusCode TgcDigitizationTool::getNextEvent ( const EventContext & ctx )

private

Get next event and extract collection of hit collections.

Definition at line 189 of file TgcDigitizationTool.cxx.

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

initialize()

StatusCode TgcDigitizationTool::initialize ( )

finaloverridevirtual

Initialize.

Reimplemented from PileUpToolBase.

Definition at line 29 of file TgcDigitizationTool.cxx.

                                           {
    // retrieve MuonDetctorManager from DetectorStore
    ATH_CHECK(detStore()->retrieve(m_mdManager));
    ATH_MSG_DEBUG("Retrieved MuonDetectorManager from DetectorStore.");
 
    if (m_onlyUseContainerName) {
        ATH_CHECK(m_mergeSvc.retrieve());
    }
 
    // initialize the TgcIdHelper
    m_idHelper = m_mdManager->tgcIdHelper();
    if (!m_idHelper) {
        ATH_MSG_WARNING("tgcIdHelper could not be retrieved.");
        return StatusCode::FAILURE;
    }
 
    // TgcHitIdHelper
    m_hitIdHelper = TgcHitIdHelper::GetHelper();
 
    // check the input object name
    if (m_hitsContainerKey.key().empty()) {
        ATH_MSG_FATAL("Property InputObjectName not set !");
        return StatusCode::FAILURE;
    }
    if (m_onlyUseContainerName)
        m_inputHitCollectionName = m_hitsContainerKey.key();
    ATH_MSG_DEBUG("Input objects in container : '" << m_inputHitCollectionName
                                                   << "'");
 
    // Initialize Read(Cond)HandleKey
    ATH_CHECK(m_hitsContainerKey.initialize(true));
    ATH_CHECK(m_readCondKey_ASDpos.initialize(!m_readCondKey_ASDpos.empty()));
    ATH_CHECK(
        m_readCondKey_TimeOffset.initialize(!m_readCondKey_TimeOffset.empty()));
    ATH_CHECK(
        m_readCondKey_Crosstalk.initialize(!m_readCondKey_Crosstalk.empty()));
 
    // initialize the output WriteHandleKeys
    ATH_CHECK(m_outputDigitCollectionKey.initialize());
    ATH_CHECK(m_outputSDO_CollectionKey.initialize());
    ATH_MSG_DEBUG("Output Digits: '" << m_outputDigitCollectionKey.key()
                                     << "'");
 
    ATH_MSG_DEBUG("IncludePileUpTruth: " << m_includePileUpTruth);
    ATH_MSG_DEBUG("VetoPileUpTruthLinks: " << m_vetoPileUpTruthLinks);
 
    // initialize class to execute digitization
    m_digitizer = new TgcDigitMaker(m_hitIdHelper, m_mdManager,
                                    m_doFourBunchDigitization);
    m_digitizer->setLevel(static_cast<MSG::Level>(msgLevel()));
    ATH_CHECK(m_rndmSvc.retrieve());
 
    ATH_CHECK(m_digitizer->initialize());
 
    return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode TgcDigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

called at the end of the subevts loop.

Not (necessarily) able to access SubEvents (IPileUpTool)

Definition at line 142 of file TgcDigitizationTool.cxx.

                                                                  {
    ATH_MSG_DEBUG("TgcDigitizationTool::mergeEvent()");
 
    ATH_CHECK(digitizeCore(ctx));
    // reset the pointer (delete null pointer should be safe)
    delete m_thpcTGC;
    m_thpcTGC = nullptr;
 
    std::list<TGCSimHitCollection*>::iterator TGCHitColl =
        m_TGCHitCollList.begin();
    std::list<TGCSimHitCollection*>::iterator TGCHitCollEnd =
        m_TGCHitCollList.end();
    while (TGCHitColl != TGCHitCollEnd) {
        delete (*TGCHitColl);
        ++TGCHitColl;
    }
    m_TGCHitCollList.clear();
 
    return StatusCode::SUCCESS;
}

prepareEvent()

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

finaloverridevirtual

Definition at line 87 of file TgcDigitizationTool.cxx.

                                                           {
    m_TGCHitCollList.clear();
    m_thpcTGC = new TimedHitCollection<TGCSimHit>();
 
    return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode TgcDigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

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

Reads GEANT4 hits from StoreGate in each of detector components corresponding to TGC modules which are triplets or doublets. A triplet has tree sensitive volumes and a double has two. This method calls TgcDigitMaker::executeDigi, which digitizes every hit, for every readout element, i.e., a sensitive volume of a chamber.

Reimplemented from PileUpToolBase.

Definition at line 164 of file TgcDigitizationTool.cxx.

                                                                           {
    ATH_MSG_DEBUG("TgcDigitizationTool::processAllSubEvents()");
    // merging of the hit collection in getNextEvent method
    if (!m_thpcTGC) {
        ATH_CHECK(getNextEvent(ctx));
    }
    ATH_CHECK(digitizeCore(ctx));
    // reset the pointer (delete null pointer should be safe)
    delete m_thpcTGC;
    m_thpcTGC = nullptr;
    return StatusCode::SUCCESS;
}

processBunchXing()

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

finaloverridevirtual

called for each active bunch-crossing to process current SubEvents bunchXing is in ns

Reimplemented from PileUpToolBase.

Definition at line 96 of file TgcDigitizationTool.cxx.

                                                                              {
    ATH_MSG_DEBUG("TgcDigitizationTool::processBunchXing() " << bunchXing);
 
    typedef PileUpMergeSvc::TimedList<TGCSimHitCollection>::type
        TimedHitCollList;
    TimedHitCollList hitCollList;
 
    if (!(m_mergeSvc
              ->retrieveSubSetEvtData(m_inputHitCollectionName, hitCollList,
                                      bunchXing, bSubEvents, eSubEvents)
              .isSuccess()) &&
        hitCollList.empty()) {
        ATH_MSG_ERROR("Could not fill TimedHitCollList");
        return StatusCode::FAILURE;
    } else {
        ATH_MSG_VERBOSE(hitCollList.size()
                        << " TGCSimHitCollection with key "
                        << m_inputHitCollectionName << " found");
    }
 
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
 
    // Iterating over the list of collections
    for (; iColl != endColl; ++iColl) {
 
        TGCSimHitCollection* hitCollPtr =
            new TGCSimHitCollection(*iColl->second);
        PileUpTimeEventIndex timeIndex(iColl->first);
 
        ATH_MSG_DEBUG("TGCSimHitCollection found with " << hitCollPtr->size()
                                                        << " hits");
        ATH_MSG_VERBOSE("time index info. time: "
                        << timeIndex.time() << " index: " << timeIndex.index()
                        << " type: " << timeIndex.type());
 
        m_thpcTGC->insert(timeIndex, hitCollPtr);
        m_TGCHitCollList.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_digitizer

TgcDigitMaker* TgcDigitizationTool::m_digitizer {}

private

Definition at line 90 of file TgcDigitizationTool.h.

{};

m_doFourBunchDigitization

Gaudi::Property<bool> TgcDigitizationTool::m_doFourBunchDigitization

private

Initial value:

{
        this, "FourBunchDigitization", true,
        "Do the four bunch digitization since Run-3"}

Definition at line 98 of file TgcDigitizationTool.h.

                                                 {
        this, "FourBunchDigitization", true,
        "Do the four bunch digitization since Run-3"};

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_hitIdHelper

const TgcHitIdHelper* TgcDigitizationTool::m_hitIdHelper {}

private

Definition at line 87 of file TgcDigitizationTool.h.

{};

m_hitsContainerKey

SG::ReadHandleKey<TGCSimHitCollection> TgcDigitizationTool::m_hitsContainerKey

private

Initial value:

{
        this, "InputObjectName", "TGC_Hits", "name of the input object"}

Definition at line 101 of file TgcDigitizationTool.h.

                                                           {
        this, "InputObjectName", "TGC_Hits", "name of the input object"};

m_idHelper

const TgcIdHelper* TgcDigitizationTool::m_idHelper {}

private

Definition at line 88 of file TgcDigitizationTool.h.

{};

m_includePileUpTruth

Gaudi::Property<bool> TgcDigitizationTool::m_includePileUpTruth

private

Initial value:

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

Definition at line 123 of file TgcDigitizationTool.h.

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

m_inputHitCollectionName

std::string TgcDigitizationTool::m_inputHitCollectionName {""}

private

Definition at line 103 of file TgcDigitizationTool.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_mdManager

const MuonGM::MuonDetectorManager* TgcDigitizationTool::m_mdManager {}

private

Definition at line 89 of file TgcDigitizationTool.h.

{};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> TgcDigitizationTool::m_mergeSvc

protected

Initial value:

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

Definition at line 81 of file TgcDigitizationTool.h.

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

m_onlyUseContainerName

Gaudi::Property<bool> TgcDigitizationTool::m_onlyUseContainerName

private

Initial value:

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

Definition at line 94 of file TgcDigitizationTool.h.

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

m_outputDigitCollectionKey

SG::WriteHandleKey<TgcDigitContainer> TgcDigitizationTool::m_outputDigitCollectionKey

private

Initial value:

{
        this, "OutputObjectName", "TGC_DIGITS",
        "WriteHandleKey for Output TgcDigitContainer"}

Definition at line 113 of file TgcDigitizationTool.h.

                                                                  {
        this, "OutputObjectName", "TGC_DIGITS",
        "WriteHandleKey for Output TgcDigitContainer"};  // name of the output

m_outputSDO_CollectionKey

SG::WriteHandleKey<MuonSimDataCollection> TgcDigitizationTool::m_outputSDO_CollectionKey

private

Initial value:

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

Definition at line 117 of file TgcDigitizationTool.h.

                                                                     {
        this, "OutputSDOName", "TGC_SDO",
        "WriteHandleKey for Output MuonSimDataCollection"};  // name of the

m_readCondKey_ASDpos

SG::ReadCondHandleKey<TgcDigitASDposData> TgcDigitizationTool::m_readCondKey_ASDpos

private

Initial value:

{
        this, "TGCDigitASDposKey", "",
        "ReadCondHandleKey for TGCDigitASDposData"}

Definition at line 104 of file TgcDigitizationTool.h.

                                                                {
        this, "TGCDigitASDposKey", "",
        "ReadCondHandleKey for TGCDigitASDposData"};

m_readCondKey_Crosstalk

SG::ReadCondHandleKey<TgcDigitCrosstalkData> TgcDigitizationTool::m_readCondKey_Crosstalk

private

Initial value:

{
        this, "TGCDigitCrosstalkKey", "",
        "ReadCondHandleKey for TGCDigitCrosstalkData"}

Definition at line 110 of file TgcDigitizationTool.h.

                                                                      {
        this, "TGCDigitCrosstalkKey", "",
        "ReadCondHandleKey for TGCDigitCrosstalkData"};

m_readCondKey_TimeOffset

SG::ReadCondHandleKey<TgcDigitTimeOffsetData> TgcDigitizationTool::m_readCondKey_TimeOffset

private

Initial value:

{
        this, "TGCDigitTimeOffsetKey", "",
        "ReadCondHandleKey for TGCDigitTimeOffsetData"}

Definition at line 107 of file TgcDigitizationTool.h.

                                                                        {
        this, "TGCDigitTimeOffsetKey", "",
        "ReadCondHandleKey for TGCDigitTimeOffsetData"};

m_rndmSvc

ServiceHandle<IAthRNGSvc> TgcDigitizationTool::m_rndmSvc

protected

Initial value:

{this, "RndmSvc", "AthRNGSvc",
                                        ""}

Definition at line 83 of file TgcDigitizationTool.h.

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

m_TGCHitCollList

std::list<TGCSimHitCollection*> TgcDigitizationTool::m_TGCHitCollList

private

Definition at line 92 of file TgcDigitizationTool.h.

m_thpcTGC

TimedHitCollection<TGCSimHit>* TgcDigitizationTool::m_thpcTGC {}

private

Definition at line 91 of file TgcDigitizationTool.h.

{};

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

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

Definition at line 58 of file PileUpToolBase.h.

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

---

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

• TgcDigitizationTool.h
• TgcDigitizationTool.cxx