#include <sTgcDigitizationTool.h>

Inheritance diagram for sTgcDigitizationTool:

Collaboration diagram for sTgcDigitizationTool:

Classes
class	sTgcSimDigitData

Public Types
using	sTgcSimDigitVec = std::vector< sTgcSimDigitData >

using	sTgcSimDigitCont = std::vector< sTgcSimDigitVec >

using	DigiConditions = sTgcDigitMaker::DigiConditions

using	sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec

using	sTgcDigtCont = std::vector< sTgcDigitVec >

Public Member Functions
	sTgcDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	initialize ()
	Initialize. More...

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

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

StatusCode	mergeEvent (const EventContext &ctx)

virtual StatusCode	processAllSubEvents (const EventContext &ctx)
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents. More...

StatusCode	digitize (const EventContext &ctx)
	Just calls processAllSubEvents - leaving for back-compatibility (IMuonDigitizationTool) More...

Private Member Functions
CLHEP::HepRandomEngine *	getRandomEngine (const std::string &streamName, const EventContext &ctx) const

template<class CondType >
StatusCode	retrieveCondData (const EventContext &ctx, SG::ReadCondHandleKey< CondType > &key, const CondType *&condPtr) const

StatusCode	getNextEvent (const EventContext &ctx)
	Get next event and extract collection of hit collections. More...

StatusCode	doDigitization (const EventContext &ctx)
	Core part of digitization use by mergeEvent (IPileUpTool) and digitize (IMuonDigitizationTool) More...

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

StatusCode	processDigitsWithVMM (const EventContext &ctx, const DigiConditions &digiCond, sTgcSimDigitCont &unmergedContainer, const double vmmDeadTime, const bool isNeighbourOn, sTgcDigtCont &outDigitContainer, MuonSimDataCollection &outSdoContainer) const

sTgcSimDigitVec	processDigitsWithVMM (const EventContext &ctx, const DigiConditions &digiCond, const double vmmDeadTime, sTgcSimDigitVec &unmergedDigits, const bool isNeighborOn) const

Static Private Member Functions
static uint16_t	bcTagging (const double digittime)

Private Attributes
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}

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

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

SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_detMgrKey

SG::ReadCondHandleKey< Muon::DigitEffiData >	m_effiKey

std::unique_ptr< sTgcDigitMaker >	m_digitizer {}

std::unique_ptr< TimedHitCollection< sTGCSimHit > >	m_thpcsTGC {}

std::vector< std::unique_ptr< sTGCSimHitCollection > >	m_STGCHitCollList {}

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

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

SG::WriteHandleKey< sTgcDigitContainer >	m_outputDigitCollectionKey {this,"OutputObjectName","sTGC_DIGITS","WriteHandleKey for Output sTgcDigitContainer"}

SG::WriteHandleKey< MuonSimDataCollection >	m_outputSDO_CollectionKey {this,"OutputSDOName","sTGC_SDO","WriteHandleKey for Output MuonSimDataCollection"}

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

Gaudi::Property< bool >	m_doToFCorrection {this,"doToFCorrection",false}

Gaudi::Property< bool >	m_doEfficiencyCorrection {this,"doEfficiencyCorrection",false}

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

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

Gaudi::Property< bool >	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}

SG::ReadHandleKey< sTGCSimHitCollection >	m_hitsContainerKey {this, "InputObjectName", "sTGC_Hits", "name of the input object"}

std::string	m_inputObjectName {""}

Gaudi::Property< bool >	m_useCondThresholds {this, "useCondThresholds", false, "Use conditions data to get VMM charge threshold values"}

SG::ReadCondHandleKey< NswCalibDbThresholdData >	m_condThrshldsKey {this, "CondThrshldsKey", "NswCalibDbThresholdData", "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"}

Gaudi::Property< int >	m_doChannelTypes {this,"doChannelTypes",3}

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

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

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

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

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

Gaudi::Property< double >	m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV,"Minimum energy deposit for hit to be digitized"}

Gaudi::Property< double >	m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV,"Minimum kinetic energy for electron hit to be digitized"}

Gaudi::Property< double >	m_chargeThreshold {this,"chargeThreshold", 0.002, "vmm charge threshold in pC, need to set useCondThresholds to false if one wants to use this threshold value otherwise the one from the conditions database is used"}

Gaudi::Property< double >	m_stripChargeScale {this, "stripChargeScale",0.4, "strip charge scale"}

const double	m_timeJitterElectronicsStrip {2.f}

const double	m_timeJitterElectronicsPad {2.f}

const double	m_hitTimeMergeThreshold {30.f}

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing More...

virtual StatusCode	processAllSubEvents (const EventContext &ctx)=0
	dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...

virtual bool	filterPassed () const override
	dummy implementation of passing filter More...

virtual void	resetFilter () override
	dummy implementation of filter reset More...

Gaudi::Property< int >	m_firstXing

Gaudi::Property< int >	m_lastXing

Gaudi::Property< int >	m_vetoPileUpTruthLinks

bool	m_filterPassed {true}

Detailed Description

Class methods and properties

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

Definition at line 50 of file sTgcDigitizationTool.h.

Member Typedef Documentation

◆ DigiConditions

using sTgcDigitizationTool::DigiConditions = sTgcDigitMaker::DigiConditions

Definition at line 113 of file sTgcDigitizationTool.h.

◆ sTgcDigitVec

using sTgcDigitizationTool::sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec

Definition at line 114 of file sTgcDigitizationTool.h.

◆ sTgcDigtCont

using sTgcDigitizationTool::sTgcDigtCont = std::vector<sTgcDigitVec>

Definition at line 115 of file sTgcDigitizationTool.h.

◆ sTgcSimDigitCont

using sTgcDigitizationTool::sTgcSimDigitCont = std::vector<sTgcSimDigitVec>

Definition at line 111 of file sTgcDigitizationTool.h.

◆ sTgcSimDigitVec

using sTgcDigitizationTool::sTgcSimDigitVec = std::vector<sTgcSimDigitData>

Definition at line 110 of file sTgcDigitizationTool.h.

Constructor & Destructor Documentation

◆ sTgcDigitizationTool()

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

Definition at line 52 of file sTgcDigitizationTool.cxx.

52 :

53 PileUpToolBase(type, name, parent) {}

Member Function Documentation

◆ bcTagging()

uint16_t sTgcDigitizationTool::bcTagging ( const double digittime )

staticprivate

Definition at line 545 of file sTgcDigitizationTool.cxx.

                                                                {
  
   uint16_t bctag = 0;
  
    int bunchInteger{0};  //Define the absolute distance from t0 in units of BX
    if(digitTime > 0) bunchInteger = (int)(abs(digitTime/25.0));  //absolute bunch for future bunches
    else bunchInteger = (int)(abs(digitTime/25.0)) + 1; //The absolute bunch for negative time needs to be shifted by 1 as there is no negative zero bunch
    bctag = (bctag | bunchInteger);  //Store bitwise the abs(BX).  This should be equivalent to regular variable assignment
    if(digitTime < 0) bctag = ~bctag;  //If from a PREVIOUS BX, apply bitwise negation
  
   return bctag;
 }

◆ digitize()

StatusCode sTgcDigitizationTool::digitize ( const EventContext & ctx )

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

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

Definition at line 242 of file sTgcDigitizationTool.cxx.

                                                                  {
   return this->processAllSubEvents(ctx);
 }

◆ doDigitization()

StatusCode sTgcDigitizationTool::doDigitization ( const EventContext & ctx )

private

Core part of digitization use by mergeEvent (IPileUpTool) and digitize (IMuonDigitizationTool)

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

Resize the container accordingly

Definition at line 277 of file sTgcDigitizationTool.cxx.

                                                                        {
  
   ATH_MSG_DEBUG ("sTgcDigitizationTool::doDigitization()" );
   const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
   
   sTgcDigitMaker::DigiConditions digitCond{};
   digitCond.rndmEngine = getRandomEngine(m_rndmEngineName, ctx);
   ATH_CHECK(retrieveCondData(ctx, m_detMgrKey, digitCond.detMgr));
   ATH_CHECK(retrieveCondData(ctx, m_effiKey, digitCond.efficiencies));
   ATH_CHECK(retrieveCondData(ctx, m_condThrshldsKey , digitCond.thresholdData));
   
  
   // create and record the Digit container in StoreGate
   SG::WriteHandle<sTgcDigitContainer> digitContainer(m_outputDigitCollectionKey, ctx);
   ATH_CHECK(digitContainer.record(std::make_unique<sTgcDigitContainer>(idHelper.module_hash_max())));
   ATH_MSG_DEBUG ( "sTgcDigitContainer 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( "sTgcSDOCollection recorded in StoreGate." );
  
  
   TimedHitCollection<sTGCSimHit>::const_iterator i, e;
  
   // Collections of digits by digit type associated with a detector element
   sTgcSimDigitCont unmergedPadDigits{}, unmergedStripDigits{}, unmergedWireDigits{};
   sTgcDigtCont outputDigits{};
   
   ATH_MSG_DEBUG("create Digit container of size " << idHelper.module_hash_max());
  
   double earliestEventTime = 9999;
  
   // --nextDetectorElement>sets an iterator range with the hits of current detector element , returns a bool when done
   while(m_thpcsTGC->nextDetectorElement(i, e)) {
     int nhits = 0;
     ATH_MSG_VERBOSE("Next Detector Element");
     while(i != e){ //loop through the hits on this Detector Element
       ATH_MSG_VERBOSE("Looping over hit " << nhits+1 << " on this Detector Element." );
  
       ++nhits;
       TimedHitPtr<sTGCSimHit> phit = *i++;
       const sTGCSimHit& hit = *phit;
       ATH_MSG_VERBOSE("Hit Particle ID : " << hit.particleEncoding() );
       double eventTime = phit.eventTime();
       if(eventTime < earliestEventTime) earliestEventTime = eventTime;
       // Cut on energy deposit of the particle
       if(hit.depositEnergy() < m_energyDepositThreshold) {
         ATH_MSG_VERBOSE("Hit with Energy Deposit of " << hit.depositEnergy()
                         << " less than " << m_energyDepositThreshold << ". Skip this hit." );
         continue;
       }
  
       // Old HITS format doesn't have kinetic energy (i.e it is set to -1).
       double hit_kineticEnergy = hit.kineticEnergy();
  
       // Skip digitizing some problematic hits, if processing compatible HITS format
       if (hit_kineticEnergy > 0.) {
         // Skip electron with low kinetic energy, since electrons are mainly secondary particles.
         if ((std::abs(hit.particleEncoding()) == 11) && (hit_kineticEnergy < m_limitElectronKineticEnergy)) {
           ATH_MSG_DEBUG("Skip electron hit with kinetic energy " << hit_kineticEnergy
                       << ", which is less than the lower limit of " << m_limitElectronKineticEnergy);
           continue;
         }
  
        // No support for particles with direction perpendicular to the beam line, since such particles
        // can deposit energy on a lot of strips and pads of the gas gap. So a good model of charge
        // spreading should be implemented. Also, these particles are rare, and most of them are
        // secondary particles suh as electrons.
        if (std::abs(hit.globalPosition().z() - hit.globalPrePosition().z()) < 0.00001) {
          ATH_MSG_VERBOSE("Skip hit with a direction perpendicular to the beam line, ie z-component is less than 0.00001 mm.");
          continue;
        }
       }
  
       if(eventTime != 0){
          ATH_MSG_DEBUG("Updated hit global time to include off set of " << eventTime << " ns from OOT bunch.");
       }
       else {
           ATH_MSG_DEBUG("This hit came from the in time bunch.");
       }
       sTgcSimIdToOfflineId simToOffline(&idHelper);
       const int idHit = hit.sTGCId();
       ATH_MSG_VERBOSE("Hit ID " << idHit );
       Identifier layid = simToOffline.convert(idHit);
       int eventId = phit.eventId();
       
       if (m_doSmearing) {
         bool acceptHit = true;
         ATH_CHECK(m_smearingTool->isAccepted(layid, acceptHit, digitCond.rndmEngine));
         if ( !acceptHit ) {
           ATH_MSG_DEBUG("Dropping the hit - smearing tool");
           continue;
         }
       }
  
       const MuonGM::sTgcReadoutElement* detEL = digitCond.detMgr->getsTgcReadoutElement(layid);  //retreiving the sTGC this hit is located in
       if(!detEL) {
         ATH_MSG_WARNING("Failed to retrieve detector element for " 
                       << m_idHelperSvc->toStringDetEl(layid));
         continue;
       }
  
       // project the hit position to wire surface (along the incident angle)
       ATH_MSG_VERBOSE("Projecting hit to Wire Surface" );
       const Amg::Vector3D& HPOS{hit.globalPosition()};  //Global position of the hit
       const Amg::Vector3D& GLODIRE{hit.globalDirection()};
       const Amg::Vector3D& global_preStepPos{hit.globalPrePosition()};
  
       ATH_MSG_VERBOSE("Global Direction " << Amg::toString(GLODIRE, 2) );
       ATH_MSG_VERBOSE("Global Position " << Amg::toString(HPOS, 2) );
  
       int surfHash_wire =  detEL->surfaceHash(idHelper.gasGap(layid), 
                                               sTgcIdHelper::sTgcChannelTypes::Wire);
       ATH_MSG_VERBOSE("Surface Hash for wire plane" << surfHash_wire );
       const Trk::PlaneSurface&  SURF_WIRE = detEL->surface(surfHash_wire);  //Plane of the wire surface in this gasGap
       ATH_MSG_VERBOSE("Wire Surface Defined " <<Amg::toString(SURF_WIRE.center(), 2) );
  
       const Amg::Transform3D wireTrans = SURF_WIRE.transform().inverse(); 
       Amg::Vector3D LOCDIRE = wireTrans.linear()*GLODIRE;
       Amg::Vector3D LPOS = wireTrans * HPOS;  //Position of the hit on the wire plane in local coordinates
  
       ATH_MSG_VERBOSE("Local Direction: "<<Amg::toString(LOCDIRE, 2));
       ATH_MSG_VERBOSE("Local Position: " << Amg::toString(LPOS, 2));
  
       const double scale = Amg::intersect<3>(LPOS, LOCDIRE, Amg::Vector3D::UnitZ(), 0.).value_or(0);
       // Hit on the wire surface in local coordinates
       Amg::Vector3D hitOnSurf_wire = LPOS + scale * LOCDIRE;
  
       //The hit on the wire in Global coordinates
       Amg::Vector3D glob_hitOnSurf_wire = SURF_WIRE.transform() * hitOnSurf_wire;
  
       ATH_MSG_VERBOSE("Local Hit on Wire Surface: " << Amg::toString(hitOnSurf_wire, 2));
       ATH_MSG_VERBOSE("Global Hit on Wire Surface: " <<Amg::toString(glob_hitOnSurf_wire, 2));
  
       ATH_MSG_DEBUG("sTgcDigitizationTool::doDigitization hits mapped");
  
       const HepMcParticleLink particleLink = HepMcParticleLink::getRedirectedLink(hit.particleLink(), eventId, ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
       const sTGCSimHit temp_hit(hit.sTGCId(), hit.globalTime(),
                                 HPOS,
                                 hit.particleEncoding(),
                                 hit.globalDirection(),
                                 hit.depositEnergy(),
                                 particleLink,
                                 hit_kineticEnergy,
                                 global_preStepPos);
  
  
       double globalHitTime = temp_hit.globalTime() + eventTime;
       double tof = temp_hit.globalPosition().mag()/CLHEP::c_light;
       double bunchTime = globalHitTime - tof;
  
       // Create all the digits for this particular Sim Hit
       sTgcDigitVec digiHits = m_digitizer->executeDigi(digitCond, temp_hit);
       if (digiHits.empty()) {
           continue;
       }
       ATH_MSG_VERBOSE("Hit produced " << digiHits.size() << " digits." );
       for( std::unique_ptr<sTgcDigit>& digit : digiHits) {
         /*
           NOTE:
           -----
           Since not every hit might end up resulting in a
           digit, this construction might take place after the hit loop
           in a loop of its own!
         */
         // make new sTgcDigit
         Identifier newDigitId = digit->identify(); //This Identifier should be sufficient to determine which RE the digit is from
         double newTime = digit->time();
         int newChannelType = idHelper.channelType(newDigitId);
  
         double timeJitterElectronicsStrip = CLHEP::RandGaussZiggurat::shoot(digitCond.rndmEngine, 0, m_timeJitterElectronicsStrip);
         double timeJitterElectronicsPad = CLHEP::RandGaussZiggurat::shoot(digitCond.rndmEngine, 0, m_timeJitterElectronicsPad);
         if(newChannelType== sTgcIdHelper::sTgcChannelTypes::Strip)
           newTime += timeJitterElectronicsStrip;
         else
           newTime += timeJitterElectronicsPad;
         uint16_t newBcTag = bcTagging(newTime+bunchTime);
  
         if(m_doToFCorrection)
           newTime += bunchTime;
         else
           newTime += globalHitTime;
  
         double newCharge = digit->charge();
  
         bool isDead{false}, isPileup{eventId != 0};
         ATH_MSG_VERBOSE("Hit is from the main signal subevent if eventId is zero, eventId = " << eventId << " newTime: " << newTime);
       
  
         // Create a new digit with updated time and BCTag
         sTgcDigit newDigit(newDigitId, newBcTag, newTime, newCharge, isDead, isPileup);
         ATH_MSG_VERBOSE("Unmerged Digit "<<m_idHelperSvc->toString(newDigitId)
                       <<" BC tag = "    << newDigit.bcTag() 
                       <<" digitTime = " << newDigit.time()
                       <<" charge = "    << newDigit.charge()) ;
  
  
         // Create a MuonSimData (SDO) corresponding to the digit
         MuonSimData::Deposit deposit(particleLink, MuonMCData(hit.depositEnergy(), tof));
         std::vector<MuonSimData::Deposit> deposits;
         deposits.push_back(std::move(deposit));
         MuonSimData simData(std::move(deposits), hit.particleEncoding());
         // The sTGC SDO should be placed at the center of the gap, on the wire plane.
         // We use the position from the hit on the wire surface which is by construction in the center of the gap
         // glob_hitOnSurf_wire projects the whole hit to the center of the gap
         simData.setPosition(glob_hitOnSurf_wire);
         simData.setTime(globalHitTime);
         const unsigned int modHash = static_cast<unsigned>(m_idHelperSvc->detElementHash(newDigitId));
         sTgcSimDigitCont& contToPush = newChannelType == sTgcIdHelper::sTgcChannelTypes::Pad ? unmergedPadDigits :
                                        newChannelType == sTgcIdHelper::sTgcChannelTypes::Strip ? unmergedStripDigits : unmergedWireDigits;                     
         if (contToPush.size() <= modHash) contToPush.resize(modHash + 1);
         contToPush[modHash].emplace_back(std::move(simData), std::move(newDigit));
       } // end of loop digiHits
     } // end of while(i != e)
   } //end of while(m_thpcsTGC->nextDetectorElement(i, e))
  
   
   /*********************
   * Process Strip Digits *
   *********************/
   /* Comments from Alexandre Laurier, October 2022:
     Big update to VMM handling of digits to sTGC digitization
     For each channel type, the digits are processed on a layer-by-layer level
     This is done to improve the performance of strip neighborOn functionnality
     For wires, pads, and neighborOn=false strips, the digits on each channel
     are ordered by earlier to latest and processed in order.
     The digits are merged according to the VMM merging time window.
     Above threshold digits are saved to output unless a previous digit is found
     within the deadtime window.
     --- For neighborOn=true strips ---
     A strip above threshold forces the VMM readout of neighbor strips, even if
     neighbor strips are below threshold.
     We apply the logic as above, but for strips below threshold we search for one
     direct neighbor strip to be above VMM threshold which triggers the VMM
     to read the strip digit.
   */
   ATH_CHECK(processDigitsWithVMM(ctx, digitCond, unmergedStripDigits, m_deadtimeStrip,
                                  m_doNeighborOn, outputDigits, *sdoContainer));
   /*********************
   * Process Pad Digits *
   *********************/
   ATH_CHECK(processDigitsWithVMM(ctx, digitCond, unmergedPadDigits, m_deadtimePad,
                                  false, outputDigits, *sdoContainer));
   /*********************
   * Process Wire Digits *
   *********************/
   ATH_CHECK(processDigitsWithVMM(ctx, digitCond, unmergedWireDigits, m_deadtimeWire,
                                  false, outputDigits, *sdoContainer));
   /*************************************************
    * Output the digits to the StoreGate collection *
   *************************************************/
   for (sTgcDigitVec& digits : outputDigits) {
      if (digits.empty()) continue;
      const Identifier elemID = m_idHelperSvc->chamberId(digits[0]->identify());
      const IdentifierHash modHash = m_idHelperSvc->moduleHash(elemID);
      std::unique_ptr<sTgcDigitCollection> collection = std::make_unique<sTgcDigitCollection>(elemID, modHash);
      collection->insert(collection->end(), std::make_move_iterator(digits.begin()),
                                            std::make_move_iterator(digits.end()));
      ATH_CHECK(digitContainer->addCollection(collection.release(), modHash));
   }
   return StatusCode::SUCCESS;
 }

◆ filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

49 { return m_filterPassed; }

◆ getChannelThreshold()

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

private

Definition at line 558 of file sTgcDigitizationTool.cxx.

                                                                                                      {
  
   float threshold = m_chargeThreshold, elecThrsld{0.f};
  
   if(!thresholdData.getThreshold(channelID, elecThrsld))
     ATH_MSG_ERROR("Cannot find retrieve VMM threshold from conditions data base!");
   if(!m_calibTool->pdoToCharge(ctx, true, elecThrsld, channelID, threshold))
     ATH_MSG_ERROR("Cannot convert VMM charge threshold via conditions data!");
  
   return threshold;
 }

◆ getNextEvent()

StatusCode sTgcDigitizationTool::getNextEvent ( const EventContext & ctx )

private

Get next event and extract collection of hit collections.

Definition at line 173 of file sTgcDigitizationTool.cxx.

                                                                      {
  
   ATH_MSG_DEBUG ( "sTgcDigitizationTool::getNextEvent()" );
  
   //  get the container(s)
   using TimedHitCollList = PileUpMergeSvc::TimedList<sTGCSimHitCollection>::type;
  
   // In case of single hits container just load the collection using read handles
   if (!m_onlyUseContainerName) {
     SG::ReadHandle<sTGCSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
     if (!hitCollection.isValid()) {
       ATH_MSG_ERROR("Could not get sTGCSimHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
       return StatusCode::FAILURE;
     }
  
     // create a new hits collection
     m_thpcsTGC = std::make_unique<TimedHitCollection<sTGCSimHit>>(1);
     m_thpcsTGC->insert(0, hitCollection.cptr());
     ATH_MSG_DEBUG("sTGCSimHitCollection found with " << hitCollection->size() << " hits");
     return StatusCode::SUCCESS;
   }
  
   //this is a list<info<time_t, DataLink<sTGCSimHitCollection> > >
   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() << " sTGC SimHitCollections with key " << m_inputObjectName << " found" );
   }
  
   //Perform null check on m_thpcsTGC. If pointer is not null throw error
   if (!m_thpcsTGC) {
     m_thpcsTGC = std::make_unique<TimedHitCollection<sTGCSimHit>>();
   }else{
   ATH_MSG_ERROR ( "m_thpcsTGC is not null" );
   return StatusCode::FAILURE;
   }
  
   //now merge all collections into one
   TimedHitCollList::iterator iColl(hitCollList.begin());
   TimedHitCollList::iterator endColl(hitCollList.end());
   while (iColl != endColl) {
     const sTGCSimHitCollection* p_collection(iColl->second);
     m_thpcsTGC->insert(iColl->first, p_collection);
     ATH_MSG_DEBUG ( "sTGC SimHitCollection found with " << p_collection->size() << " hits"  );
     ++iColl;
   }
  
   return StatusCode::SUCCESS;
 }

◆ getRandomEngine()

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

private

Definition at line 573 of file sTgcDigitizationTool.cxx.

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

◆ initialize()

StatusCode sTgcDigitizationTool::initialize ( )

virtual

Initialize.

Reimplemented from PileUpToolBase.

Definition at line 58 of file sTgcDigitizationTool.cxx.

                                             {
  
   ATH_MSG_INFO (" sTgcDigitizationTool  retrieved");
   ATH_MSG_INFO ( "Configuration  sTgcDigitizationTool" );
   ATH_MSG_INFO ( "doSmearing             "<< m_doSmearing);
   ATH_MSG_INFO ( "RndmSvc                " << m_rndmSvc             );
   ATH_MSG_INFO ( "RndmEngine             " << m_rndmEngineName      );
   ATH_MSG_INFO ( "InputObjectName        " << m_hitsContainerKey.key());
   ATH_MSG_INFO ( "OutputObjectName       " << m_outputDigitCollectionKey.key());
   ATH_MSG_INFO ( "OutputSDOName          " << m_outputSDO_CollectionKey.key());
   ATH_MSG_INFO ( "HV                     " << m_runVoltage);
   ATH_MSG_INFO ( "threshold              " << m_chargeThreshold);
   ATH_MSG_INFO ( "useCondThresholds      " << m_useCondThresholds);
  
   if (m_hitsContainerKey.key().empty()) {
     ATH_MSG_FATAL("Property InputObjectName not set !");
     return StatusCode::FAILURE;
   }
  
   if (m_onlyUseContainerName) m_inputObjectName = m_hitsContainerKey.key();
   ATH_MSG_DEBUG("Input objects in container: '" << m_inputObjectName << "'");
  
   // Pile-up merge service
   if (m_onlyUseContainerName) {
     ATH_CHECK(m_mergeSvc.retrieve());
   }
  
   // retrieve MuonDetctorManager from DetectorStore
   ATH_CHECK(m_detMgrKey.initialize());
   ATH_CHECK(m_idHelperSvc.retrieve());
   ATH_CHECK(m_effiKey.initialize(m_doEfficiencyCorrection));
  
  
   // calibration tool
   ATH_CHECK(m_calibTool.retrieve());
   // initialize ReadCondHandleKey
   ATH_CHECK(m_condThrshldsKey.initialize(m_useCondThresholds));
   // Initialize ReadHandleKey
   ATH_CHECK(m_hitsContainerKey.initialize());
  
   //initialize the output WriteHandleKeys
   ATH_CHECK(m_outputDigitCollectionKey.initialize());
   ATH_CHECK(m_outputSDO_CollectionKey.initialize());
  
   // initialize sTgcDigitMaker class to digitize hits
   // meanGasGain is the mean value of the polya gas gain function describing the
   // avalanche of electrons caused by the electric field
   // Parameterization is obtained from ATL-MUON-PUB-2014-001 and the corrected
   // fit to data to parameterize gain vs HV in kV
   // m_runVoltage MUST BE in kV!
   if (m_runVoltage < 2.3 || m_runVoltage > 3.2){
     ATH_MSG_ERROR("STGC run voltage must be in kV and within fit domain of 2.3 kV to 3.2 kV");
     return StatusCode::FAILURE;
   }
   double meanGasGain = 2.15 * 1E-4 * std::exp(6.88*m_runVoltage);
   m_digitizer = std::make_unique<sTgcDigitMaker>(m_idHelperSvc.get(), m_doChannelTypes, meanGasGain, m_doPadSharing, m_stripChargeScale);
   m_digitizer->setLevel(static_cast<MSG::Level>(msgLevel()));
   ATH_CHECK(m_digitizer->initialize());
  
   ATH_CHECK(m_rndmSvc.retrieve());
   // getting our random numbers stream
   ATH_MSG_DEBUG("Getting random number engine : <" << m_rndmEngineName << ">");
  
   return StatusCode::SUCCESS;
 }

◆ mergeEvent()

StatusCode sTgcDigitizationTool::mergeEvent ( const EventContext & ctx )

Definition at line 232 of file sTgcDigitizationTool.cxx.

                                                                    {
   ATH_MSG_DEBUG ( "sTgcDigitizationTool::in mergeEvent()" );
   ATH_CHECK(doDigitization(ctx));
   // reset the pointer
   m_thpcsTGC.reset();
   m_STGCHitCollList.clear();
  
   return StatusCode::SUCCESS;
 }

◆ prepareEvent()

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

Definition at line 124 of file sTgcDigitizationTool.cxx.

                                                                                               {
  
   ATH_MSG_DEBUG("sTgcDigitizationTool::prepareEvent() called for " << nInputEvents << " input events" );
   m_STGCHitCollList.clear();
  
   return StatusCode::SUCCESS;
 }

◆ processAllSubEvents() [1/2]

StatusCode sTgcDigitizationTool::processAllSubEvents ( const EventContext & ctx )

virtual

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

Reimplemented from PileUpToolBase.

Definition at line 246 of file sTgcDigitizationTool.cxx.

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

◆ processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents

inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

◆ processBunchXing()

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

virtual

Reimplemented from PileUpToolBase.

Definition at line 133 of file sTgcDigitizationTool.cxx.

                                            {
   ATH_MSG_DEBUG ( "sTgcDigitizationTool::in processBunchXing()" );
   if (m_thpcsTGC == nullptr) {
     m_thpcsTGC = std::make_unique<TimedHitCollection<sTGCSimHit>>();
   }
   using TimedHitCollList = PileUpMergeSvc::TimedList<sTGCSimHitCollection>::type;
   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() << " sTGCSimHitCollection with key " <<
                     m_inputObjectName << " found");
   }
  
   TimedHitCollList::iterator iColl(hitCollList.begin());
   TimedHitCollList::iterator endColl(hitCollList.end());
  
   // Iterating over the list of collections
   for( ; iColl != endColl; ++iColl){
  
     auto hitCollPtr = std::make_unique<sTGCSimHitCollection>(*iColl->second);
     PileUpTimeEventIndex timeIndex(iColl->first);
  
     ATH_MSG_DEBUG("sTGCSimHitCollection found with " << hitCollPtr->size() << " hits");
     ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time()
                     << " index: " << timeIndex.index()
                     << " type: " << timeIndex.type());
  
     m_thpcsTGC->insert(timeIndex, hitCollPtr.get());
     m_STGCHitCollList.push_back(std::move(hitCollPtr));
   }
   return StatusCode::SUCCESS;
 }

◆ processDigitsWithVMM() [1/2]

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

private

Sort the unmerged digit vector per layer Id -> by channel -> time from early to late arrival

Catch the cases where the channel is 1 or maxChannel

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

We reached another digit. No need to merge

Definition at line 640 of file sTgcDigitizationTool.cxx.

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

◆ processDigitsWithVMM() [2/2]

StatusCode sTgcDigitizationTool::processDigitsWithVMM	(	const EventContext &	ctx,
		const DigiConditions &	digiCond,
		sTgcSimDigitCont &	unmergedContainer,
		const double	vmmDeadTime,
		const bool	isNeighbourOn,
		sTgcDigtCont &	outDigitContainer,
		MuonSimDataCollection &	outSdoContainer
	)		const

private

Start the merging by looping over the digit container and grouping the hits from the same layer together.

Merge all digits

Update the container iterator to go to the next layer

Assign enough space in the container vector

Push back the SDO

apply the smearing before adding the digit

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

Definition at line 583 of file sTgcDigitizationTool.cxx.

                                                                                                     {
   
   const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
   for (sTgcSimDigitVec& digitsInCham : unmergedDigits) { 
     
     if (digitsInCham.empty()) continue;
     sTgcSimDigitVec mergedDigits = processDigitsWithVMM(ctx, digiCond, vmmDeadTime, 
                                                        digitsInCham, isNeighbourOn);
     if (mergedDigits.empty()) continue;
  
     const IdentifierHash hash = m_idHelperSvc->moduleHash(mergedDigits.front().identify());
     const unsigned int hashIdx = static_cast<unsigned>(hash);
     if (hash >= outDigitContainer.size()) {
       outDigitContainer.resize(hash + 1);
     }
     for (sTgcSimDigitData& merged : mergedDigits) {
         outSdoContainer.insert(std::make_pair(merged.identify(), std::move(merged.getSimData())));
         bool acceptDigit{true};
         float chargeAfterSmearing = merged.getDigit().charge();
         if (m_doSmearing) {
             ATH_CHECK(m_smearingTool->smearCharge(merged.identify(), chargeAfterSmearing, acceptDigit, 
                                                   digiCond.rndmEngine));
         }
         if (!acceptDigit) {
             continue;
         }
         if (idHelper.channelType(merged.identify()) == sTgcIdHelper::sTgcChannelTypes::Strip &&
             chargeAfterSmearing < 0.001) {
             continue;
         }
         std::unique_ptr<sTgcDigit> finalDigit = std::make_unique<sTgcDigit>(std::move(merged.getDigit()));
         if (m_doSmearing) {
             finalDigit->set_charge(chargeAfterSmearing);
         }
         ATH_MSG_VERBOSE("Final Digit "<<m_idHelperSvc->toString(finalDigit->identify())<<
                         " BC tag = "    << finalDigit->bcTag()<<
                         " digitTime = " << finalDigit->time() <<
                         " charge = "    << finalDigit->charge());
         outDigitContainer[hashIdx].push_back(std::move(finalDigit));
     }
   }
   return StatusCode::SUCCESS; 
 }

◆ resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

51 { m_filterPassed=true; }

◆ retrieveCondData()

template<class CondType >

StatusCode sTgcDigitizationTool::retrieveCondData	(	const EventContext &	ctx,
		SG::ReadCondHandleKey< CondType > &	key,
		const CondType *&	condPtr
	)		const

private

Definition at line 259 of file sTgcDigitizationTool.cxx.

                                                                                                             {
     if (key.empty()) {
        ATH_MSG_DEBUG("No key has been configured for object "<<typeid(CondType).name()<<". Clear pointer");
        condPtr = nullptr;
        return StatusCode::SUCCESS;
     }
     SG::ReadCondHandle<CondType> readHandle{key, ctx};
     if (!readHandle.isValid()){
         ATH_MSG_FATAL("Failed to load conditions object "<<key.fullKey()<<".");
         return StatusCode::FAILURE;
     }
     condPtr = readHandle.cptr();
     return StatusCode::SUCCESS;
 }

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

ToolHandle<Muon::INSWCalibTool> sTgcDigitizationTool::m_calibTool {this,"CalibrationTool","Muon::NSWCalibTool/NSWCalibTool"}

private

Definition at line 144 of file sTgcDigitizationTool.h.

◆ m_chargeThreshold

Gaudi::Property<double> sTgcDigitizationTool::m_chargeThreshold {this,"chargeThreshold", 0.002, "vmm charge threshold in pC, need to set useCondThresholds to false if one wants to use this threshold value otherwise the one from the conditions database is used"}

private

Definition at line 178 of file sTgcDigitizationTool.h.

◆ m_condThrshldsKey

SG::ReadCondHandleKey<NswCalibDbThresholdData> sTgcDigitizationTool::m_condThrshldsKey {this, "CondThrshldsKey", "NswCalibDbThresholdData", "Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"}

private

Definition at line 164 of file sTgcDigitizationTool.h.

◆ m_deadtimePad

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

private

Definition at line 171 of file sTgcDigitizationTool.h.

◆ m_deadtimeStrip

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

private

Definition at line 170 of file sTgcDigitizationTool.h.

◆ m_deadtimeWire

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

private

Definition at line 172 of file sTgcDigitizationTool.h.

◆ m_detMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> sTgcDigitizationTool::m_detMgrKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",

"Key of input MuonDetectorManager condition data"}

Definition at line 132 of file sTgcDigitizationTool.h.

◆ m_digitizer

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

private

Definition at line 139 of file sTgcDigitizationTool.h.

◆ m_doChannelTypes

Gaudi::Property<int> sTgcDigitizationTool::m_doChannelTypes {this,"doChannelTypes",3}

private

Definition at line 166 of file sTgcDigitizationTool.h.

◆ m_doEfficiencyCorrection

Gaudi::Property<bool> sTgcDigitizationTool::m_doEfficiencyCorrection {this,"doEfficiencyCorrection",false}

private

Definition at line 151 of file sTgcDigitizationTool.h.

◆ m_doNeighborOn

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

private

Definition at line 173 of file sTgcDigitizationTool.h.

◆ m_doPadSharing

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

private

Definition at line 167 of file sTgcDigitizationTool.h.

◆ m_doSmearing

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

private

Definition at line 149 of file sTgcDigitizationTool.h.

◆ m_doToFCorrection

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

private

Definition at line 150 of file sTgcDigitizationTool.h.

◆ m_effiKey

SG::ReadCondHandleKey<Muon::DigitEffiData> sTgcDigitizationTool::m_effiKey

private

Initial value:

{this, "EffiDigiKey", "sTgcDigitEff",

"Key of the efficiency data in the CondStore"}

Definition at line 135 of file sTgcDigitizationTool.h.

◆ m_energyDepositThreshold

Gaudi::Property<double> sTgcDigitizationTool::m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV,"Minimum energy deposit for hit to be digitized"}

private

Definition at line 175 of file sTgcDigitizationTool.h.

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

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

◆ m_hitsContainerKey

SG::ReadHandleKey<sTGCSimHitCollection> sTgcDigitizationTool::m_hitsContainerKey {this, "InputObjectName", "sTGC_Hits", "name of the input object"}

private

Definition at line 160 of file sTgcDigitizationTool.h.

◆ m_hitTimeMergeThreshold

const double sTgcDigitizationTool::m_hitTimeMergeThreshold {30.f}

private

Definition at line 184 of file sTgcDigitizationTool.h.

◆ m_idHelperSvc

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

private

Definition at line 130 of file sTgcDigitizationTool.h.

◆ m_inputObjectName

std::string sTgcDigitizationTool::m_inputObjectName {""}

private

Definition at line 161 of file sTgcDigitizationTool.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.

◆ m_limitElectronKineticEnergy

Gaudi::Property<double> sTgcDigitizationTool::m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV,"Minimum kinetic energy for electron hit to be digitized"}

private

Definition at line 176 of file sTgcDigitizationTool.h.

◆ m_mergeSvc

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

private

Definition at line 128 of file sTgcDigitizationTool.h.

◆ m_onlyUseContainerName

Gaudi::Property<bool> sTgcDigitizationTool::m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}

private

Definition at line 159 of file sTgcDigitizationTool.h.

◆ m_outputDigitCollectionKey

SG::WriteHandleKey<sTgcDigitContainer> sTgcDigitizationTool::m_outputDigitCollectionKey {this,"OutputObjectName","sTGC_DIGITS","WriteHandleKey for Output sTgcDigitContainer"}

private

Definition at line 146 of file sTgcDigitizationTool.h.

◆ m_outputSDO_CollectionKey

SG::WriteHandleKey<MuonSimDataCollection> sTgcDigitizationTool::m_outputSDO_CollectionKey {this,"OutputSDOName","sTGC_SDO","WriteHandleKey for Output MuonSimDataCollection"}

private

Definition at line 147 of file sTgcDigitizationTool.h.

◆ m_rndmEngineName

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

private

Definition at line 157 of file sTgcDigitizationTool.h.

◆ m_rndmSvc

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

private

Definition at line 129 of file sTgcDigitizationTool.h.

◆ m_runVoltage

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

private

Definition at line 155 of file sTgcDigitizationTool.h.

◆ m_smearingTool

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

private

Definition at line 143 of file sTgcDigitizationTool.h.

◆ m_STGCHitCollList

std::vector<std::unique_ptr<sTGCSimHitCollection> > sTgcDigitizationTool::m_STGCHitCollList {}

private

Definition at line 141 of file sTgcDigitizationTool.h.

◆ m_stripChargeScale

Gaudi::Property<double> sTgcDigitizationTool::m_stripChargeScale {this, "stripChargeScale",0.4, "strip charge scale"}

private

Definition at line 180 of file sTgcDigitizationTool.h.

◆ m_thpcsTGC

std::unique_ptr<TimedHitCollection<sTGCSimHit> > sTgcDigitizationTool::m_thpcsTGC {}

private

Definition at line 140 of file sTgcDigitizationTool.h.

◆ m_timeJitterElectronicsPad

const double sTgcDigitizationTool::m_timeJitterElectronicsPad {2.f}

private

Definition at line 183 of file sTgcDigitizationTool.h.

◆ m_timeJitterElectronicsStrip

const double sTgcDigitizationTool::m_timeJitterElectronicsStrip {2.f}

private

Definition at line 182 of file sTgcDigitizationTool.h.

◆ m_useCondThresholds

Gaudi::Property<bool> sTgcDigitizationTool::m_useCondThresholds {this, "useCondThresholds", false, "Use conditions data to get VMM charge threshold values"}

private

Definition at line 163 of file sTgcDigitizationTool.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.

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

Classes

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

structors and AlgTool implementation

Detailed Description

Class methods and properties

Member Typedef Documentation

◆ DigiConditions

◆ sTgcDigitVec

◆ sTgcDigtCont

◆ sTgcSimDigitCont

◆ sTgcSimDigitVec

Constructor & Destructor Documentation

◆ sTgcDigitizationTool()

Member Function Documentation

◆ bcTagging()

◆ digitize()

◆ doDigitization()

◆ filterPassed()

◆ getChannelThreshold()

◆ getNextEvent()

◆ getRandomEngine()

◆ initialize()

◆ mergeEvent()

◆ prepareEvent()

◆ processAllSubEvents() [1/2]

◆ processAllSubEvents() [2/2]

◆ processBunchXing()

◆ processDigitsWithVMM() [1/2]

◆ processDigitsWithVMM() [2/2]

◆ resetFilter()

◆ retrieveCondData()

◆ toProcess()

Member Data Documentation

◆ m_calibTool

◆ m_chargeThreshold

◆ m_condThrshldsKey

◆ m_deadtimePad

◆ m_deadtimeStrip

◆ m_deadtimeWire

◆ m_detMgrKey

◆ m_digitizer

◆ m_doChannelTypes

◆ m_doEfficiencyCorrection

◆ m_doNeighborOn

◆ m_doPadSharing

◆ m_doSmearing

◆ m_doToFCorrection

◆ m_effiKey

◆ m_energyDepositThreshold

◆ m_filterPassed

◆ m_firstXing

◆ m_hitsContainerKey

◆ m_hitTimeMergeThreshold

◆ m_idHelperSvc

◆ m_inputObjectName

◆ m_lastXing

◆ m_limitElectronKineticEnergy

◆ m_mergeSvc

◆ m_onlyUseContainerName

◆ m_outputDigitCollectionKey

◆ m_outputSDO_CollectionKey

◆ m_rndmEngineName

◆ m_rndmSvc

◆ m_runVoltage

◆ m_smearingTool

◆ m_STGCHitCollList

◆ m_stripChargeScale

◆ m_thpcsTGC

◆ m_timeJitterElectronicsPad

◆ m_timeJitterElectronicsStrip

◆ m_useCondThresholds

◆ m_vetoPileUpTruthLinks