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 More...
virtual	~StripSurfaceChargesGenerator ()=default
	Destructor. More...
virtual StatusCode	initialize () override
	AlgTool initialize. More...
virtual StatusCode	finalize () override
	AlgTool finalize. More...

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 More...
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 More...
float	diffusionSigma (float zhit, const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	calculate diffusion sigma from a gaussian dist scattered charge More...
float	surfaceDriftTime (float ysurf) const
	Calculate of the surface drift time. More...
float	maxDriftTime (const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	max drift charge equivalent to the detector thickness More...
float	maxDiffusionSigma (const InDetDD::SiDetectorElement *element, const EventContext &ctx) const
	max sigma diffusion More...
bool	chargeIsTrapped (double spess, const InDetDD::SiDetectorElement *element, double &trap_pos, double &drift_time) 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 More...
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. More...
float	m_distInterStrip {1.0}
	Inter strip distance normalized to 1. More...
float	m_distHalfInterStrip {0.}
	Half way distance inter strip. More...
bool	m_SurfaceDriftFlag {false}
	surface drift ON/OFF More...
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

private

Definition at line 622 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)};
  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 686 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};
    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)) {
            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);
              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.

m_distInterStrip

float ITk::StripSurfaceChargesGenerator::m_distInterStrip {1.0}

private

Inter strip distance normalized to 1.

Definition at line 134 of file StripSurfaceChargesGenerator.h.

m_doHistoTrap

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

private

Definition at line 117 of file StripSurfaceChargesGenerator.h.

m_doInducedChargeModel

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

private

Definition at line 120 of file StripSurfaceChargesGenerator.h.

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.

m_doTrapping

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

private

Definition at line 116 of file StripSurfaceChargesGenerator.h.

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.

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.

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.

m_numberOfCharges

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

private

Definition at line 104 of file StripSurfaceChargesGenerator.h.

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.

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.

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.

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.

m_SurfaceDriftFlag

bool ITk::StripSurfaceChargesGenerator::m_SurfaceDriftFlag {false}

private

surface drift ON/OFF

Definition at line 137 of file StripSurfaceChargesGenerator.h.

m_tfix

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

private

Definition at line 110 of file StripSurfaceChargesGenerator.h.

m_tHalfwayDrift

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

private

Surface drift time.

Definition at line 133 of file StripSurfaceChargesGenerator.h.

m_thistSvc

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

private

Definition at line 128 of file StripSurfaceChargesGenerator.h.

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.

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.

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.

m_vbias

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

private

Definition at line 115 of file StripSurfaceChargesGenerator.h.

m_vdepl

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

private

Definition at line 114 of file StripSurfaceChargesGenerator.h.

---

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

• StripSurfaceChargesGenerator.h
• StripSurfaceChargesGenerator.cxx