ITk::StripSurfaceChargesGenerator Class Reference

#include <StripSurfaceChargesGenerator.h>

Inheritance diagram for ITk::StripSurfaceChargesGenerator:

Collaboration diagram for ITk::StripSurfaceChargesGenerator:

Classes
struct	Hists

Public Member Functions
	StripSurfaceChargesGenerator (const std::string &type, const std::string &name, const IInterface *parent)
	constructor
virtual	~StripSurfaceChargesGenerator ()=default
	Destructor.
virtual StatusCode	initialize () override
	AlgTool initialize.
virtual StatusCode	finalize () override
	AlgTool finalize.

Private Member Functions
virtual void	setFixedTime (float fixedTime) override
virtual void	process (const InDetDD::SiDetectorElement *element, const TimedHitPtr< SiHit > &phit, ISiSurfaceChargesInserter &inserter, CLHEP::HepRandomEngine *rndmEngine, const EventContext &ctx) override
	create a list of surface charges from a hit
void	processSiHit (const InDetDD::SiDetectorElement *element, const SiHit &phit, ISiSurfaceChargesInserter &inserter, float eventTime, unsigned short eventID, CLHEP::HepRandomEngine *rndmEngine, const EventContext &ctx) const
float	driftTime (float zhit, const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	calculate drift time perpandicular to the surface for a charge at distance zhit from mid gap
float	diffusionSigma (float zhit, const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	calculate diffusion sigma from a gaussian dist scattered charge
float	surfaceDriftTime (float ysurf) const
	Calculate of the surface drift time.
float	maxDriftTime (const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	max drift charge equivalent to the detector thickness
float	maxDiffusionSigma (const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	max sigma diffusion
bool	chargeIsTrapped (double spess, const InDetDD::SiDetectorElement *element, double &trap_pos, double &drift_time, const EventContext &ctx) const
Hists &	getHists () const

Private Attributes
IntegerProperty	m_numberOfCharges {this, "NumberOfCharges", 1, "number of charges"}
FloatProperty	m_smallStepLength {this, "SmallStepLength", 5 * CLHEP::micrometer, "max internal step along the larger G4 step"}
FloatProperty	m_tSurfaceDrift {this, "SurfaceDriftTime", 10 * CLHEP::ns, "max surface drift time"}
	related to the surface drift
FloatProperty	m_tfix {this, "FixedTime", -999., "fixed time"}
FloatProperty	m_tsubtract {this, "SubtractTime", -999., "subtract drift time from mid gap"}
BooleanProperty	m_useSiCondDB {this, "UseSiCondDB", true, "Usage of SiConditions DB values can be disabled to use setable ones"}
FloatProperty	m_vdepl {this, "DepletionVoltage", 70., "depletion voltage, default 70V"}
FloatProperty	m_vbias {this, "BiasVoltage", 150., "bias voltage, default 150V"}
BooleanProperty	m_doTrapping {this, "doTrapping", false, "Flag to set Charge Trapping"}
BooleanProperty	m_doHistoTrap {this, "doHistoTrap", false, "Histogram the charge trapping effect"}
BooleanProperty	m_doRamo {this, "doRamo", false, "Ramo Potential for charge trapping effect"}
BooleanProperty	m_isOverlay {this, "isOverlay", false, "flag for overlay"}
BooleanProperty	m_doInducedChargeModel {this, "doInducedChargeModel", false, "Flag for Induced Charge Model"}
ToolHandle< ISiPropertiesTool >	m_siPropertiesTool {this, "SiPropertiesTool", "StripSiPropertiesTool", "Tool to retrieve SCT silicon properties"}
ToolHandle< ISCT_RadDamageSummaryTool >	m_radDamageTool {this, "RadDamageSummaryTool", "StripRadDamageSummaryTool", "Tool to retrieve SCT radiation damages"}
ToolHandle< ISiliconConditionsTool >	m_siConditionsTool {this, "SiConditionsTool", "StripSiliconConditionsTool", "Tool to retrieve SCT silicon information"}
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/ITkStripLorentzAngleTool", "Tool to retreive Lorentz angle"}
ServiceHandle< ITHistSvc >	m_thistSvc {this, "THistSvc", "THistSvc"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
float	m_tHalfwayDrift {0.}
	Surface drift time.
float	m_distInterStrip {1.0}
	Inter strip distance normalized to 1.
float	m_distHalfInterStrip {0.}
	Half way distance inter strip.
bool	m_SurfaceDriftFlag {false}
	surface drift ON/OFF
std::unique_ptr< Hists >	m_h
std::unique_ptr< InducedChargeModel >	m_InducedChargeModel

Detailed Description

Definition at line 62 of file StripSurfaceChargesGenerator.h.

Constructor & Destructor Documentation

StripSurfaceChargesGenerator()

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

constructor

Definition at line 40 of file StripSurfaceChargesGenerator.cxx.

  : base_class(type, name, parent) {
}

~StripSurfaceChargesGenerator()

virtual ITk::StripSurfaceChargesGenerator::~StripSurfaceChargesGenerator ( )

virtualdefault

Destructor.

Member Function Documentation

chargeIsTrapped()

bool ITk::StripSurfaceChargesGenerator::chargeIsTrapped ( double spess, const InDetDD::SiDetectorElement * element, double & trap_pos, double & drift_time, const EventContext & ctx ) const

private

Definition at line 626 of file StripSurfaceChargesGenerator.cxx.

                                                                                 {
  if (element==nullptr) {
    ATH_MSG_ERROR("StripSurfaceChargesGenerator::chargeIsTrapped element is nullptr");
    return false;
  }
  bool isTrapped{false};
  const IdentifierHash hashId{element->identifyHash()};
  const SCT_ChargeTrappingCondData condData{m_radDamageTool->getCondData(hashId, spess, ctx)};
  const double electric_field{condData.getElectricField()};
 
  if (m_doHistoTrap) {
    Hists& h = getHists();
    const double mobChar{condData.getHoleDriftMobility()};
    h.m_h_efieldz->Fill(spess, electric_field);
    h.m_h_efield->Fill(electric_field);
    h.m_h_mob_Char->Fill(electric_field, mobChar);
    h.m_h_vel->Fill(electric_field, electric_field * mobChar);
  }
  const double t_electrode{condData.getTimeToElectrode()};
  drift_time = condData.getTrappingTime();
  const double z_trap{condData.getTrappingPositionZ()};
  trap_pos = spess - z_trap;
  if (m_doHistoTrap) {
    Hists& h = getHists();
    h.m_h_drift_time->Fill(drift_time);
    h.m_h_t_electrode->Fill(t_electrode);
    h.m_h_drift_electrode->Fill(drift_time, t_electrode);
    h.m_h_ztrap_tot->Fill(z_trap);
  }
  // -- Calculate if the charge is trapped, and at which distance
  // -- Charge gets trapped before arriving to the electrode
  if (drift_time < t_electrode) {
    isTrapped = true;
    ATH_MSG_INFO("drift_time: " << drift_time << " t_electrode:  " << t_electrode << " spess " << spess);
    ATH_MSG_INFO("z_trap: " << z_trap);
    if (m_doHistoTrap) {
      Hists& h = getHists();
      h.m_h_ztrap->Fill(z_trap);
      h.m_h_trap_drift_t->Fill(drift_time);
      h.m_h_drift1->Fill(spess, drift_time / t_electrode);
      h.m_h_gen->Fill(spess, drift_time);
      h.m_h_gen1->Fill(spess, z_trap);
      h.m_h_gen2->Fill(spess, z_trap / drift_time * t_electrode);
      h.m_h_velocity_trap->Fill(electric_field, z_trap / drift_time);
      h.m_h_mobility_trap->Fill(electric_field, z_trap / drift_time / electric_field);
      h.m_h_trap_pos->Fill(trap_pos);
    }
  } else {
    isTrapped = false;
    if (m_doHistoTrap) {
      const double z_trap{condData.getTrappingPositionZ()};
      Hists& h = getHists();
      h.m_h_no_ztrap->Fill(z_trap);
      h.m_h_notrap_drift_t->Fill(drift_time);
    }
  }
  return isTrapped;
}

diffusionSigma()

float ITk::StripSurfaceChargesGenerator::diffusionSigma ( float zhit, const InDetDD::SiDetectorElement * element, const EventContext & ctx ) const

private

calculate diffusion sigma from a gaussian dist scattered charge

Definition at line 242 of file StripSurfaceChargesGenerator.cxx.

                                                                                                                              {
  if (element==nullptr) {
    ATH_MSG_ERROR("StripSurfaceChargesGenerator::diffusionSigma element is nullptr");
    return 0.0;
  }
  const IdentifierHash hashId{element->identifyHash()};
  const float t{driftTime(zhit, element, ctx)}; // in ns
 
  if (t > 0.0) {
    const float sigma{static_cast<float>(std::sqrt(2. * m_siPropertiesTool->getSiProperties(hashId, ctx).holeDiffusionConstant() * t))}; // in mm
    return sigma;
  } else {
    return 0.0;
  }
}

driftTime()

float ITk::StripSurfaceChargesGenerator::driftTime ( float zhit, const InDetDD::SiDetectorElement * element, const EventContext & ctx ) const

private

calculate drift time perpandicular to the surface for a charge at distance zhit from mid gap

Definition at line 193 of file StripSurfaceChargesGenerator.cxx.

                                                                                                                         {
  if (element==nullptr) {
    ATH_MSG_ERROR("StripSurfaceChargesGenerator::process element is nullptr");
    return -2.0;
  }
  const SCT_ModuleSideDesign* design{dynamic_cast<const SCT_ModuleSideDesign*>(&(element->design()))};
  if (design==nullptr) {
    ATH_MSG_ERROR("StripSurfaceChargesGenerator::process can not get " << design);
    return -2.0;
  }
  const double thickness{design->thickness()};
  const IdentifierHash hashId{element->identifyHash()};
 
  if ((zhit < 0.0) or (zhit > thickness)) {
    ATH_MSG_DEBUG("driftTime: hit coordinate zhit=" << zhit / CLHEP::micrometer << " out of range");
    return -2.0;
  }
 
  float depletionVoltage{0.};
  float biasVoltage{0.};
  if (m_useSiCondDB) {
    depletionVoltage = m_siConditionsTool->depletionVoltage(hashId, ctx) * CLHEP::volt;
    biasVoltage = m_siConditionsTool->biasVoltage(hashId, ctx) * CLHEP::volt;
  } else {
    depletionVoltage = m_vdepl * CLHEP::volt;
    biasVoltage = m_vbias * CLHEP::volt;
  }
 
  const float denominator{static_cast<float>(depletionVoltage + biasVoltage - (2.0 * zhit * depletionVoltage / thickness))};
  if (denominator <= 0.0) {
    if (biasVoltage >= depletionVoltage) { // Should not happen
      if(not m_isOverlay) {
        ATH_MSG_ERROR("driftTime: negative argument X for log(X) " << zhit);
      }
      return -1.0;
    } else {
      // (m_biasVoltage<m_depletionVoltage) can happen with underdepleted sensors, lose charges in that volume
      return -10.0;
    }
  }
 
  float t_drift{std::log((depletionVoltage + biasVoltage) / denominator)};
  t_drift *= thickness * thickness / (2.0 * m_siPropertiesTool->getSiProperties(hashId, ctx).holeDriftMobility() * depletionVoltage);
  return t_drift;
}

finalize()

StatusCode ITk::StripSurfaceChargesGenerator::finalize ( )

overridevirtual

AlgTool finalize.

Definition at line 185 of file StripSurfaceChargesGenerator.cxx.

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

getHists()

StripSurfaceChargesGenerator::Hists & ITk::StripSurfaceChargesGenerator::getHists ( ) const

private

Definition at line 691 of file StripSurfaceChargesGenerator.cxx.

{
  // We earlier checked that no more than one thread is being used.
  Hists* h ATLAS_THREAD_SAFE = m_h.get();
  return *h;
}

initialize()

StatusCode ITk::StripSurfaceChargesGenerator::initialize ( )

overridevirtual

AlgTool initialize.

Definition at line 49 of file StripSurfaceChargesGenerator.cxx.

                                                    {
  ATH_MSG_DEBUG("StripSurfaceChargesGenerator::initialize()");
 
  // Get ISiPropertiesTool
  ATH_CHECK(m_siPropertiesTool.retrieve());
 
  // Get ISiliconConditionsSvc
  ATH_CHECK(m_siConditionsTool.retrieve());
 
  ATH_CHECK(m_fieldCacheCondObjInputKey.initialize(m_doInducedChargeModel));
 
  if (m_doTrapping) {
    // -- Get Radiation Damage Tool
    ATH_CHECK(m_radDamageTool.retrieve());
  } else {
    m_radDamageTool.disable();
  }
 
  if (m_doHistoTrap) {
    if (Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
      ATH_MSG_FATAL("Filling histograms not supported in MT jobs.");
      return StatusCode::FAILURE;
    }
 
    // -- Get Histogram Service
    ATH_CHECK(m_thistSvc.retrieve());
    m_h = std::make_unique<Hists>();
    ATH_CHECK(m_h->book(*m_thistSvc));
  }
 
  // Induced Charge Module.
  if (m_doInducedChargeModel) {
    const SCT_ID* sct_id{nullptr};
    ATH_CHECK(detStore()->retrieve(sct_id, "SCT_ID"));
    m_InducedChargeModel = std::make_unique<InducedChargeModel>(sct_id->wafer_hash_max());
  }
 
  // Surface drift time calculation Stuff
  m_tHalfwayDrift = m_tSurfaceDrift * 0.5;
  m_distHalfInterStrip = m_distInterStrip * 0.5;
  if ((m_tSurfaceDrift > m_tHalfwayDrift) and (m_tHalfwayDrift >= 0.0) and
      (m_distHalfInterStrip > 0.0) and (m_distHalfInterStrip < m_distInterStrip)) {
    m_SurfaceDriftFlag = true;
  } else {
    ATH_MSG_INFO("\tsurface drift still not on, wrong params");
  }
 
  // Make sure these two flags are not set simultaneously
  if (m_tfix>-998. and m_tsubtract>-998.) {
    ATH_MSG_FATAL("\tCannot set both FixedTime and SubtractTime options!");
    ATH_MSG_INFO("\tMake sure the two flags are not set simultaneously in jo");
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_lorentzAngleTool.retrieve());
 
  return StatusCode::SUCCESS;
}

maxDiffusionSigma()

float ITk::StripSurfaceChargesGenerator::maxDiffusionSigma ( const InDetDD::SiDetectorElement * element, const EventContext & ctx ) const

private

max sigma diffusion

Definition at line 274 of file StripSurfaceChargesGenerator.cxx.

                                                                                                                     {
  if (element) {
    const float sensorThickness{static_cast<float>(element->thickness())};
    return diffusionSigma(sensorThickness, element, ctx);
  } else {
    ATH_MSG_INFO("Error: SiDetectorElement not set!");
    return 0.;
  }
}

maxDriftTime()

float ITk::StripSurfaceChargesGenerator::maxDriftTime ( const InDetDD::SiDetectorElement * element, const EventContext & ctx ) const

private

max drift charge equivalent to the detector thickness

Definition at line 261 of file StripSurfaceChargesGenerator.cxx.

                                                                                                                {
  if (element) {
    const float sensorThickness{static_cast<float>(element->thickness())};
    return driftTime(sensorThickness, element, ctx);
  } else {
    ATH_MSG_INFO("Error: SiDetectorElement not set!");
    return 0.;
  }
}

process()

void ITk::StripSurfaceChargesGenerator::process ( const InDetDD::SiDetectorElement * element, const TimedHitPtr< SiHit > & phit, ISiSurfaceChargesInserter & inserter, CLHEP::HepRandomEngine * rndmEngine, const EventContext & ctx )

overrideprivatevirtual

create a list of surface charges from a hit

Definition at line 313 of file StripSurfaceChargesGenerator.cxx.

                                                                   {
  ATH_MSG_VERBOSE("StripSurfaceChargesGenerator::process starts");
  processSiHit(element, *phit, inserter, phit.eventTime(), phit.eventId(), rndmEngine, ctx);
}

processSiHit()

void ITk::StripSurfaceChargesGenerator::processSiHit ( const InDetDD::SiDetectorElement * element, const SiHit & phit, ISiSurfaceChargesInserter & inserter, float eventTime, unsigned short eventID, CLHEP::HepRandomEngine * rndmEngine, const EventContext & ctx ) const

private

Definition at line 326 of file StripSurfaceChargesGenerator.cxx.

                                                                              {
  const SCT_ModuleSideDesign* design;
  const SCT_ModuleSideDesign* initialDesign{dynamic_cast<const SCT_ModuleSideDesign*>(&(element->design()))};
  if (initialDesign==nullptr) {
    ATH_MSG_ERROR("StripSurfaceChargesGenerator::process can not get " << initialDesign);
    return;
  }
 
  //If this proves costly, we can pass a (potentially null) motherDesign 
  //in the interface instead, but this will require a new interface class
  //(see comment in SiDigitization/ISurfaceChargesGenerator.h)
 
  const SCT_ModuleSideDesign* motherDesign  = initialDesign->getMother();
 
  if(motherDesign!=nullptr){
    ATH_MSG_DEBUG("Found a Mother Design - Using it!");
    design = motherDesign;
  }
  else {
    ATH_MSG_DEBUG("No Mother Design - Using Design from DetElement directly!");
    design = initialDesign;
  }
 
  const double thickness{design->thickness()};
  const IdentifierHash hashId{element->identifyHash()};
  const double tanLorentz{m_lorentzAngleTool->getTanLorentzAngle(hashId, ctx)};
 
  // ---**************************************
  //  Time of Flight Calculation - separate method?
  // ---**************************************
  // --- Original calculation of Time of Flight of the particle Time needed by the particle to reach the sensor
  float timeOfFlight{p_eventTime + hitTime(phit)};
 
  // Kondo 19/09/2007: Use the coordinate of the center of the module to calculate the time of flight
  timeOfFlight -= (element->center().mag()) / CLHEP::c_light;
  // !< extract the distance to the origin of the module to Time of flight
 
  // !< timing set from jo to adjust (subtract) the timing
  if (m_tsubtract > -998.) {
    timeOfFlight -= m_tsubtract;
  }
  // ---**************************************
 
  const CLHEP::Hep3Vector pos{phit.localStartPosition()};
  const float xEta{static_cast<float>(pos[SiHit::xEta])};
  const float xPhi{static_cast<float>(pos[SiHit::xPhi])};
  const float xDep{static_cast<float>(pos[SiHit::xDep])};
 
  const CLHEP::Hep3Vector endPos{phit.localEndPosition()};
  const float cEta{static_cast<float>(endPos[SiHit::xEta]) - xEta};
  const float cPhi{static_cast<float>(endPos[SiHit::xPhi]) - xPhi};
  const float cDep{static_cast<float>(endPos[SiHit::xDep]) - xDep};
 
 
 
  const float largeStep{std::sqrt(cEta*cEta + cPhi*cPhi + cDep*cDep)};
  const int numberOfSteps{static_cast<int>(largeStep / m_smallStepLength) + 1};
  const float steps{static_cast<float>(m_numberOfCharges * numberOfSteps)};
  const float e1{static_cast<float>(phit.energyLoss() / steps)};
  const float q1{static_cast<float>(e1 * m_siPropertiesTool->getSiProperties(hashId, ctx).electronHolePairsPerEnergy())};
 
  // NB this is different to the SCT, where this would be
  //float xhit{xEta};
  //float yhit{xPhi};
  //float zhit{xDep};
  //float cX{cEta};
  //float cY{cPhi};
  //float cZ{cDep};
 
 float xhit{xDep};
 float yhit{xPhi};
 float zhit{xEta};
 float cX{cDep};
 float cY{cPhi};
 float cZ{cEta};
 
  InducedChargeModel::SCT_InducedChargeModelData* data{nullptr};
  if (m_doInducedChargeModel) { // Setting magnetic field for the ICM.
    SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
    const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
    if (!fieldCondObj)[[unlikely]]{
      ATH_MSG_ERROR("fieldCondObj is nullptr");
      return;
    }
    float vdepl{m_vdepl};
    float vbias{m_vbias};
    if (m_useSiCondDB) {
      vdepl = m_siConditionsTool->depletionVoltage(hashId, ctx);
      vbias = m_siConditionsTool->biasVoltage(hashId, ctx);
    }
    data = m_InducedChargeModel->setWaferData(vdepl,
                                              vbias,
                                              element,
                                              fieldCondObj,
                                              m_siConditionsTool,
                                              rndmEngine,
                                              ctx);
  }
 
  const float stepX{cX / numberOfSteps};
  const float stepY{cY / numberOfSteps};
  const float stepZ{cZ / numberOfSteps};
 
  // check the status of truth information for this SiHit
  // some Truth information is cut for pile up events
  const HepMcParticleLink trklink = HepMcParticleLink::getRedirectedLink(phit.particleLink(), p_eventId, ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
  SiCharge::Process hitproc{SiCharge::track};
  if (phit.truthID() != 0 || phit.truthBarcode() != 0) { // if the hit was not caused by a delta-ray then one of these must be true
    if (not trklink.isValid()) {
      // TODO consider extending this check to reject links to
      // GenEvents other than the first one in the McEventCollection,
      // so that the digitization output doesn't change if pile-up
      // truth is saved.
      hitproc = SiCharge::cut_track;
    }
  }
 
  float dstep{-0.5};
  for (int istep{0}; istep < numberOfSteps; ++istep) {
    dstep += 1.0;
    float z1{zhit + stepZ * dstep};
 
    // Distance between charge and readout side.
    // design->readoutSide() is +1 if readout side is in +ve depth axis direction and visa-versa.
    float zReadout{static_cast<float>(0.5 * thickness - design->readoutSide() * z1)};
    const double spess{zReadout};
 
    if (m_doHistoTrap) {
      Hists& h = getHists();
      h.m_h_depD->Fill(z1);
      h.m_h_spess->Fill(spess);
    }
 
    float t_drift{driftTime(zReadout, element, ctx)};  // !< t_drift: perpandicular drift time
    if (t_drift>-2.0000002 and t_drift<-1.9999998) {
      ATH_MSG_DEBUG("Checking for rounding errors in compression");
      if ((std::abs(z1) - 0.5 * thickness) < 0.000010) {
        ATH_MSG_DEBUG("Rounding error found attempting to correct it. z1 = " << std::fixed << std::setprecision(8) << z1);
        if (z1 < 0.0) {
          z1 = 0.0000005 - 0.5 * thickness;
          // set new coordinate to be 0.5nm inside wafer volume.
        } else {
          z1 = 0.5 * thickness - 0.0000005;
          // set new coordinate to be 0.5nm inside wafer volume.
        }
        zReadout = 0.5 * thickness - design->readoutSide() * z1;
        t_drift = driftTime(zReadout, element, ctx);
        if (t_drift>-2.0000002 and t_drift<-1.9999998) {
          ATH_MSG_WARNING("Attempt failed. Making no correction.");
        } else {
          ATH_MSG_DEBUG("Correction Successful! z1 = " << std::fixed << std::setprecision(8) << z1 << ", zReadout = " << zReadout << ", t_drift = " << t_drift);
        }
      } else {
        ATH_MSG_DEBUG("No rounding error found. Making no correction.");
      }
    }
    if (t_drift > 0.0) {
      const float x1{xhit + stepX * dstep};
      float y1{yhit + stepY * dstep};
 
      float sigma{0.};
      if (not m_doInducedChargeModel) {
        sigma = diffusionSigma(zReadout, element, ctx);
        y1 += tanLorentz * zReadout; // !< Taking into account the magnetic field
      } // These are treated in Induced Charge Model.
 
      for (int i{0}; i < m_numberOfCharges; ++i) {
        const float rx{CLHEP::RandGaussZiggurat::shoot(rndmEngine)};
        const float xd{x1 + sigma * rx};
        const float ry{CLHEP::RandGaussZiggurat::shoot(rndmEngine)};
        const float yd{y1 + sigma * ry};
 
        // For charge trapping with Ramo potential
        const double stripPitch{0.080}; // mm
        double dstrip{y1 / stripPitch}; // mm
        if (dstrip > 0.) {
          dstrip = dstrip - std::trunc(dstrip);
        } else {
          dstrip = dstrip - std::trunc(dstrip) + 1;
        }
 
        // now y will be x and z will be y ....just to make sure to confuse everebody
        double y0{dstrip * stripPitch}; // mm
        double z0{thickness - zReadout}; // mm
 
        // -- Charge Trapping
        if (m_doTrapping) {
          if (m_doHistoTrap) {
            Hists& h = getHists();
            h.m_h_zhit->Fill(zhit);
          }
          double trap_pos{-999999.}, drift_time{-999999.}; // FIXME need better default values
          if (chargeIsTrapped(spess, element, trap_pos, drift_time, ctx)) {
            if (not m_doRamo) {
              break;
            } else {  // if we want to take into account also Ramo Potential
              double Q_m2{0.}, Q_m1{0.}, Q_00{0.}, Q_p1{0.}, Q_p2{0.}; // Charges
 
              dstrip = y1 / stripPitch; // mm
              // need the distance from the nearest strips
              // edge not centre, xtaka = 1/2*stripPitch
              // centre of detector, y1=0, is in the middle of
              // an interstrip gap
              if (dstrip > 0.) {
                dstrip -= static_cast<double>(static_cast<int>(dstrip));
              } else {
                dstrip -= static_cast<double>(static_cast<int>(dstrip)) + 1;
              }
 
              // now y will be x and z will be y ....just to make sure to confuse everebody
              double yfin{dstrip * stripPitch}; // mm
              double zfin{thickness - trap_pos}; // mm
 
              m_radDamageTool->holeTransport(y0, z0, yfin, zfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2, ctx);
              for (int strip{-2}; strip<=2; strip++) {
                const double ystrip{yd + strip * stripPitch}; // mm
                const SiLocalPosition position(element->hitLocalToLocal(xd, ystrip));
                if (design->inActiveArea(position)) {
                  double charge{0.};
                  if (strip == -2) charge = Q_m2;
                  else if (strip == -1) charge = Q_m1;
                  else if (strip ==  0) charge = Q_00;
                  else if (strip ==  1) charge = Q_p1;
                  else if (strip ==  2) charge = Q_p2;
                  const double time{drift_time};
                  if (charge != 0.) {
                    inserter(SiSurfaceCharge(position, SiCharge(q1*charge, time, hitproc, trklink)));
                    continue;
                  }
                }
              }
              ATH_MSG_INFO("strip zero charge = " << Q_00); // debug
            } // m_doRamo==true
          } // chargeIsTrapped()
        } // m_doTrapping==true
 
        if (not m_doRamo) {
          if (m_doInducedChargeModel) { // Induced Charge Model
            // Charges storages for 50 ns. 0.5 ns steps.
            double Q_m2[InducedChargeModel::NTransportSteps]={0};
            double Q_m1[InducedChargeModel::NTransportSteps]={0};
            double Q_00[InducedChargeModel::NTransportSteps]={0};
            double Q_p1[InducedChargeModel::NTransportSteps]={0};
            double Q_p2[InducedChargeModel::NTransportSteps]={0};
 
            const double mm2cm = 0.1; // For mm -> cm conversion
            // Unit for y and z : mm -> cm in InducedChargeModel
            m_InducedChargeModel->holeTransport(*data,
                                                y0*mm2cm, z0*mm2cm,
                                                Q_m2, Q_m1, Q_00, Q_p1, Q_p2,
                                                hashId, m_siPropertiesTool,
                                                ctx);
            m_InducedChargeModel->electronTransport(*data,
                                                    y0*mm2cm, z0*mm2cm,
                                                    Q_m2, Q_m1, Q_00, Q_p1, Q_p2,
                                                    hashId, m_siPropertiesTool,
                                                    ctx);
 
            for (int it{0}; it<InducedChargeModel::NTransportSteps; it++) {
              if (Q_00[it] == 0.0) continue;
              double ICM_time{(it+0.5)*0.5 + timeOfFlight};
              double Q_new[InducedChargeModel::NStrips]{
                Q_m2[it], Q_m1[it], Q_00[it], Q_p1[it], Q_p2[it]
              };
              for (int strip{InducedChargeModel::StartStrip}; strip<=InducedChargeModel::EndStrip; strip++) {
                double ystrip{y1 + strip * stripPitch};
                SiLocalPosition position{element->hitLocalToLocal(x1, ystrip)};
                if (design->inActiveArea(position)) {
                  inserter(SiSurfaceCharge(position,
                                           SiCharge(q1 * Q_new[strip+InducedChargeModel::Offset],
                                                    ICM_time, hitproc, trklink)));
                }
              }
            }
          } else { // not m_doInducedChargeModel
            const SiLocalPosition position{element->hitLocalToLocal(xd, yd)};
            if (design->inActiveArea(position)) {
              const float sdist{static_cast<float>(design->scaledDistanceToNearestDiode(position))};
              // !< dist on the surface from the hit point to the nearest strip (diode)
              const float t_surf{surfaceDriftTime(2.0 * sdist)}; // !< Surface drift time
              const float totaltime{(m_tfix > -998.) ? m_tfix.value() : t_drift + timeOfFlight + t_surf}; // !< Total drift time
              inserter(SiSurfaceCharge(position, SiCharge(q1, totaltime, hitproc, trklink)));
            } else {
              ATH_MSG_VERBOSE(std::fixed << std::setprecision(8) << "Local position (phi, eta, depth): ("
                              << position.xPhi() << ", " << position.xEta() << ", " << position.xDepth()
                              << ") of the element is out of active area, charge = " << q1);
            }
          }
        }
      } // end of loop on charges
    }
  }
  }

setFixedTime()

virtual void ITk::StripSurfaceChargesGenerator::setFixedTime ( float fixedTime )

inlineoverrideprivatevirtual

Definition at line 79 of file StripSurfaceChargesGenerator.h.

{m_tfix = fixedTime;}

surfaceDriftTime()

float ITk::StripSurfaceChargesGenerator::surfaceDriftTime ( float ysurf ) const

private

Calculate of the surface drift time.

Definition at line 288 of file StripSurfaceChargesGenerator.cxx.

                                                                      {
  if (m_SurfaceDriftFlag) {
    if ((ysurf >= 0.0) and (ysurf <= m_distInterStrip)) {
      float t_surfaceDrift{0.};
      if (ysurf < m_distHalfInterStrip) {
        const float y{ysurf / m_distHalfInterStrip};
        t_surfaceDrift= m_tHalfwayDrift * y * y;
      } else {
        const float y{(m_distInterStrip - ysurf) / (m_distInterStrip - m_distHalfInterStrip)};
        t_surfaceDrift = m_tSurfaceDrift + (m_tHalfwayDrift - m_tSurfaceDrift) * y * y;
      }
      return t_surfaceDrift;
    } else {
      ATH_MSG_INFO(" ysurf out of range " << ysurf);
      return -1.0;
    }
  } else {
    return 0.0;
  }
}

Member Data Documentation

m_distHalfInterStrip

float ITk::StripSurfaceChargesGenerator::m_distHalfInterStrip {0.}

private

Half way distance inter strip.

Definition at line 135 of file StripSurfaceChargesGenerator.h.

{0.}; 

m_distInterStrip

float ITk::StripSurfaceChargesGenerator::m_distInterStrip {1.0}

private

Inter strip distance normalized to 1.

Definition at line 134 of file StripSurfaceChargesGenerator.h.

{1.0}; 

m_doHistoTrap

BooleanProperty ITk::StripSurfaceChargesGenerator::m_doHistoTrap {this, "doHistoTrap", false, "Histogram the charge trapping effect"}

private

Definition at line 117 of file StripSurfaceChargesGenerator.h.

{this, "doHistoTrap", false, "Histogram the charge trapping effect"};

m_doInducedChargeModel

BooleanProperty ITk::StripSurfaceChargesGenerator::m_doInducedChargeModel {this, "doInducedChargeModel", false, "Flag for Induced Charge Model"}

private

Definition at line 120 of file StripSurfaceChargesGenerator.h.

{this, "doInducedChargeModel", false, "Flag for Induced Charge Model"};

m_doRamo

BooleanProperty ITk::StripSurfaceChargesGenerator::m_doRamo {this, "doRamo", false, "Ramo Potential for charge trapping effect"}

private

Definition at line 118 of file StripSurfaceChargesGenerator.h.

{this, "doRamo", false, "Ramo Potential for charge trapping effect"};

m_doTrapping

BooleanProperty ITk::StripSurfaceChargesGenerator::m_doTrapping {this, "doTrapping", false, "Flag to set Charge Trapping"}

private

Definition at line 116 of file StripSurfaceChargesGenerator.h.

{this, "doTrapping", false, "Flag to set Charge Trapping"};

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> ITk::StripSurfaceChargesGenerator::m_fieldCacheCondObjInputKey

private

Initial value:

{
    this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

Definition at line 130 of file StripSurfaceChargesGenerator.h.

                                                                         {
    this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};

m_h

std::unique_ptr<Hists> ITk::StripSurfaceChargesGenerator::m_h

private

Definition at line 165 of file StripSurfaceChargesGenerator.h.

m_InducedChargeModel

std::unique_ptr<InducedChargeModel> ITk::StripSurfaceChargesGenerator::m_InducedChargeModel

private

Definition at line 168 of file StripSurfaceChargesGenerator.h.

m_isOverlay

BooleanProperty ITk::StripSurfaceChargesGenerator::m_isOverlay {this, "isOverlay", false, "flag for overlay"}

private

Definition at line 119 of file StripSurfaceChargesGenerator.h.

{this, "isOverlay", false, "flag for overlay"};

m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> ITk::StripSurfaceChargesGenerator::m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/ITkStripLorentzAngleTool", "Tool to retreive Lorentz angle"}

private

Definition at line 126 of file StripSurfaceChargesGenerator.h.

{this, "LorentzAngleTool", "SiLorentzAngleTool/ITkStripLorentzAngleTool", "Tool to retreive Lorentz angle"};

m_numberOfCharges

IntegerProperty ITk::StripSurfaceChargesGenerator::m_numberOfCharges {this, "NumberOfCharges", 1, "number of charges"}

private

Definition at line 104 of file StripSurfaceChargesGenerator.h.

{this, "NumberOfCharges", 1, "number of charges"};

m_radDamageTool

ToolHandle<ISCT_RadDamageSummaryTool> ITk::StripSurfaceChargesGenerator::m_radDamageTool {this, "RadDamageSummaryTool", "StripRadDamageSummaryTool", "Tool to retrieve SCT radiation damages"}

private

Definition at line 124 of file StripSurfaceChargesGenerator.h.

{this, "RadDamageSummaryTool", "StripRadDamageSummaryTool", "Tool to retrieve SCT radiation damages"};

m_siConditionsTool

ToolHandle<ISiliconConditionsTool> ITk::StripSurfaceChargesGenerator::m_siConditionsTool {this, "SiConditionsTool", "StripSiliconConditionsTool", "Tool to retrieve SCT silicon information"}

private

Definition at line 125 of file StripSurfaceChargesGenerator.h.

{this, "SiConditionsTool", "StripSiliconConditionsTool", "Tool to retrieve SCT silicon information"};

m_siPropertiesTool

ToolHandle<ISiPropertiesTool> ITk::StripSurfaceChargesGenerator::m_siPropertiesTool {this, "SiPropertiesTool", "StripSiPropertiesTool", "Tool to retrieve SCT silicon properties"}

private

Definition at line 123 of file StripSurfaceChargesGenerator.h.

{this, "SiPropertiesTool", "StripSiPropertiesTool", "Tool to retrieve SCT silicon properties"};

m_smallStepLength

FloatProperty ITk::StripSurfaceChargesGenerator::m_smallStepLength {this, "SmallStepLength", 5 * CLHEP::micrometer, "max internal step along the larger G4 step"}

private

Definition at line 105 of file StripSurfaceChargesGenerator.h.

{this, "SmallStepLength", 5 * CLHEP::micrometer, "max internal step along the larger G4 step"};

m_SurfaceDriftFlag

bool ITk::StripSurfaceChargesGenerator::m_SurfaceDriftFlag {false}

private

surface drift ON/OFF

Definition at line 137 of file StripSurfaceChargesGenerator.h.

{false}; 

m_tfix

FloatProperty ITk::StripSurfaceChargesGenerator::m_tfix {this, "FixedTime", -999., "fixed time"}

private

Definition at line 110 of file StripSurfaceChargesGenerator.h.

{this, "FixedTime", -999., "fixed time"};

m_tHalfwayDrift

float ITk::StripSurfaceChargesGenerator::m_tHalfwayDrift {0.}

private

Surface drift time.

Definition at line 133 of file StripSurfaceChargesGenerator.h.

{0.}; 

m_thistSvc

ServiceHandle<ITHistSvc> ITk::StripSurfaceChargesGenerator::m_thistSvc {this, "THistSvc", "THistSvc"}

private

Definition at line 128 of file StripSurfaceChargesGenerator.h.

{this, "THistSvc", "THistSvc"};

m_tsubtract

FloatProperty ITk::StripSurfaceChargesGenerator::m_tsubtract {this, "SubtractTime", -999., "subtract drift time from mid gap"}

private

Definition at line 111 of file StripSurfaceChargesGenerator.h.

{this, "SubtractTime", -999., "subtract drift time from mid gap"};

m_tSurfaceDrift

FloatProperty ITk::StripSurfaceChargesGenerator::m_tSurfaceDrift {this, "SurfaceDriftTime", 10 * CLHEP::ns, "max surface drift time"}

private

related to the surface drift

Definition at line 108 of file StripSurfaceChargesGenerator.h.

{this, "SurfaceDriftTime", 10 * CLHEP::ns, "max surface drift time"};

m_useSiCondDB

BooleanProperty ITk::StripSurfaceChargesGenerator::m_useSiCondDB {this, "UseSiCondDB", true, "Usage of SiConditions DB values can be disabled to use setable ones"}

private

Definition at line 113 of file StripSurfaceChargesGenerator.h.

{this, "UseSiCondDB", true, "Usage of SiConditions DB values can be disabled to use setable ones"};

m_vbias

FloatProperty ITk::StripSurfaceChargesGenerator::m_vbias {this, "BiasVoltage", 150., "bias voltage, default 150V"}

private

Definition at line 115 of file StripSurfaceChargesGenerator.h.

{this, "BiasVoltage", 150., "bias voltage, default 150V"};

m_vdepl

FloatProperty ITk::StripSurfaceChargesGenerator::m_vdepl {this, "DepletionVoltage", 70., "depletion voltage, default 70V"}

private

Definition at line 114 of file StripSurfaceChargesGenerator.h.

{this, "DepletionVoltage", 70., "depletion voltage, default 70V"};

---

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

• StripSurfaceChargesGenerator.h
• StripSurfaceChargesGenerator.cxx