EnergyDepositionTool Class Reference

#include <EnergyDepositionTool.h>

Inheritance diagram for EnergyDepositionTool:

Collaboration diagram for EnergyDepositionTool:

Public Member Functions
	EnergyDepositionTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
virtual	~EnergyDepositionTool ()
StatusCode	initTools ()
std::vector< std::pair< double, double > >	bichselSim (double BetaGamma, int ParticleType, double TotalLength, double InciEnergy, CLHEP::HepRandomEngine *rndmEngine) const
std::vector< std::pair< double, double > >	clusterHits (std::vector< std::pair< double, double > > &rawHitRecord, int n_pieces) const
virtual StatusCode	depositEnergy (const TimedHitPtr< SiHit > &phit, const InDetDD::SiDetectorElement &Module, std::vector< std::pair< double, double > > &trfHitRecord, std::vector< double > &initialConditions, CLHEP::HepRandomEngine *rndmEngine, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	EnergyDepositionTool ()
void	simulateBow (const InDetDD::SiDetectorElement *element, double &xi, double &yi, const double zi, double &xf, double &yf, const double zf) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const PixelID *	m_pixelID
std::vector< BichselData >	m_bichselData
Gaudi::Property< int >	m_numberOfSteps
Gaudi::Property< int >	m_numberOfCharges
Gaudi::Property< bool >	m_disableDistortions
Gaudi::Property< bool >	m_doBichsel
Gaudi::Property< double >	m_doBichselBetaGammaCut
Gaudi::Property< bool >	m_doDeltaRay
Gaudi::Property< double >	m_DeltaRayCut
Gaudi::Property< bool >	m_doPU
Gaudi::Property< int >	m_nCols
Gaudi::Property< int >	m_LoopLimit
SG::ReadCondHandleKey< PixelDistortionData >	m_distortionKey
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 43 of file EnergyDepositionTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

EnergyDepositionTool() [1/2]

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

Definition at line 83 of file EnergyDepositionTool.cxx.

                                                                                                                 :
  AthAlgTool(type, name, parent) {}

~EnergyDepositionTool()

EnergyDepositionTool::~EnergyDepositionTool ( )

virtualdefault

EnergyDepositionTool() [2/2]

EnergyDepositionTool::EnergyDepositionTool ( )

private

Member Function Documentation

bichselSim()

std::vector< std::pair< double, double > > EnergyDepositionTool::bichselSim	(	double	BetaGamma,
		int	ParticleType,
		double	TotalLength,
		double	InciEnergy,
		CLHEP::HepRandomEngine *	rndmEngine ) const

Definition at line 308 of file EnergyDepositionTool.cxx.

                                                               {
  ATH_MSG_DEBUG("Begin EnergyDepositionTool::bichselSim");
 
  // prepare hit record (output)
  std::vector<std::pair<double, double> > rawHitRecord;
  double TotalEnergyLoss = 0.;
  double accumLength = 0.;
  
  if (BetaGamma <= std::numeric_limits<double>::min()){
    setFailureFlag(rawHitRecord);
    return rawHitRecord;
  }
 
  // load relevant data
  const BichselData& iData = m_bichselData[ParticleType - 1];
  double BetaGammaLog10 = std::log10(BetaGamma);
  std::pair<int, int> indices_BetaGammaLog10 = iData.getBetaGammaIndices(BetaGammaLog10);
 
  // upper bound
  double IntXUpperBound = iData.interpolateCrossSection(indices_BetaGammaLog10, BetaGammaLog10);
  if (IntXUpperBound <= 0.) {
    ATH_MSG_WARNING("Negative IntXUpperBound in EnergyDepositionTool::bichselSim! (-1,-1) will be returned for log(betaGamma) = "<<BetaGammaLog10);
    setFailureFlag(rawHitRecord);
    return rawHitRecord;
  }
  
  if(IntXUpperBound<std::numeric_limits<double>::min()){
    setFailureFlag(rawHitRecord);
    return rawHitRecord;
  }
  
  // mean-free path
  double lambda = (1. / IntXUpperBound) * 1.E4;   // unit of IntX is cm-1. It needs to be converted to micrometer-1
 
 
  // direct those hits with potential too many steps into nominal simulation
  int LoopLimit = m_LoopLimit;                         // limit assuming 1 collision per sampling
  if (std::abs(1.0 * TotalLength / lambda) > LoopLimit) {       // m_nCols is cancelled out in the formula
    setFailureFlag(rawHitRecord);
    return rawHitRecord;
  }
 
  // begin simulation
  int count = 0;
  while (true) {
    // infinite loop protection
    if (count >= (1.0 * LoopLimit / m_nCols)) {
      ATH_MSG_WARNING(
          "Potential infinite loop in bichselSim. Exit Loop. A special flag "
          "will be returned (-1,-1). The total length is "
          << TotalLength << ". The lambda is " << lambda << ".");
      setFailureFlag(rawHitRecord);
      break;
    }
 
    // sample hit position -- exponential distribution
    double HitPosition = 0.;
    for (int iHit = 0; iHit < m_nCols; iHit++) {
      HitPosition += CLHEP::RandExpZiggurat::shoot(rndmEngine, lambda);
    }
    // termination by hit position
    // yes, in case m_nCols > 1, we will loose the last m_nCols collisions. So m_nCols cannot be too big
    if (accumLength + HitPosition >= TotalLength) break;
 
    // sample single collision
    double TossEnergyLoss = -1.;
    while (TossEnergyLoss <= 0.) { // we have to do this because sometimes TossEnergyLoss will be negative due to too
                                   // small TossIntX
      double TossIntX = CLHEP::RandFlat::shoot(rndmEngine, 0., IntXUpperBound);
      TossEnergyLoss = iData.interpolateCollisionEnergy(indices_BetaGammaLog10, std::log10(TossIntX));
    }
 
    // check if it is delta-ray -- delta-ray is already taken care of by G4 and treated as an independent hit.
    // Unfortunately, we won't deal with delta-ray using Bichsel's model
    // as long as m_nCols is not very big, the probability of having >= 2 such a big energy loss in a row is very small.
    // In case there is a delta-ray, it would be so dominant that other energy deposition becomes negligible
    if (TossEnergyLoss > (m_DeltaRayCut * 1000.)) {
      TossEnergyLoss = 0.;
    }
 
    bool fLastStep = false;
 
    if (((TotalEnergyLoss + TossEnergyLoss) / 1.E+6) > InciEnergy) {
      ATH_MSG_WARNING(
        "Energy loss is larger than incident energy in EnergyDepositionTool::bichselSim! This is usually delta-ray.");
      TossEnergyLoss = InciEnergy * 1.E+6 - TotalEnergyLoss;
      fLastStep = true;
    }
 
    // update
    accumLength += HitPosition;
    TotalEnergyLoss += TossEnergyLoss;
 
    // record this hit
    std::pair<double, double> oneHit;
    if (m_nCols == 1) oneHit.first = accumLength;
    else oneHit.first = (accumLength - 1.0 * HitPosition / 2);// as long as m_nCols is small enough (making sure lambda*m_nCols is within resolution of a pixel), then taking middle point might still be reasonable
    oneHit.second = TossEnergyLoss;
    rawHitRecord.push_back(oneHit);
 
    count++;
 
    if (fLastStep) break;
  }
 
  ATH_MSG_DEBUG("Finish EnergyDepositionTool::bichselSim");
 
  return rawHitRecord;
}

clusterHits()

std::vector< std::pair< double, double > > EnergyDepositionTool::clusterHits	(	std::vector< std::pair< double, double > > &	rawHitRecord,
		int	n_pieces ) const

Definition at line 422 of file EnergyDepositionTool.cxx.

                                                                                              {
  ATH_MSG_DEBUG("Begin EnergyDepositionTool::clusterHits");
  std::vector<std::pair<double, double> > trfHitRecord;
 
  if (static_cast<int>(rawHitRecord.size()) < n_pieces) { // each single collision is the most fundamental unit
    n_pieces = rawHitRecord.size();
  }
 
  int unitlength = int(1.0 * rawHitRecord.size() / n_pieces);
  int index_start = 0;
  int index_end = unitlength - 1;   // [index_start, index_end] are included
  while (true) {
    // calculate weighted center of each slice
    double position = 0.;
    double energyloss = 0.;
 
    for (int index = index_start; index <= index_end; index++) {
      position += (rawHitRecord[index].first * rawHitRecord[index].second);
      energyloss += rawHitRecord[index].second;
    }
    position = (energyloss == 0. ? 0. : position / energyloss);
 
    // store
    std::pair<double, double> oneHit;
    oneHit.first = position;
    oneHit.second = energyloss;
    trfHitRecord.push_back(oneHit);
 
    // procede to next slice
    index_start = index_end + 1;
    index_end = index_start + unitlength - 1;
 
    if (index_start > static_cast<int>(rawHitRecord.size() - 1)) {
      break;
    }
 
    if (index_end > static_cast<int>(rawHitRecord.size() - 1)) {
      index_end = rawHitRecord.size() - 1;
    }
  }
 
  ATH_MSG_DEBUG("Finish EnergyDepositionTool::clusterHits");
 
  return trfHitRecord;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

depositEnergy()

StatusCode EnergyDepositionTool::depositEnergy ( const TimedHitPtr< SiHit > & phit, const InDetDD::SiDetectorElement & Module, std::vector< std::pair< double, double > > & trfHitRecord, std::vector< double > & initialConditions, CLHEP::HepRandomEngine * rndmEngine, const EventContext & ctx ) const

virtual

Definition at line 135 of file EnergyDepositionTool.cxx.

                                                                              {
  ATH_MSG_DEBUG("Deposit energy in sensor volume.");
 
  //Check if simulated particle or delta ray
  const HepMcParticleLink McLink = HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
 HepMC::ConstGenParticlePtr genPart = McLink.cptr();
  bool delta_hit = true;
  if (genPart) delta_hit = false;
  double sensorThickness = Module.design().thickness();
 
 
  //Get path of particle through volume of G4
  double stepsize = sensorThickness / m_numberOfSteps;
  const CLHEP::Hep3Vector startPosition = phit->localStartPosition();
  const CLHEP::Hep3Vector endPosition = phit->localEndPosition();
 
  //Get entry and exit positions, store for SensorSim tools
  double eta_0 = startPosition[SiHit::xEta];
  double phi_0 = startPosition[SiHit::xPhi];
  const double depth_0 = startPosition[SiHit::xDep];
 
  double eta_f = endPosition[SiHit::xEta];
  double phi_f = endPosition[SiHit::xPhi];
  const double depth_f = endPosition[SiHit::xDep];
 
  //Simulate effect of bowing on entry and exit points
  if (!m_disableDistortions && !delta_hit) simulateBow(&Module, phi_0, eta_0, depth_0, phi_f, eta_f, depth_f);
 
  double dEta = eta_f - eta_0;
  double dPhi = phi_f - phi_0;
  const double dDepth = depth_f - depth_0;
  double pathLength = std::sqrt(dEta * dEta + dPhi * dPhi + dDepth * dDepth);
 
  //Scale steps and charge chunks
  const int nsteps = int(pathLength / stepsize) + 1;
  const int ncharges = this->m_numberOfCharges * this->m_numberOfSteps / nsteps + 1;
 
  //Store information
  initialConditions.clear();
  initialConditions = {eta_0, phi_0, depth_0, dEta, dPhi, dDepth, static_cast<double>(ncharges)};

  // ***                For Bichsel               *** //
  double iTotalLength = pathLength * 1000.;   // mm -> micrometer
  initialConditions.push_back(iTotalLength);
 
  // -1 ParticleType means we are unable to run Bichel simulation for this case
  int ParticleType = -1;
  if (m_doBichsel and !(Module.isDBM()) and genPart) {
    ParticleType = delta_hit ? (m_doDeltaRay ? 4 : -1) : trfPDG(genPart->pdg_id());
    if (ParticleType != -1) { // this is a protection in case delta_hit == true (a delta ray)
      TLorentzVector genPart_4V;
 
      if (genPart) { // non-delta-ray
        genPart_4V.SetPtEtaPhiM(genPart->momentum().perp(), genPart->momentum().eta(),
                                genPart->momentum().phi(), genPart->momentum().m());
        if (iBetaGammaFn(genPart_4V) < m_doBichselBetaGammaCut){
          ParticleType = -1;
        }        
      } else { // delta-ray.
        double k = phit->energyLoss() / CLHEP::MeV;     // unit of MeV
        if (iBetaGammaFn(k) < m_doBichselBetaGammaCut){
          ParticleType = -1;
        } 
      }
 
      // In-time PU
      if (!m_doPU) {
        if (phit.eventId() != 0) ParticleType = -1;
      }
 
      // Out-of-time PU
      // We don't cut on the out-of-time PU, since studies show that the fraction is too small
    }
  }
 
  if (ParticleType != -1) { // yes, good to go with Bichsel
    // I don't know why genPart->momentum() goes crazy ...
    TLorentzVector genPart_4V;
    double iBetaGamma=0.;
    if (genPart) {
      genPart_4V.SetPtEtaPhiM(genPart->momentum().perp(), genPart->momentum().eta(),
                              genPart->momentum().phi(), genPart->momentum().m());
      iBetaGamma = iBetaGammaFn(genPart_4V);
    } else {
      double k = phit->energyLoss() / CLHEP::MeV;     // unit of MeV                            // unit of MeV
      iBetaGamma = iBetaGammaFn(k);
    }
 
    int iParticleType = ParticleType;
    // begin simulation
    std::vector<std::pair<double, double> > rawHitRecord = bichselSim(iBetaGamma, iParticleType, iTotalLength,
                                                                      genPart ? (genPart->momentum().e() /
                                                                                 CLHEP::MeV) : (phit->energyLoss() /
                                                                                                CLHEP::MeV),
    rndmEngine);
 
    // check if returned simulation result makes sense
    if (rawHitRecord.empty()) { // deal with rawHitRecord==0 specifically -- no energy deposition
      std::pair<double, double> specialHit;
      specialHit.first = 0.;
      specialHit.second = 0.;
      trfHitRecord.push_back(specialHit);
    } else if ((rawHitRecord.size() == 1) && (rawHitRecord[0].first == -1.) && (rawHitRecord[0].second == -1.)) { // special flag returned from bichselSim meaning it FAILs
      for (int j = 0; j < nsteps; j++) { // do the same thing as old digitization method
        std::pair<double, double> specialHit;
        specialHit.first = 1.0 * iTotalLength / nsteps * (j + 0.5);
        specialHit.second = phit->energyLoss() * 1.E+6 / nsteps;
        trfHitRecord.push_back(specialHit);
      }
    } else { // cluster thousands hits to ~20 groups
      trfHitRecord = clusterHits(rawHitRecord, nsteps);
    }
  } else { // same as old digitization method
    // ***         B I C H S E L    O F F           *** //
    //double iTotalLength = pathLength*1000.;   // mm -> micrometer
    for (int j = 0; j < nsteps; j++) { // do the same thing as old digitization method
      std::pair<double, double> specialHit;
      specialHit.first = 1.0 * iTotalLength / nsteps * (j + 0.5);
      specialHit.second = phit->energyLoss() * 1.E+6 / nsteps;
      trfHitRecord.push_back(specialHit);
    }
  }
 
  // *** Finsih Bichsel *** //
  return StatusCode::SUCCESS;
}

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode EnergyDepositionTool::finalize ( )

virtual

Definition at line 127 of file EnergyDepositionTool.cxx.

                                          {
  ATH_MSG_DEBUG("EnergyDepositionTool::finalize()");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode EnergyDepositionTool::initialize ( )

virtual

Definition at line 91 of file EnergyDepositionTool.cxx.

                                            {
  ATH_MSG_INFO("You are using EnergyDepositionTool for solid-state silicon detectors.");
 
  ATH_CHECK(detStore()->retrieve(m_pixelID, "PixelID"));
 
  //Setup distortions tool
  if (!m_disableDistortions) {
    ATH_MSG_DEBUG("Getting distortions tool");
    ATH_CHECK(m_distortionKey.initialize());
  }
 
 if (m_doBichsel) {
    // Load Bichsel data
    m_bichselData.clear();
    ATH_MSG_INFO("The number of collision for each sampling is " << m_nCols);
    ATH_MSG_INFO("Loading data file");
    int n_ParticleType = 6;
    for (int iParticleType = 1; iParticleType <= n_ParticleType; iParticleType++) {
      const std::string & inputFileName(PixelDigitization::formBichselDataFileName(iParticleType, m_nCols));
      const std::string & fullFileName = PathResolverFindCalibFile(inputFileName);
      ATH_MSG_INFO("Bichsel Data File "<<fullFileName);
      BichselData iData = PixelDigitization::getBichselDataFromFile(fullFileName);
      m_bichselData.push_back(iData);
    }
    ATH_MSG_INFO("Finish Loading Data File");
  }
 
 
  m_doDeltaRay = (m_doBichsel && m_doDeltaRay);    // if we don't do Bichsel model, no re-simulation on delta-ray at
                                                   // all!
  return StatusCode::SUCCESS;
}

initTools()

StatusCode EnergyDepositionTool::initTools

(

)

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & EnergyDepositionTool::interfaceID ( )

static

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

simulateBow()

void EnergyDepositionTool::simulateBow ( const InDetDD::SiDetectorElement * element, double & xi, double & yi, const double zi, double & xf, double & yf, const double zf ) const

private

Definition at line 273 of file EnergyDepositionTool.cxx.

                                                                                                       {
  // If tool is NONE we apply no correction.
  Amg::Vector3D dir(element->hitPhiDirection() * (xf - xi),
                    element->hitEtaDirection() * (yf - yi), element->hitDepthDirection() * (zf - zi));
 
  Amg::Vector2D locposi = element->hitLocalToLocal(yi, xi);
  Amg::Vector2D locposf = element->hitLocalToLocal(yf, xf);
 
  Amg::Vector2D newLocposi = SG::ReadCondHandle<PixelDistortionData>(m_distortionKey)->correctSimulation(m_pixelID->wafer_hash(
                                                                                                           element->
                                                                                                            identify()), locposi,
                                                                                                         dir);
  Amg::Vector2D newLocposf = SG::ReadCondHandle<PixelDistortionData>(m_distortionKey)->correctSimulation(m_pixelID->wafer_hash(
                                                                                                           element->
                                                                                                            identify()), locposf,
                                                                                                         dir);
 
  // Extract new coordinates and convert back to hit frame.
  xi = newLocposi[Trk::x] * element->hitPhiDirection();
  yi = newLocposi[Trk::y] * element->hitEtaDirection();
 
  xf = newLocposf[Trk::x] * element->hitPhiDirection();
  yf = newLocposf[Trk::y] * element->hitEtaDirection();
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_bichselData

std::vector<BichselData> EnergyDepositionTool::m_bichselData

private

Definition at line 73 of file EnergyDepositionTool.h.

m_DeltaRayCut

Gaudi::Property<double> EnergyDepositionTool::m_DeltaRayCut

private

Initial value:

{
    this, "DeltaRayCut", 80.7687, "Cut of delta ray [keV] - Value should be consistent with range cut in simulation"
  }

Definition at line 105 of file EnergyDepositionTool.h.

  {
    this, "DeltaRayCut", 80.7687, "Cut of delta ray [keV] - Value should be consistent with range cut in simulation"
  };

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_disableDistortions

Gaudi::Property<bool> EnergyDepositionTool::m_disableDistortions

private

Initial value:

{
    this, "DisableDistortions", false, "Disable simulation of module distortions"
  }

Definition at line 85 of file EnergyDepositionTool.h.

  {
    this, "DisableDistortions", false, "Disable simulation of module distortions"
  };

m_distortionKey

SG::ReadCondHandleKey<PixelDistortionData> EnergyDepositionTool::m_distortionKey

private

Initial value:

{
    this, "PixelDistortionData", "PixelDistortionData", "Output readout distortion data"
  }

Definition at line 125 of file EnergyDepositionTool.h.

  {
    this, "PixelDistortionData", "PixelDistortionData", "Output readout distortion data"
  };

m_doBichsel

Gaudi::Property<bool> EnergyDepositionTool::m_doBichsel

private

Initial value:

{
    this, "doBichsel", true, "re-do charge deposition following Bichsel model"
  }

Definition at line 90 of file EnergyDepositionTool.h.

  {
    this, "doBichsel", true, "re-do charge deposition following Bichsel model"
  };

m_doBichselBetaGammaCut

Gaudi::Property<double> EnergyDepositionTool::m_doBichselBetaGammaCut

private

Initial value:

{
    this, "doBichselBetaGammaCut", 0.1, "minimum beta-gamma for particle to be re-simulated through Bichsel Model"
  }

Definition at line 95 of file EnergyDepositionTool.h.

  {
    this, "doBichselBetaGammaCut", 0.1, "minimum beta-gamma for particle to be re-simulated through Bichsel Model"
  };

m_doDeltaRay

Gaudi::Property<bool> EnergyDepositionTool::m_doDeltaRay

private

Initial value:

{
    this, "doDeltaRay", false, "whether we simulate delta-ray using Bichsel model"
  }

Definition at line 100 of file EnergyDepositionTool.h.

  {
    this, "doDeltaRay", false, "whether we simulate delta-ray using Bichsel model"
  };

m_doPU

Gaudi::Property<bool> EnergyDepositionTool::m_doPU

private

Initial value:

{
    this, "doPU", true, "Whether we apply Bichsel model on PU"
  }

Definition at line 110 of file EnergyDepositionTool.h.

  {
    this, "doPU", true, "Whether we apply Bichsel model on PU"
  };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_LoopLimit

Gaudi::Property<int> EnergyDepositionTool::m_LoopLimit

private

Initial value:

{
    this, "LoopLimit", 100000, "Limit assuming 1 collision per sampling"
  }

Definition at line 120 of file EnergyDepositionTool.h.

  {
    this, "LoopLimit", 100000, "Limit assuming 1 collision per sampling"
  };

m_nCols

Gaudi::Property<int> EnergyDepositionTool::m_nCols

private

Initial value:

{
    this, "nCols", 1, "Number of collision for each sampling"
  }

Definition at line 115 of file EnergyDepositionTool.h.

  {
    this, "nCols", 1, "Number of collision for each sampling"
  };

m_numberOfCharges

Gaudi::Property<int> EnergyDepositionTool::m_numberOfCharges

private

Initial value:

{
    this, "numberOfCharges", 10, "Geant4:number of charges for PixelPlanar"
  }

Definition at line 80 of file EnergyDepositionTool.h.

  {
    this, "numberOfCharges", 10, "Geant4:number of charges for PixelPlanar"
  };

m_numberOfSteps

Gaudi::Property<int> EnergyDepositionTool::m_numberOfSteps

private

Initial value:

{
    this, "numberOfSteps", 50, "Geant4:number of steps for PixelPlanar"
  }

Definition at line 75 of file EnergyDepositionTool.h.

  {
    this, "numberOfSteps", 50, "Geant4:number of steps for PixelPlanar"
  };

m_pixelID

const PixelID* EnergyDepositionTool::m_pixelID

private

Initial value:

{
    nullptr
  }

Definition at line 69 of file EnergyDepositionTool.h.

                           {
    nullptr
  };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• EnergyDepositionTool.h
• EnergyDepositionTool.cxx