sTgcDigitizationTool Class Reference

#include <sTgcDigitizationTool.h>

Inheritance 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.
StatusCode	prepareEvent (const EventContext &ctx, const unsigned int)
	When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop.
StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents)
	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)
	When being run from PileUpToolsAlgs, this method is called at the end of the subevts loop.
virtual StatusCode	processAllSubEvents (const EventContext &ctx)
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.
StatusCode	digitize (const EventContext &ctx)
	Just calls processAllSubEvents - leaving for back-compatibility (IMuonDigitizationTool)

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.
StatusCode	doDigitization (const EventContext &ctx)
	Core part of digitization use by mergeEvent (IPileUpTool) and digitize (IMuonDigitizationTool)
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.030, "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< bool >	m_applyAsBuiltBLines {this, "applyAsBuiltBLines",false, "correct the hit position by the as built and B-lines parameters"}
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
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

Class methods and properties

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

Definition at line 45 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

Member Typedef Documentation

DigiConditions

using sTgcDigitizationTool::DigiConditions = sTgcDigitMaker::DigiConditions

Definition at line 108 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

sTgcDigitVec

using sTgcDigitizationTool::sTgcDigitVec = sTgcDigitMaker::sTgcDigitVec

Definition at line 109 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

sTgcDigtCont

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

Definition at line 110 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

sTgcSimDigitCont

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

Definition at line 106 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

sTgcSimDigitVec

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

Definition at line 105 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

Constructor & Destructor Documentation

sTgcDigitizationTool()

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

Definition at line 42 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.

                                                                                                                 :
    PileUpToolBase(type, name, parent) {}

Member Function Documentation

bcTagging()

uint16_t sTgcDigitizationTool::bcTagging ( const double digittime )

staticprivate

Definition at line 535 of file MuonDigitization/sTGC_Digitization/src/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 232 of file MuonDigitization/sTGC_Digitization/src/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 267 of file MuonDigitization/sTGC_Digitization/src/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.

{ return m_filterPassed; }

getChannelThreshold()

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

private

Definition at line 548 of file MuonDigitization/sTGC_Digitization/src/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 163 of file MuonDigitization/sTGC_Digitization/src/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 563 of file MuonDigitization/sTGC_Digitization/src/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 48 of file MuonDigitization/sTGC_Digitization/src/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_applyAsBuiltBLines);
  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

)

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 222 of file MuonDigitization/sTGC_Digitization/src/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 )

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

Not able to access SubEvents

Definition at line 114 of file MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx.

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

processAllSubEvents()

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 236 of file MuonDigitization/sTGC_Digitization/src/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;
}

processBunchXing()

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

virtual

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 123 of file MuonDigitization/sTGC_Digitization/src/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 630 of file MuonDigitization/sTGC_Digitization/src/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 573 of file MuonDigitization/sTGC_Digitization/src/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.

{ 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 249 of file MuonDigitization/sTGC_Digitization/src/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_applyAsBuiltBLines

Gaudi::Property<bool> sTgcDigitizationTool::m_applyAsBuiltBLines {this, "applyAsBuiltBLines",false, "correct the hit position by the as built and B-lines parameters"}

private

Definition at line 175 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this, "applyAsBuiltBLines",false, "correct the hit position by the as built and B-lines parameters"};

m_calibTool

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

private

Definition at line 139 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_chargeThreshold

Gaudi::Property<double> sTgcDigitizationTool::m_chargeThreshold {this,"chargeThreshold", 0.030, "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 173 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"chargeThreshold", 0.030, "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"};

m_condThrshldsKey

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

private

Definition at line 159 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_deadtimePad

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

private

Definition at line 166 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"deadtimePad"    , 250};

m_deadtimeStrip

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

private

Definition at line 165 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"deadtimeStrip", 250};

m_deadtimeWire

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

private

Definition at line 167 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"deadtimeWire" , 250};

m_detMgrKey

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

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",
                                                                            "Key of input MuonDetectorManager condition data"}

Definition at line 127 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

                                                            {this, "DetectorManagerKey", "MuonDetectorManager",
                                                                            "Key of input MuonDetectorManager condition data"};

m_digitizer

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

private

Definition at line 134 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{};

m_doChannelTypes

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

private

Definition at line 161 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"doChannelTypes",3};

m_doEfficiencyCorrection

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

private

Definition at line 146 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"doEfficiencyCorrection",false};

m_doNeighborOn

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

private

Definition at line 168 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"neighborOn", true};

m_doPadSharing

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

private

Definition at line 162 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"padChargeSharing", false};

m_doSmearing

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

private

Definition at line 144 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"doSmearing",false};

m_doToFCorrection

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

private

Definition at line 145 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"doToFCorrection",false};

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 130 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

                                                  {this, "EffiDigiKey", "sTgcDigitEff",
                                                      "Key of the efficiency data in the CondStore"};

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 170 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"energyDepositThreshold",300.0*CLHEP::eV,"Minimum energy deposit for hit to be digitized"};

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_hitsContainerKey

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

private

Definition at line 155 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_hitTimeMergeThreshold

const double sTgcDigitizationTool::m_hitTimeMergeThreshold {30.f}

private

Definition at line 179 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{30.f}; //30ns = resolution of peak finding descriminator

m_idHelperSvc

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

private

Definition at line 125 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_inputObjectName

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

private

Definition at line 156 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/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.

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

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 171 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"limitElectronKineticEnergy",5.0*CLHEP::MeV,"Minimum kinetic energy for electron hit to be digitized"};

m_mergeSvc

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

private

Definition at line 123 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

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 154 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_outputDigitCollectionKey

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

private

Definition at line 141 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"OutputObjectName","sTGC_DIGITS","WriteHandleKey for Output sTgcDigitContainer"}; // name of the output digits

m_outputSDO_CollectionKey

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

private

Definition at line 142 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_rndmEngineName

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

private

Definition at line 152 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_rndmSvc

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

private

Definition at line 124 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

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

m_runVoltage

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

private

Definition at line 150 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"operatingHVinkV",2.8};

m_smearingTool

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

private

Definition at line 138 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this,"SmearingTool","Muon::NSWCalibSmearingTool/STgcCalibSmearingTool"};

m_STGCHitCollList

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

private

Definition at line 136 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{};

m_thpcsTGC

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

private

Definition at line 135 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{};

m_timeJitterElectronicsPad

const double sTgcDigitizationTool::m_timeJitterElectronicsPad {2.f}

private

Definition at line 178 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{2.f}; //ns

m_timeJitterElectronicsStrip

const double sTgcDigitizationTool::m_timeJitterElectronicsStrip {2.f}

private

Definition at line 177 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{2.f}; //ns

m_useCondThresholds

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

private

Definition at line 158 of file MuonDigitization/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h.

{this, "useCondThresholds", false, "Use conditions data to get VMM charge threshold values"};

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/sTGC_Digitization/sTGC_Digitization/sTgcDigitizationTool.h
• MuonDigitization/sTGC_Digitization/src/sTgcDigitizationTool.cxx