BCM_DigitizationTool Class Reference

Pileup tool for BCM digitization. More...

#include <BCM_DigitizationTool.h>

Inheritance diagram for BCM_DigitizationTool:

Public Member Functions
	BCM_DigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters.
virtual StatusCode	initialize () override final
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
	PileUpToolBase methods.
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
virtual StatusCode	mergeEvent (const EventContext &ctx) override final

Private Member Functions
StatusCode	createOutputContainers (const EventContext &ctx)
	Create the RDO and SDO containers.
void	processSiHit (const SiHit &currentHit, double eventTime, unsigned int evtIndex, const EventContext &ctx)
void	createRDOsAndSDOs (const EventContext &ctx)
float	computeEnergy (float simEner, const HepGeom::Point3D< double > &startPos, const HepGeom::Point3D< double > &endPos)
	Compute energy deposit depending on hit position.
std::vector< float >	createAnalog (int mod, const std::vector< float > &enerVect, const std::vector< float > &timeVect)
	Fill in hit pulses on analog waveform.
void	addNoise (int mod, std::vector< float > &analog, CLHEP::HepRandomEngine *randomEngine)
	Add noise to analog waveform.
std::bitset< 64 >	applyThreshold (int chan, const std::vector< float > &analog)
	Do ToT digitization.
void	fillRDO (unsigned int chan, int p1x, int p1w, int p2x, int p2w)
	Create raw data object and put it in the container.

Static Private Member Functions
static void	applyFilter (std::bitset< 64 > &digital)
	Apply hole and spike filter to digital waveform.
static void	findPulses (const std::bitset< 64 > &digital, int &p1x, int &p1w, int &p2x, int &p2w)
	Find first two pulses on digital waveform.

Private Attributes
std::vector< float >	m_modNoise
	RMS Gaussian noise.
std::vector< float >	m_modSignal
	Most probable MIP signal.
std::vector< float >	m_ninoThr
	NINO threshold.
Gaudi::Property< float >	m_mipDeposit {this, "MIPDeposit", 0.0f, "Most probable MIP deposit in BCM pad"}
Gaudi::Property< float >	m_effPrmDistance {this, "EffDistanceParam", 0.0f, "Distance parameter for efficiency calculation"}
Gaudi::Property< float >	m_effPrmSharpness {this, "EffSharpnessParam", 0.0f, "Sharpness parameter for efficiency calculation"}
Gaudi::Property< float >	m_timeDelay {this, "TimeDelay", 0.0f, "Pulse time delay"}
BooleanProperty	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
SG::ReadHandleKey< SiHitCollection >	m_hitsContainerKey {this, "HitCollName", "BCMHits", "Input simulation hits collection name"}
std::string	m_inputObjectName {""}
SG::WriteHandleKey< BCM_RDO_Container >	m_outputKey {this, "OutputRDOKey", "BCM_RDOs", ""}
SG::WriteHandleKey< InDetSimDataCollection >	m_outputSDOKey {this, "OutputSDOKey", "BCM_SDO_Map", ""}
BCM_RDO_Container *	m_rdoContainer {}
	Output RDO container.
InDetSimDataCollection *	m_simDataCollMap {}
	Output SDO map.
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service.
std::vector< float >	m_enerVect [8]
	G4 hit energies, weighted.
std::vector< float >	m_timeVect [8]
	G4 hit times.
std::vector< InDetSimData::Deposit >	m_depositVect [8]
	Deposit vectors for SDO map.

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

Pileup tool for BCM digitization.

Definition at line 34 of file BCM_DigitizationTool.h.

Constructor & Destructor Documentation

BCM_DigitizationTool()

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

Constructor with parameters.

Definition at line 26 of file BCM_DigitizationTool.cxx.

                                                                                                                 :
  PileUpToolBase(type,name,parent)
{
  declareProperty("ModNoise", m_modNoise, "RMS noise averaged over modules");
  declareProperty("ModSignal", m_modSignal, "Average MIP signal in modules");
  declareProperty("NinoThr", m_ninoThr, "NINO threshold voltage");
}

Member Function Documentation

addNoise()

void BCM_DigitizationTool::addNoise ( int mod, std::vector< float > & analog, CLHEP::HepRandomEngine * randomEngine )

private

Add noise to analog waveform.

Definition at line 315 of file BCM_DigitizationTool.cxx.

{
  for (float & iBin : analog) iBin+=CLHEP::RandGaussZiggurat::shoot(randomEngine,0.,m_modNoise[iMod]);
}

applyFilter()

void BCM_DigitizationTool::applyFilter ( std::bitset< 64 > & digital )

staticprivate

Apply hole and spike filter to digital waveform.

Definition at line 336 of file BCM_DigitizationTool.cxx.

{
  // 1101, 1011 -> 1111
  for (int iSamp=2; iSamp<63; iSamp++) {
    if (digital[iSamp-2] && digital[iSamp-1] && !digital[iSamp] && digital[iSamp+1]) digital[iSamp] = 1;
    if (digital[iSamp-2] && !digital[iSamp-1] && digital[iSamp] && digital[iSamp+1]) digital[iSamp-1] = 1;
  }
  // 010 -> 000
  if (digital[0] && !digital[1]) digital[0] = 0;
  for (int iSamp=1; iSamp<63; iSamp++) {
    if (!digital[iSamp-1] && digital[iSamp] && !digital[iSamp+1]) digital[iSamp] = 0;
  }
  if (!digital[62] && digital[63]) digital[63] = 0;
}

applyThreshold()

std::bitset< 64 > BCM_DigitizationTool::applyThreshold ( int chan, const std::vector< float > & analog )

private

Do ToT digitization.

Definition at line 323 of file BCM_DigitizationTool.cxx.

{
  std::bitset<64> digital;
  digital.reset();
  float factor = iChan<8 ? 1./13 : 12./13;
  for (int iBin=0; iBin<64; ++iBin)
    if (analog[iBin]*factor>m_ninoThr[iChan%8]) digital.set(iBin);
  return digital;
}

computeEnergy()

float BCM_DigitizationTool::computeEnergy ( float simEner, const HepGeom::Point3D< double > & startPos, const HepGeom::Point3D< double > & endPos )

private

Compute energy deposit depending on hit position.

Definition at line 264 of file BCM_DigitizationTool.cxx.

{
  // Initialize output energy
  float calcEner = 0;
  // Break hit up into 10 discrete energy deposits
  // For each deposit, weight energy by charge collection efficiency based on position on diamond surface
  float xStep, yStep, rStep, r0Step, effStep;
  for (int iStep=0; iStep<10; ++iStep) {
    xStep = startPos.x()+iStep*(endPos.x()-startPos.x())/9;
    yStep = startPos.y()+iStep*(endPos.y()-startPos.y())/9;
    if (xStep==0 && yStep==0) effStep = 1.;
    else {
      rStep = sqrt(pow(xStep,2)+pow(yStep,2));
      r0Step = std::abs(yStep)>std::abs(xStep) ? rStep*m_effPrmDistance/std::abs(yStep) : rStep*m_effPrmDistance/std::abs(xStep);
      effStep = 1/(1+std::exp((rStep-r0Step)/m_effPrmSharpness));
    }
    calcEner+= 0.1*simEner*effStep;
  }
  return calcEner;
}

createAnalog()

std::vector< float > BCM_DigitizationTool::createAnalog ( int mod, const std::vector< float > & enerVect, const std::vector< float > & timeVect )

private

Fill in hit pulses on analog waveform.

Definition at line 288 of file BCM_DigitizationTool.cxx.

{
  std::vector<float> analog(64,0);
  for (unsigned int iHit=0; iHit<enerVect.size(); ++iHit) {
    float enerDep = enerVect.at(iHit);
    float hitTime = timeVect.at(iHit);
    int startBin = (int)(hitTime*64/25);
    float signalMax = enerDep*m_modSignal[iMod]/m_mipDeposit;
    float slopeup = signalMax/5; // pulse rise in 2ns ~ 5 bins @ 390ps/bin
    float slopedown = signalMax/10; // pulse fall in 3.8ns ~ 10 bins @ 390ps/bin
    int iBin = startBin-1;
    float signal = 0;
    if (iBin>=0 && startBin<64) {
      while (signal>=0 && iBin<64) {
        analog[iBin] += signal;
        signal += slopeup;
        if (iBin > startBin+4) signal -= slopeup+slopedown;
        iBin++;
      }
    }
  }
  return analog;
}

createOutputContainers()

StatusCode BCM_DigitizationTool::createOutputContainers ( const EventContext & ctx )

private

Create the RDO and SDO containers.

Definition at line 71 of file BCM_DigitizationTool.cxx.

{
  // Creating output RDO container
  SG::WriteHandle<BCM_RDO_Container> outputContainer(m_outputKey, ctx);
  ATH_CHECK(outputContainer.record(std::make_unique<BCM_RDO_Container>()));
  if (!outputContainer.isValid()) {
    ATH_MSG_ERROR("Could not record output BCM RDO container " << outputContainer.name() << " to store " << outputContainer.store());
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Recorded output BCM RDO container " << outputContainer.name() << " in store " << outputContainer.store());
  m_rdoContainer = outputContainer.ptr();
 
  // Creating output SDO collection container
  SG::WriteHandle<InDetSimDataCollection> outputSDOContainer(m_outputSDOKey, ctx);
  ATH_CHECK(outputSDOContainer.record(std::make_unique<InDetSimDataCollection>()));
  if (!outputSDOContainer.isValid()) {
    ATH_MSG_ERROR("Could not record output BCM SDO container " << outputSDOContainer.name() << " to store " << outputSDOContainer.store());
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Recorded output BCM SDO container " << outputSDOContainer.name() << " in store " << outputSDOContainer.store());
  m_simDataCollMap = outputSDOContainer.ptr();
 
 
  // Clear G4 hit info vectors
  for (unsigned int iMod=0; iMod<8; ++iMod) {
    m_enerVect[iMod].clear();
    m_timeVect[iMod].clear();
    m_depositVect[iMod].clear();
  }
 
  return StatusCode::SUCCESS;
}

createRDOsAndSDOs()

void BCM_DigitizationTool::createRDOsAndSDOs ( const EventContext & ctx )

private

Definition at line 126 of file BCM_DigitizationTool.cxx.

{
  // Set the RNG to use for this event.
  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this);
  rngWrapper->setSeed( name(), ctx );
 
  // Digitize hit info and create RDO for each module
  for (int iMod=0; iMod<8; ++iMod) {
    if (!m_depositVect[iMod].empty()) m_simDataCollMap->emplace(Identifier(iMod), m_depositVect[iMod]);
    std::vector<float> analog = createAnalog(iMod,m_enerVect[iMod],m_timeVect[iMod]);
    addNoise(iMod,analog, rngWrapper->getEngine(ctx));
    for (int iGain=0; iGain<2; ++iGain) {
      std::bitset<64> digital = applyThreshold(iGain*8+iMod,analog);
      int p1x,p1w,p2x,p2w;
      applyFilter(digital);
      findPulses(digital,p1x,p1w,p2x,p2w);
      fillRDO(iGain*8+iMod,p1x,p1w,p2x,p2w);
    }
  }
  }

fillRDO()

void BCM_DigitizationTool::fillRDO ( unsigned int chan, int p1x, int p1w, int p2x, int p2w )

private

Create raw data object and put it in the container.

Definition at line 434 of file BCM_DigitizationTool.cxx.

{
  BCM_RDO_Collection *RDOColl = nullptr;
  // Check if collection for this channel already exists
  bool collExists = false;
  BCM_RDO_Container::iterator it_coll = m_rdoContainer->begin();
  BCM_RDO_Container::iterator it_collE= m_rdoContainer->end();
  for (; it_coll!=it_collE; ++it_coll) {
    if ((*it_coll)->getChannel()==chan) {
      collExists = true;
      RDOColl = *it_coll;
    }
  }
  // Create the RDO collection if needed
  if (!collExists) {
    RDOColl = new BCM_RDO_Collection(chan);
    // Add collection to container
    m_rdoContainer->push_back(RDOColl);
  }
  // Create RDO & add it to collection
  BCM_RawData *bcmrdo = new BCM_RawData(chan,p1x,p1w,p2x,p2w,0,0,0);
  if (bcmrdo) RDOColl->push_back(bcmrdo);
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

findPulses()

void BCM_DigitizationTool::findPulses ( const std::bitset< 64 > & digital, int & p1x, int & p1w, int & p2x, int & p2w )

staticprivate

Find first two pulses on digital waveform.

Definition at line 354 of file BCM_DigitizationTool.cxx.

{
  p1x = 0; p1w = 0; p2x = 0; p2w = 0;
 
  if (!digital.count()) return; // skip if waveform is empty
 
  bool p1done = false, p2done = false; bool ignorepulse = false;
  if (digital[0] && digital[1]) ignorepulse = true;
  else if (!digital[0] && digital[1] && digital[2]) p1x = 1;
  for (int iBin=2; iBin<63; iBin++) {
    if (!digital[iBin-2] && !digital[iBin-1] && digital[iBin] && digital[iBin+1]) { // rising edge
      if (!p1done && !p2done) p1x = iBin;
      else if (p1done && !p2done) p2x = iBin;
    }
    else if (digital[iBin-2] && digital[iBin-1] && !digital[iBin] && !digital[iBin+1]) { // falling edge
      if (!ignorepulse) {
        if (!p1done && !p2done) {
          p1w = iBin - p1x;
          p1done = true;
          if (p1w >= 32) {
            p2x = p1x + 31;
            p2w = p1w - 31;
            p2done = true;
            p1w = 31;
          }
        }
        else if (p1done && !p2done) {
          p2w = iBin - p2x;
          p2done = true;
          if (p2w >= 32) p2w = 31;
        }
      }
      else ignorepulse = false;
    }
  }
  if (digital[61] && digital[62] && !digital[63]) {
    if (!ignorepulse) {
      if (!p1done && !p2done) {
        p1w = 63 - p1x;
        p1done = true;
        if (p1w >= 32) {
          p2x = p1x + 31;
          p2w = p1w - 31;
          p2done = true;
          p1w = 31;
        }
      }
      else if (p1done && !p2done) {
        p2w = 63 - p2x;
        p2done = true;
        if (p2w >= 32) p2w = 31;
      }
    }
    else ignorepulse = false;
  }
  else if (digital[62] && digital[63]) {
    if (!ignorepulse) {
      if (!p1done && !p2done) {
        p1w = 1;
        p1done = true;
        if (64 - p1x >= 32) {
          p2x = p1x + 31;
          p2w = 1;
          p2done = true;
          p1w = 31;
        }
      }
      else if (p1done && !p2done) {
        p2w = 1;
        p2done = true;
        if (64 - p2x >= 32) p2w = 31;
      }
    }
    else ignorepulse = false;
  }
}

initialize()

StatusCode BCM_DigitizationTool::initialize ( )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 37 of file BCM_DigitizationTool.cxx.

{
  ATH_MSG_VERBOSE ( "initialize()");
 
  if (m_onlyUseContainerName) {
    ATH_CHECK(m_mergeSvc.retrieve());
  }
 
  // get random service
  ATH_CHECK(m_rndmGenSvc.retrieve());
 
  // check the input object name
  if (m_hitsContainerKey.key().empty()) {
    ATH_MSG_FATAL("Property InputObjectName not set !");
    return StatusCode::FAILURE;
  }
  if(m_onlyUseContainerName) m_inputObjectName = m_hitsContainerKey.key();
  ATH_MSG_DEBUG("Input objects in container : '" << m_inputObjectName << "'");
 
  // Initialize ReadHandleKey
  ATH_CHECK(m_hitsContainerKey.initialize(true));
 
  // Write handle keys
  ATH_CHECK( m_outputKey.initialize() );
  ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputKey);
  ATH_CHECK( m_outputSDOKey.initialize() );
  ATH_MSG_VERBOSE("Initialized WriteHandleKey: " << m_outputSDOKey);
 
  return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode BCM_DigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

Definition at line 252 of file BCM_DigitizationTool.cxx.

{
  ATH_MSG_DEBUG ( "mergeEvent()" );
 
  createRDOsAndSDOs(ctx);
 
  return StatusCode::SUCCESS;
}

prepareEvent()

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

finaloverridevirtual

PileUpToolBase methods.

Definition at line 150 of file BCM_DigitizationTool.cxx.

{
  ATH_MSG_DEBUG ( "prepareEvent() called for " << nInputEvents << " input events" );
 
  CHECK(createOutputContainers(ctx));
 
  return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode BCM_DigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

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

Reimplemented from PileUpToolBase.

Definition at line 162 of file BCM_DigitizationTool.cxx.

{
  ATH_MSG_DEBUG ( "processAllSubEvents()" );
 
  ATH_CHECK(createOutputContainers(ctx));
 
  // Fetch SiHitCollections for this bunch crossing
  if (!m_onlyUseContainerName) {
    SG::ReadHandle<SiHitCollection> hitCollection(m_hitsContainerKey, ctx);
    if (!hitCollection.isValid()) {
      ATH_MSG_ERROR("Could not get BCM SiHitCollection container " << hitCollection.name() <<
                    " from store " << hitCollection.store());
      return StatusCode::FAILURE;
    }
    const unsigned int evtIndex = 0;
    const double time = 0.0;
    ATH_MSG_DEBUG ( "SiHitCollection found with " << hitCollection->size() << " hits" );
    // Read hits from this collection
    for (const auto& siHit : *hitCollection) {
      processSiHit(siHit, time, evtIndex, ctx);
    }
 
  }
  else {
    using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
    TimedHitCollList hitCollList;
    if (!(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList).isSuccess()) && hitCollList.empty()) {
      ATH_MSG_ERROR ( "Could not fill TimedHitCollList" );
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG ( hitCollList.size() << " SiHitCollections with key " << m_inputObjectName << " found" );
    }
 
    // Store hit info in vectors and fill SDO map
    TimedHitCollList::iterator iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end());
    for (; iColl != endColl; ++iColl) {
      const SiHitCollection* tmpColl(iColl->second);
      const unsigned int evtIndex = (iColl->first).index();
      const double time = (iColl->first).time();
      ATH_MSG_DEBUG ( "SiHitCollection found with " << tmpColl->size() << " hits" );
      // Read hits from this collection
      for (const auto& siHit : *tmpColl) {
        processSiHit(siHit, time, evtIndex, ctx);
      }
    }
  }
 
  createRDOsAndSDOs(ctx);
 
  return StatusCode::SUCCESS;
}

processBunchXing()

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

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 218 of file BCM_DigitizationTool.cxx.

{
  const EventContext &ctx = Gaudi::Hive::currentContext();
 
  ATH_MSG_DEBUG ( "processBunchXing() " << bunchXing );
 
  SubEventIterator iEvt = bSubEvents;
  for (; iEvt!=eSubEvents; ++iEvt) {
    StoreGateSvc& seStore = *iEvt->ptr()->evtStore();
    ATH_MSG_VERBOSE ( "SubEvt StoreGate " << seStore.name() << " :"
                      << " bunch crossing : " << bunchXing
                      << " time offset : " << iEvt->time()
                      << " event number : " << iEvt->ptr()->eventNumber()
                      << " run number : " << iEvt->ptr()->runNumber()
                      );
    const SiHitCollection* seHitColl = nullptr;
    CHECK(seStore.retrieve(seHitColl,m_inputObjectName));
    ATH_MSG_DEBUG ( "SiHitCollection found with " << seHitColl->size() << " hits" );
    SiHitCollection::const_iterator i = seHitColl->begin();
    SiHitCollection::const_iterator e = seHitColl->end();
    // Read hits from this collection
    for (; i!=e; ++i) {
      processSiHit(*i, iEvt->time(), iEvt->index(), ctx);
    }
  }
 
  return StatusCode::SUCCESS;
}

processSiHit()

void BCM_DigitizationTool::processSiHit ( const SiHit & currentHit, double eventTime, unsigned int evtIndex, const EventContext & ctx )

private

Definition at line 109 of file BCM_DigitizationTool.cxx.

{
  const int moduleNo = currentHit.getLayerDisk();
  const float enerDep = computeEnergy(currentHit.energyLoss(), currentHit.localStartPosition(), currentHit.localEndPosition());
  const float hitTime = currentHit.meanTime() + eventTime + m_timeDelay;
  // Fill vectors with hit info
  m_enerVect[moduleNo].push_back(enerDep);
  m_timeVect[moduleNo].push_back(hitTime);
  // Create new deposit and add to vector
  const HepMcParticleLink particleLink = HepMcParticleLink::getRedirectedLink(currentHit.particleLink(), evtIndex, ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
  if (HepMC::no_truth_link(particleLink)) return;
  m_depositVect[moduleNo].emplace_back(particleLink,currentHit.energyLoss());
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

Member Data Documentation

m_depositVect

std::vector<InDetSimData::Deposit> BCM_DigitizationTool::m_depositVect[8]

private

Deposit vectors for SDO map.

Definition at line 106 of file BCM_DigitizationTool.h.

m_effPrmDistance

Gaudi::Property<float> BCM_DigitizationTool::m_effPrmDistance {this, "EffDistanceParam", 0.0f, "Distance parameter for efficiency calculation"}

private

Definition at line 84 of file BCM_DigitizationTool.h.

{this, "EffDistanceParam", 0.0f, "Distance parameter for efficiency calculation"};

m_effPrmSharpness

Gaudi::Property<float> BCM_DigitizationTool::m_effPrmSharpness {this, "EffSharpnessParam", 0.0f, "Sharpness parameter for efficiency calculation"}

private

Definition at line 85 of file BCM_DigitizationTool.h.

{this, "EffSharpnessParam", 0.0f, "Sharpness parameter for efficiency calculation"};

m_enerVect

std::vector<float> BCM_DigitizationTool::m_enerVect[8]

private

G4 hit energies, weighted.

Definition at line 104 of file BCM_DigitizationTool.h.

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<SiHitCollection> BCM_DigitizationTool::m_hitsContainerKey {this, "HitCollName", "BCMHits", "Input simulation hits collection name"}

private

Definition at line 89 of file BCM_DigitizationTool.h.

{this, "HitCollName", "BCMHits", "Input simulation hits collection name"};

m_inputObjectName

std::string BCM_DigitizationTool::m_inputObjectName {""}

private

Definition at line 90 of file BCM_DigitizationTool.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_mergeSvc

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

private

Definition at line 100 of file BCM_DigitizationTool.h.

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

m_mipDeposit

Gaudi::Property<float> BCM_DigitizationTool::m_mipDeposit {this, "MIPDeposit", 0.0f, "Most probable MIP deposit in BCM pad"}

private

Definition at line 83 of file BCM_DigitizationTool.h.

{this, "MIPDeposit", 0.0f, "Most probable MIP deposit in BCM pad"};

m_modNoise

std::vector<float> BCM_DigitizationTool::m_modNoise

private

RMS Gaussian noise.

Definition at line 80 of file BCM_DigitizationTool.h.

m_modSignal

std::vector<float> BCM_DigitizationTool::m_modSignal

private

Most probable MIP signal.

Definition at line 81 of file BCM_DigitizationTool.h.

m_ninoThr

std::vector<float> BCM_DigitizationTool::m_ninoThr

private

NINO threshold.

Definition at line 82 of file BCM_DigitizationTool.h.

m_onlyUseContainerName

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

private

Definition at line 88 of file BCM_DigitizationTool.h.

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

m_outputKey

SG::WriteHandleKey<BCM_RDO_Container> BCM_DigitizationTool::m_outputKey {this, "OutputRDOKey", "BCM_RDOs", ""}

private

Definition at line 93 of file BCM_DigitizationTool.h.

{this, "OutputRDOKey", "BCM_RDOs", ""};

m_outputSDOKey

SG::WriteHandleKey<InDetSimDataCollection> BCM_DigitizationTool::m_outputSDOKey {this, "OutputSDOKey", "BCM_SDO_Map", ""}

private

Definition at line 94 of file BCM_DigitizationTool.h.

{this, "OutputSDOKey", "BCM_SDO_Map", ""};

m_rdoContainer

BCM_RDO_Container* BCM_DigitizationTool::m_rdoContainer {}

private

Output RDO container.

Definition at line 97 of file BCM_DigitizationTool.h.

{}; 

m_rndmGenSvc

ServiceHandle<IAthRNGSvc> BCM_DigitizationTool::m_rndmGenSvc {this, "RndmSvc", "AthRNGSvc", ""}

private

Random number service.

Definition at line 101 of file BCM_DigitizationTool.h.

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

m_simDataCollMap

InDetSimDataCollection* BCM_DigitizationTool::m_simDataCollMap {}

private

Output SDO map.

Definition at line 98 of file BCM_DigitizationTool.h.

{}; 

m_timeDelay

Gaudi::Property<float> BCM_DigitizationTool::m_timeDelay {this, "TimeDelay", 0.0f, "Pulse time delay"}

private

Definition at line 86 of file BCM_DigitizationTool.h.

{this, "TimeDelay", 0.0f, "Pulse time delay"};

m_timeVect

std::vector<float> BCM_DigitizationTool::m_timeVect[8]

private

G4 hit times.

Definition at line 105 of file BCM_DigitizationTool.h.

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

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

Definition at line 58 of file PileUpToolBase.h.

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

---

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

• BCM_DigitizationTool.h
• BCM_DigitizationTool.cxx