SCT_ChargeTrappingTool Class Reference

#include <SCT_ChargeTrappingTool.h>

Inheritance diagram for SCT_ChargeTrappingTool:

Collaboration diagram for SCT_ChargeTrappingTool:

Public Member Functions
	SCT_ChargeTrappingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SCT_ChargeTrappingTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual SCT_ChargeTrappingCondData	getCondData (const IdentifierHash &elementHash, double pos, const EventContext &ctx) const override
virtual SCT_ChargeTrappingCondData	getCondData (const IdentifierHash &elementHash, double pos) const override
virtual void	getHoleTransport (double &x0, double &y0, double &xfin, double &yfin, double &Q_m2, double &Q_m1, double &Q_00, double &Q_p1, double &Q_p2, const EventContext &ctx) const override
virtual void	getHoleTransport (double &x0, double &y0, double &xfin, double &yfin, double &Q_m2, double &Q_m1, double &Q_00, double &Q_p1, double &Q_p2) const override

Private Member Functions
SCT_ChargeTrappingCondData	calculate (const IdentifierHash &elementHash, double pos, const EventContext &ctx) const
double	induced (int istrip, double x, double y) const
void	holeTransport (double &x0, double &y0, double &xfin, double &yfin, double &Q_m2, double &Q_m1, double &Q_00, double &Q_p1, double &Q_p2) const
const InDetDD::SiDetectorElement *	getDetectorElement (const IdentifierHash &waferHash, const EventContext &ctx) const

Static Private Member Functions
static double	getPotentialValue (int &ix, int &iy)

Private Attributes
StringProperty	m_detectorName {this, "DetectorName", "SCT", "Detector name"}
bool	m_isSCT {false}
DoubleProperty	m_temperature {this, "Temperature", -2., "Default temperature in Celcius."}
DoubleProperty	m_temperatureMin {this, "TemperatureMin", -80., "Minimum temperature allowed in Celcius."}
DoubleProperty	m_temperatureMax {this, "TemperatureMax", 100., "Maximum temperature allowed in Celcius."}
DoubleProperty	m_deplVoltage {this, "DepletionVoltage", -30., "Default depletion voltage in Volt."}
DoubleProperty	m_biasVoltage {this, "BiasVoltage", 150., "Default bias voltage in Volt."}
bool	m_conditionsToolValid {false}
std::atomic_bool	m_conditionsToolWarning {false}
BooleanProperty	m_calcHoles {this, "CalcHoles", true, "Default is to consider holes in signal formation."}
DoubleProperty	m_fluence {this, "Fluence", 3.0E13, "Fluence received by the detector."}
DoubleProperty	m_betaElectrons {this, "BetaElectrons", 3.1E-16, "Constant for the trapping model for electrons, in [cm^2/ns] -- average value from Table 2 in ATL-INDET-2003-014"}
DoubleProperty	m_betaHoles {this, "BetaHoles", 5.1E-16, "Constant for the trapping model for holes in [cm^2/ns] -- average value from Table 2 in ATL-INDET-2003-014"}
double	m_PotentialValue [81][115] {{0.}}
ToolHandle< ISiliconConditionsTool >	m_siConditionsTool {this, "SiConditionsTool", "SCT_SiliconConditionsTool", "SCT silicon conditions tool"}
ToolHandle< ISCT_ElectricFieldTool >	m_electricFieldTool {this, "SCT_ElectricFieldTool", "SCT_ElectricFieldTool", "SCT electric field tool"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

Detailed Description

Definition at line 44 of file SCT_ChargeTrappingTool.h.

Constructor & Destructor Documentation

SCT_ChargeTrappingTool()

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

Definition at line 26 of file SCT_ChargeTrappingTool.cxx.

                                                                                                                     :
  base_class(type, name, parent)
{
}

~SCT_ChargeTrappingTool()

virtual SCT_ChargeTrappingTool::~SCT_ChargeTrappingTool ( )

virtualdefault

Member Function Documentation

calculate()

SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::calculate ( const IdentifierHash & elementHash, double pos, const EventContext & ctx ) const

private

Definition at line 92 of file SCT_ChargeTrappingTool.cxx.

{
  ATH_MSG_VERBOSE("Updating cache  for elementHash = " << elementHash);
  
  if (m_conditionsToolWarning) {
    // Only print the warning once.
    m_conditionsToolWarning = false;
    ATH_MSG_WARNING("Conditions Summary Tool is not used. Will use temperature and voltages from job options. "
                    << "Effects of radiation damage may be wrong!");
  }
  
  SCT_ChargeTrappingCondData condData;
 
  const InDetDD::SiDetectorElement* element{getDetectorElement(elementHash, ctx)};
  
  double temperature{0.};
  double deplVoltage{0.};
  double biasVoltage{0.};
  if (not m_conditionsToolValid) {
    temperature = m_temperature + Gaudi::Units::STP_Temperature;
    deplVoltage = m_deplVoltage * Gaudi::Units::volt;
    biasVoltage = m_biasVoltage * Gaudi::Units::volt;
  } else {
    temperature = m_siConditionsTool->temperature(elementHash, ctx) + Gaudi::Units::STP_Temperature;
    deplVoltage = m_siConditionsTool->depletionVoltage(elementHash, ctx) * Gaudi::Units::volt;
    biasVoltage = m_siConditionsTool->biasVoltage(elementHash, ctx) * Gaudi::Units::volt;
  }
  
  // Protect against invalid temperature
  double temperatureC{temperature - Gaudi::Units::STP_Temperature};
  if (not (temperatureC > m_temperatureMin and temperatureC <  m_temperatureMax)) {
    ATH_MSG_WARNING("Invalid  temperature: " << temperatureC << " C. "
                    << "Setting to "  << m_temperature << " C.");
    temperature = m_temperature + Gaudi::Units::STP_Temperature;
  }
  
  // Calculate depletion depth. If biasVoltage is less than  depletionVoltage
  // the detector is not fully depleted and we need to take this  into account.
  // We take absolute values just in case voltages are signed .
  double depletionDepth{element->thickness()};
  if (std::abs(biasVoltage) < std::abs(deplVoltage)) {
    depletionDepth *= std::sqrt(std::abs(biasVoltage / deplVoltage));
    // -- if this was the case would need to re-calculate the Ramo Potential and other parameters.
  }
  
  double electricField{m_electricFieldTool->getElectricField(pos,//posZ
                                                             m_fluence,
                                                             deplVoltage,
                                                             element->thickness(),
                                                             std::abs(biasVoltage))};
  //electric field will be a function of bias voltage and fluence...
 
  condData.setElectricField(electricField);
 
  InDet::SiliconProperties siProperties;
  siProperties.setConditions(temperature, electricField);
 
  // -- Calculate electron and holes drift mobility and velocity for these conditions (temperature, electricField)
  //    using parametrizations in SiliconProperties (SiPropertiesTool). These will be used later for the trapping model.
  //    In the SCT we collect holes. 
  double electronDriftMobility{0.};
  double holeDriftMobility{0.};
  double electronDriftVelocity{0.};
  double holeDriftVelocity{0.};
  if(element->carrierType()==InDetDD::electrons) {
    //    electronDriftMobility = siProperties.calcElectronDriftMobility(temperature,electricField);
    //    electronDriftVelocity = electronDriftMobility*electricField;
  } else {
    if (m_calcHoles){
      holeDriftMobility = siProperties.calcHoleDriftMobility(temperature,electricField*Gaudi::Units::volt)*Gaudi::Units::volt;
      //in this way you could put the electric field in V/mm and the mobility will be in [V mm^2 ns^-1]
      condData.setHoleDriftMobility(holeDriftMobility);
      holeDriftVelocity = holeDriftMobility*electricField;
    }
  }
  
  // -- Calculate Trapping Times
  const double trappingElectrons{1./(m_fluence*m_betaElectrons)};
  condData.setTrappingElectrons(trappingElectrons);
 
  double trappingHoles{0.};
  if (m_calcHoles) {
    trappingHoles = 1./(m_fluence*m_betaHoles);
    condData.setTrappingHoles(trappingHoles);
  }
 
  // -- Calculate Mean Free Path
  const double meanFreePathElectrons{electronDriftVelocity*trappingElectrons};
  condData.setMeanFreePathElectrons(meanFreePathElectrons);
 
  double meanFreePathHoles{0.};
  if (m_calcHoles) {
    meanFreePathHoles = holeDriftVelocity*trappingHoles;
    condData.setMeanFreePathHoles(meanFreePathHoles);
  }
  
  // -- Trapping probability
  double trappingProbability_electron{0.0};
  double trappingProbability_hole{0.0};
  double trappingProbability{0.0};
  if (element->carrierType()==InDetDD::electrons) {
    trappingProbability = 1.0 - std::exp(-std::abs(pos/meanFreePathElectrons));
    trappingProbability_electron = trappingProbability;
  } else {
    if (m_calcHoles) {
      trappingProbability = 1.0 - std::exp(-std::abs(pos/meanFreePathHoles));
      trappingProbability_hole = trappingProbability;
    } else {
      trappingProbability = 0.0;
    }
  }
  condData.setTrappingProbability(trappingProbability);
 
  // -- Drift time without being trapped
  const double u{CLHEP::RandFlat::shoot(0., 1.)};
  const double drift_time{-std::log(u)*trappingHoles};
  condData.setTrappingTime(drift_time);
  
  // -- Time to arrive to the electrode
  const double t_electrode_hole{pos/holeDriftVelocity};
  condData.setTimeToElectrode(t_electrode_hole);
 
  // -- Position at which the trapping happened
  const double trappingPosition_hole{holeDriftVelocity*drift_time};
  condData.setTrappingPositionZ(trappingPosition_hole);
 
  //-------------------
 
  ATH_MSG_VERBOSE("Temperature (C), bias voltage, depletion  voltage: "
                  << temperature - Gaudi::Units::STP_Temperature << ", "
                  << biasVoltage/Gaudi::Units::volt << ", "
                  << deplVoltage/Gaudi::Units::volt);
  ATH_MSG_VERBOSE("Depletion depth: " << depletionDepth/Gaudi::Units::mm);
  ATH_MSG_VERBOSE("Electric Field: " << electricField/(Gaudi::Units::volt/Gaudi::Units::mm));
  ATH_MSG_VERBOSE("Electron drift mobility (cm2/V/s): " <<  electronDriftMobility/(Gaudi::Units::cm2/Gaudi::Units::volt/Gaudi::Units::s));
  ATH_MSG_VERBOSE("Electron drift velocity (cm/s): " <<   electronDriftVelocity);
  ATH_MSG_VERBOSE("Electron mean free path (cm): " <<  condData.getMeanFreePathElectrons());
  ATH_MSG_VERBOSE("Electron trapping probability: " <<  trappingProbability_electron);
 
  if (m_calcHoles) {
    ATH_MSG_VERBOSE("Hole drift mobility (cm2/V/s): " <<  holeDriftMobility/(Gaudi::Units::cm2/Gaudi::Units::volt/Gaudi::Units::s));
    ATH_MSG_VERBOSE("Hole drift velocity (cm/s): " <<   holeDriftVelocity);
    ATH_MSG_VERBOSE("Hole mean free path (cm): " <<  condData.getMeanFreePathHoles());
    ATH_MSG_VERBOSE("Hole trapping probability: " <<  trappingProbability_hole);
  }
 
  return condData;
}

finalize()

StatusCode SCT_ChargeTrappingTool::finalize ( )

overridevirtual

Definition at line 64 of file SCT_ChargeTrappingTool.cxx.

{
  return StatusCode::SUCCESS;
}

getCondData() [1/2]

SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::getCondData ( const IdentifierHash & elementHash, double pos ) const

overridevirtual

Definition at line 74 of file SCT_ChargeTrappingTool.cxx.

{
  const EventContext& ctx{Gaudi::Hive::currentContext()};
  return getCondData(elementHash, pos, ctx);
}

getCondData() [2/2]

SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::getCondData ( const IdentifierHash & elementHash, double pos, const EventContext & ctx ) const

overridevirtual

Definition at line 69 of file SCT_ChargeTrappingTool.cxx.

{
  return calculate(elementHash, pos, ctx);
}

getDetectorElement()

const InDetDD::SiDetectorElement * SCT_ChargeTrappingTool::getDetectorElement ( const IdentifierHash & waferHash, const EventContext & ctx ) const

private

Definition at line 334 of file SCT_ChargeTrappingTool.cxx.

                                                                                                                                         {
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey, ctx};
  if (not condData.isValid()) return nullptr;
  return condData->getDetectorElement(waferHash);
}

getHoleTransport() [1/2]

void SCT_ChargeTrappingTool::getHoleTransport ( double & x0, double & y0, double & xfin, double & yfin, double & Q_m2, double & Q_m1, double & Q_00, double & Q_p1, double & Q_p2 ) const

overridevirtual

Definition at line 85 of file SCT_ChargeTrappingTool.cxx.

{
  const EventContext& ctx{Gaudi::Hive::currentContext()};
  getHoleTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2, ctx);
}

getHoleTransport() [2/2]

void SCT_ChargeTrappingTool::getHoleTransport ( double & x0, double & y0, double & xfin, double & yfin, double & Q_m2, double & Q_m1, double & Q_00, double & Q_p1, double & Q_p2, const EventContext & ctx ) const

overridevirtual

Definition at line 80 of file SCT_ChargeTrappingTool.cxx.

{
  holeTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2);
}

getPotentialValue()

double SCT_ChargeTrappingTool::getPotentialValue ( int & ix, int & iy )

staticprivate

Definition at line 330 of file SCT_ChargeTrappingTool.cxx.

                                                          {
  return ::getPotentialValue(ix, iy);
}

holeTransport()

void SCT_ChargeTrappingTool::holeTransport ( double & x0, double & y0, double & xfin, double & yfin, double & Q_m2, double & Q_m1, double & Q_00, double & Q_p1, double & Q_p2 ) const

private

Definition at line 285 of file SCT_ChargeTrappingTool.cxx.

                                                                                                                                                                         {
  // transport holes in the bulk 
  // T. Kondo, 2010.9.9
  // External parameters to be specified
  //     m_transportTimeMax  [nsec]
  //     m_transportTimeStep [nsec]     
  //     bulk_depth        [cm]
  // Induced currents are added to
  //     Q_m2,Q_m1,Q_00,Q_p1,Q_p2   
  // 
  // initPotentialValue(); // <-this has to go into the main
 
  // x is width, y is depth
 
  double x{x0/10.};  // original hole position [cm]
  double y{y0/10.};  // original hole position [cm]
  double qstrip[5];
 
  for (int istrip{-2}; istrip < 3 ; istrip++) {
    qstrip[istrip+2] = induced(istrip, x, y);
  }
  ATH_MSG_DEBUG("h:qstrip=" << qstrip[0] << " " << qstrip[1] << " " << qstrip[2] << " " << qstrip[3] << " " << qstrip[4]);
  
  // Get induced current by subtracting induced charges
  for (int istrip{-2}; istrip < 3 ; istrip++) {
    x = xfin/10.;
    y = yfin/10.;
    const double qnew{induced(istrip, x, y)};
    int jj{istrip + 2};
    const double dq{qnew - qstrip[jj]};
    qstrip[jj] = qnew;
    ATH_MSG_DEBUG("dq= " << dq);
    switch(istrip) {
    case -2: Q_m2 += dq ; break;
    case -1: Q_m1 += dq ; break;
    case  0: Q_00 += dq ; break;
    case +1: Q_p1 += dq ; break;
    case +2: Q_p2 += dq ; break;
      //    default: break; // Coverity complains the default is deadcode.
    }
  }  
  ATH_MSG_DEBUG("h:qstrip=" << qstrip[0] << " " << qstrip[1] << " " << qstrip[2] << " " << qstrip[3] << " " << qstrip[4]);
}

induced()

double SCT_ChargeTrappingTool::induced ( int istrip, double x, double y ) const

private

Definition at line 250 of file SCT_ChargeTrappingTool.cxx.

                                                                           {
  // x and y are the coorlocation of charge (e or hole)
  // induced chardege on the strip "istrip" situated at the height y = d
  // the center of the strip (istrip=0) is x = 0.004 [cm]
  static const double deltax{0.0005};
  static const double deltay{0.00025};
  
  static const double bulk_depth{0.0285}; // in [cm]
  static const double strip_pitch{0.0080}; // in [cm]
  // x is width, y is depth
 
  if ((y < 0.) or (y > bulk_depth)) return 0.;
  const double xc{strip_pitch * (istrip + 0.5)};
  const double dx{std::abs(x-xc)};
  const int ix{static_cast<int>(dx/deltax)};
  if (ix > 79) return 0.;
  const int iy{static_cast<int>(y/deltay)};
  const double fx{(dx - ix*deltax) / deltax};
  const double fy{(y - iy*deltay) / deltay};
  const int ix1{ix + 1};
  const int iy1{iy + 1};
  const double P{m_PotentialValue[ix ][iy ] * (1.-fx) * (1.-fy)
               + m_PotentialValue[ix1][iy ] *     fx  * (1.-fy)
               + m_PotentialValue[ix ][iy1] * (1.-fx) *     fy
               + m_PotentialValue[ix1][iy1] *     fx  *     fy};
  ATH_MSG_DEBUG("induced: x,y,iy="<<x<<" "<<y<<" "<<iy<<" istrip,xc,dx,ix="
                <<istrip<<" "<<xc<<" " <<dx<<" "<<ix<<" fx,fy="<<fx <<" " <<fy<< ", P="<<P);
  
  return P;
}

initialize()

StatusCode SCT_ChargeTrappingTool::initialize ( )

overridevirtual

Definition at line 32 of file SCT_ChargeTrappingTool.cxx.

{
  if (m_detectorName!="SCT") {
    ATH_MSG_FATAL("Invalid detector name: " << m_detectorName  << ". Must be SCT.");
    return StatusCode::FAILURE;
  }
 
  m_isSCT = (m_detectorName=="SCT");
  
  // Get conditions summary tool
  m_conditionsToolValid = false;
  if (not m_siConditionsTool.empty()) {
    ATH_CHECK(m_siConditionsTool.retrieve());
    m_conditionsToolValid = true;
  } else {
    m_siConditionsTool.disable();
    m_conditionsToolWarning = true;
  }
 
  // Read CondHandle Key
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
  // initialize PotentialValue
  for (int ix{0}; ix<81; ix++) {
    for (int iy{0}; iy<115; iy++) {
      m_PotentialValue[ix][iy] = getPotentialValue(ix, iy);
    }
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_betaElectrons

DoubleProperty SCT_ChargeTrappingTool::m_betaElectrons {this, "BetaElectrons", 3.1E-16, "Constant for the trapping model for electrons, in [cm^2/ns] -- average value from Table 2 in ATL-INDET-2003-014"}

private

Definition at line 84 of file SCT_ChargeTrappingTool.h.

{this, "BetaElectrons", 3.1E-16, "Constant for the trapping model for electrons, in [cm^2/ns] -- average value from Table 2 in ATL-INDET-2003-014"};

m_betaHoles

DoubleProperty SCT_ChargeTrappingTool::m_betaHoles {this, "BetaHoles", 5.1E-16, "Constant for the trapping model for holes in [cm^2/ns] -- average value from Table 2 in ATL-INDET-2003-014"}

private

Definition at line 85 of file SCT_ChargeTrappingTool.h.

{this, "BetaHoles", 5.1E-16, "Constant for the trapping model for holes in [cm^2/ns] -- average value from Table 2 in ATL-INDET-2003-014"};

m_biasVoltage

DoubleProperty SCT_ChargeTrappingTool::m_biasVoltage {this, "BiasVoltage", 150., "Default bias voltage in Volt."}

private

Definition at line 74 of file SCT_ChargeTrappingTool.h.

{this, "BiasVoltage", 150., "Default  bias voltage in Volt."};

m_calcHoles

BooleanProperty SCT_ChargeTrappingTool::m_calcHoles {this, "CalcHoles", true, "Default is to consider holes in signal formation."}

private

Definition at line 80 of file SCT_ChargeTrappingTool.h.

{this, "CalcHoles", true, "Default is to consider holes in signal formation."};

m_conditionsToolValid

bool SCT_ChargeTrappingTool::m_conditionsToolValid {false}

private

Definition at line 76 of file SCT_ChargeTrappingTool.h.

{false};

m_conditionsToolWarning

std::atomic_bool SCT_ChargeTrappingTool::m_conditionsToolWarning {false}

mutableprivate

Definition at line 77 of file SCT_ChargeTrappingTool.h.

{false};

m_deplVoltage

DoubleProperty SCT_ChargeTrappingTool::m_deplVoltage {this, "DepletionVoltage", -30., "Default depletion voltage in Volt."}

private

Definition at line 73 of file SCT_ChargeTrappingTool.h.

{this, "DepletionVoltage", -30., "Default depletion voltage in Volt."};

m_detectorName

StringProperty SCT_ChargeTrappingTool::m_detectorName {this, "DetectorName", "SCT", "Detector name"}

private

Definition at line 65 of file SCT_ChargeTrappingTool.h.

{this, "DetectorName", "SCT", "Detector name"};

m_electricFieldTool

ToolHandle<ISCT_ElectricFieldTool> SCT_ChargeTrappingTool::m_electricFieldTool {this, "SCT_ElectricFieldTool", "SCT_ElectricFieldTool", "SCT electric field tool"}

private

Definition at line 91 of file SCT_ChargeTrappingTool.h.

{this, "SCT_ElectricFieldTool", "SCT_ElectricFieldTool", "SCT electric field tool"};

m_fluence

DoubleProperty SCT_ChargeTrappingTool::m_fluence {this, "Fluence", 3.0E13, "Fluence received by the detector."}

private

Definition at line 83 of file SCT_ChargeTrappingTool.h.

{this, "Fluence", 3.0E13, "Fluence received by the detector."};

m_isSCT

bool SCT_ChargeTrappingTool::m_isSCT {false}

private

Definition at line 66 of file SCT_ChargeTrappingTool.h.

{false};

m_PotentialValue

double SCT_ChargeTrappingTool::m_PotentialValue[81][115] {{0.}}

private

Definition at line 87 of file SCT_ChargeTrappingTool.h.

{{0.}};

m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> SCT_ChargeTrappingTool::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

private

Definition at line 93 of file SCT_ChargeTrappingTool.h.

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

m_siConditionsTool

ToolHandle<ISiliconConditionsTool> SCT_ChargeTrappingTool::m_siConditionsTool {this, "SiConditionsTool", "SCT_SiliconConditionsTool", "SCT silicon conditions tool"}

private

Definition at line 90 of file SCT_ChargeTrappingTool.h.

{this, "SiConditionsTool", "SCT_SiliconConditionsTool", "SCT silicon conditions tool"};

m_temperature

DoubleProperty SCT_ChargeTrappingTool::m_temperature {this, "Temperature", -2., "Default temperature in Celcius."}

private

Definition at line 70 of file SCT_ChargeTrappingTool.h.

{this, "Temperature", -2., "Default temperature in Celcius."};

m_temperatureMax

DoubleProperty SCT_ChargeTrappingTool::m_temperatureMax {this, "TemperatureMax", 100., "Maximum temperature allowed in Celcius."}

private

Definition at line 72 of file SCT_ChargeTrappingTool.h.

{this, "TemperatureMax", 100., "Maximum temperature allowed in Celcius."};

m_temperatureMin

DoubleProperty SCT_ChargeTrappingTool::m_temperatureMin {this, "TemperatureMin", -80., "Minimum temperature allowed in Celcius."}

private

Definition at line 71 of file SCT_ChargeTrappingTool.h.

{this, "TemperatureMin", -80., "Minimum temperature allowed in Celcius."};

---

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

• SCT_ChargeTrappingTool.h
• SCT_ChargeTrappingTool.cxx