#include <SCT_SurfaceChargesGenerator.h>

Inheritance diagram for SCT_SurfaceChargesGenerator:

Collaboration diagram for SCT_SurfaceChargesGenerator:

Public Member Functions
	SCT_SurfaceChargesGenerator (const std::string &type, const std::string &name, const IInterface *parent)
	constructor More...

virtual	~SCT_SurfaceChargesGenerator ()=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)

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)

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", "SCT_SiPropertiesTool", "Tool to retrieve SCT silicon properties"}

ToolHandle< ISCT_RadDamageSummaryTool >	m_radDamageTool {this, "RadDamageSummaryTool", "SCT_RadDamageSummaryTool", "Tool to retrieve SCT radiation damages"}

ToolHandle< ISiliconConditionsTool >	m_siConditionsTool {this, "SiConditionsTool", "SCT_SiliconConditionsTool", "Tool to retrieve SCT silicon information"}

ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "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...

TProfile *	m_h_efieldz {nullptr}

TH1F *	m_h_efield {nullptr}

TH1F *	m_h_spess {nullptr}

TH1F *	m_h_depD {nullptr}

TH2F *	m_h_drift_electrode {nullptr}

TH1F *	m_h_ztrap {nullptr}

TH1F *	m_h_drift_time {nullptr}

TH1F *	m_h_t_electrode {nullptr}

TH1F *	m_h_zhit {nullptr}

TH1F *	m_h_ztrap_tot {nullptr}

TH1F *	m_h_no_ztrap {nullptr}

TH1F *	m_h_trap_drift_t {nullptr}

TH1F *	m_h_notrap_drift_t {nullptr}

TProfile *	m_h_mob_Char {nullptr}

TProfile *	m_h_vel {nullptr}

TProfile *	m_h_drift1 {nullptr}

TProfile *	m_h_gen {nullptr}

TProfile *	m_h_gen1 {nullptr}

TProfile *	m_h_gen2 {nullptr}

TProfile *	m_h_velocity_trap {nullptr}

TProfile *	m_h_mobility_trap {nullptr}

TH1F *	m_h_trap_pos {nullptr}

std::unique_ptr< InducedChargeModel >	m_InducedChargeModel

Detailed Description

Definition at line 79 of file SCT_SurfaceChargesGenerator.h.

Constructor & Destructor Documentation

◆ SCT_SurfaceChargesGenerator()

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

constructor

Definition at line 35 of file SCT_SurfaceChargesGenerator.cxx.

38 : base_class(type, name, parent) {

39 }

◆ ~SCT_SurfaceChargesGenerator()

virtual SCT_SurfaceChargesGenerator::~SCT_SurfaceChargesGenerator ( )

virtualdefault

Destructor.

Member Function Documentation

◆ chargeIsTrapped()

bool SCT_SurfaceChargesGenerator::chargeIsTrapped	(	double	spess,
		const InDetDD::SiDetectorElement *	element,
		double &	trap_pos,
		double &	drift_time
	)

private

Definition at line 570 of file SCT_SurfaceChargesGenerator.cxx.

                                                                       {
   if (element==nullptr) {
     ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::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) {
     const double mobChar{condData.getHoleDriftMobility()};
     m_h_efieldz->Fill(spess, electric_field);
     m_h_efield->Fill(electric_field);
     m_h_mob_Char->Fill(electric_field, mobChar);
     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) {
     m_h_drift_time->Fill(drift_time);
     m_h_t_electrode->Fill(t_electrode);
     m_h_drift_electrode->Fill(drift_time, t_electrode);
     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) {
       m_h_ztrap->Fill(z_trap);
       m_h_trap_drift_t->Fill(drift_time);
       m_h_drift1->Fill(spess, drift_time / t_electrode);
       m_h_gen->Fill(spess, drift_time);
       m_h_gen1->Fill(spess, z_trap);
       m_h_gen2->Fill(spess, z_trap / drift_time * t_electrode);
       m_h_velocity_trap->Fill(electric_field, z_trap / drift_time);
       m_h_mobility_trap->Fill(electric_field, z_trap / drift_time / electric_field);
       m_h_trap_pos->Fill(trap_pos);
     }
   } else {
     isTrapped = false;
     if (m_doHistoTrap) {
       const double z_trap{condData.getTrappingPositionZ()};
       m_h_no_ztrap->Fill(z_trap);
       m_h_notrap_drift_t->Fill(drift_time);
     }
   }
   return isTrapped;
 }

◆ diffusionSigma()

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

private

calculate diffusion sigma from a gaussian dist scattered charge

Definition at line 224 of file SCT_SurfaceChargesGenerator.cxx.

                                                                                                                              {
   if (element==nullptr) {
     ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::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 SCT_SurfaceChargesGenerator::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 175 of file SCT_SurfaceChargesGenerator.cxx.

                                                                                                                         {
   if (element==nullptr) {
     ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::process element is nullptr");
     return -2.0;
   }
   const SCT_ModuleSideDesign* design{dynamic_cast<const SCT_ModuleSideDesign*>(&(element->design()))};
   if (design==nullptr) {
     ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::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 SCT_SurfaceChargesGenerator::finalize ( )

overridevirtual

AlgTool finalize.

Definition at line 167 of file SCT_SurfaceChargesGenerator.cxx.

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

◆ initialize()

StatusCode SCT_SurfaceChargesGenerator::initialize ( )

overridevirtual

AlgTool initialize.

Definition at line 44 of file SCT_SurfaceChargesGenerator.cxx.

                                                    {
   ATH_MSG_DEBUG("SCT_SurfaceChargesGenerator::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) {
     // -- Get Histogram Service
     ATH_CHECK(m_thistSvc.retrieve());
  
     m_h_efieldz = new TProfile("efieldz", "", 50, 0., 0.4);
     ATH_CHECK(m_thistSvc->regHist("/file1/efieldz", m_h_efieldz));
  
     m_h_efield = new TH1F("efield", "", 100, 200., 800.);
     ATH_CHECK(m_thistSvc->regHist("/file1/efield", m_h_efield));
  
     m_h_spess = new TH1F("spess", "", 50, 0., 0.4);
     ATH_CHECK(m_thistSvc->regHist("/file1/spess", m_h_spess));
  
     m_h_depD = new TH1F("depD", "", 50, -0.3, 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/depD", m_h_depD));
  
     m_h_drift_electrode = new TH2F("drift_electrode", "", 50, 0., 20., 50, 0., 20.);
     ATH_CHECK(m_thistSvc->regHist("/file1/drift_electrode", m_h_drift_electrode));
  
     m_h_drift_time = new TH1F("drift_time", "", 100, 0., 20.);
     ATH_CHECK(m_thistSvc->regHist("/file1/drift_time", m_h_drift_time));
  
     m_h_t_electrode = new TH1F("t_electrode", "", 100, 0., 20.);
     ATH_CHECK(m_thistSvc->regHist("/file1/t_electrode", m_h_t_electrode));
  
     m_h_ztrap = new TH1F("ztrap", "", 100, 0., 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/ztrap", m_h_ztrap));
  
     // More histograms to check what's going on
     m_h_zhit = new TH1F("zhit", "", 50, -0.2, 0.2);
     ATH_CHECK(m_thistSvc->regHist("/file1/zhit", m_h_zhit));
  
     m_h_ztrap_tot = new TH1F("ztrap_tot", "", 100, 0., 0.5);
     ATH_CHECK(m_thistSvc->regHist("/file1/ztrap_tot", m_h_ztrap_tot));
  
     m_h_no_ztrap = new TH1F("no_ztrap", "", 100, 0., 0.5);
     ATH_CHECK(m_thistSvc->regHist("/file1/no_ztrap", m_h_no_ztrap));
  
     m_h_trap_drift_t = new TH1F("trap_drift_t", "", 100, 0., 20.);
     ATH_CHECK(m_thistSvc->regHist("/file1/trap_drift_t", m_h_trap_drift_t));
  
     m_h_notrap_drift_t = new TH1F("notrap_drift_t", "", 100, 0., 20.);
     ATH_CHECK(m_thistSvc->regHist("/file1/notrap_drift_t", m_h_notrap_drift_t));
  
     m_h_mob_Char = new TProfile("mob_Char", "", 200, 100., 1000.);
     ATH_CHECK(m_thistSvc->regHist("/file1/mob_Char", m_h_mob_Char));
  
     m_h_vel = new TProfile("vel", "", 100, 100., 1000.);
     ATH_CHECK(m_thistSvc->regHist("/file1/vel", m_h_vel));
  
     m_h_drift1 = new TProfile("drift1", "", 50, 0., 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/drift1", m_h_drift1));
  
     m_h_gen = new TProfile("gen", "", 50, 0., 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/gen", m_h_gen));
  
     m_h_gen1 = new TProfile("gen1", "", 50, 0., 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/gen1", m_h_gen1));
  
     m_h_gen2 = new TProfile("gen2", "", 50, 0., 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/gen2", m_h_gen2));
  
     m_h_velocity_trap = new TProfile("velocity_trap", "", 50, 0., 1000.);
     ATH_CHECK(m_thistSvc->regHist("/file1/velocity_trap", m_h_velocity_trap));
  
     m_h_mobility_trap = new TProfile("mobility_trap", "", 50, 100., 1000.);
     ATH_CHECK(m_thistSvc->regHist("/file1/mobility_trap", m_h_mobility_trap));
  
     m_h_trap_pos = new TH1F("trap_pos", "", 100, 0., 0.3);
     ATH_CHECK(m_thistSvc->regHist("/file1/trap_pos", m_h_trap_pos));
   }
  
   // 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 SCT_SurfaceChargesGenerator::maxDiffusionSigma	(	const InDetDD::SiDetectorElement *	element,
		const EventContext &	ctx
	)		const

private

max sigma diffusion

Definition at line 256 of file SCT_SurfaceChargesGenerator.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 SCT_SurfaceChargesGenerator::maxDriftTime	(	const InDetDD::SiDetectorElement *	element,
		const EventContext &	ctx
	)		const

private

max drift charge equivalent to the detector thickness

Definition at line 243 of file SCT_SurfaceChargesGenerator.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 SCT_SurfaceChargesGenerator::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 295 of file SCT_SurfaceChargesGenerator.cxx.

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

◆ processSiHit()

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

private

Definition at line 308 of file SCT_SurfaceChargesGenerator.cxx.

                                                                         {
   const SCT_ModuleSideDesign* design{dynamic_cast<const SCT_ModuleSideDesign*>(&(element->design()))};
   if (design==nullptr) {
     ATH_MSG_ERROR("SCT_SurfaceChargesGenerator::process can not get " << design);
     return;
   }
  
   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())};
  
   // in the following, to test the code, we will use the original coordinate
   // system of the SCTtest3SurfaceChargesGenerator x is eta y is phi z is depth
   float xhit{xEta};
   float yhit{xPhi};
   float zhit{xDep};
  
   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{cEta / numberOfSteps};
   const float StepY{cPhi / numberOfSteps};
   const float StepZ{cDep / 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) {
       m_h_depD->Fill(z1);
       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) {
             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_all[5]={0.0,0.0,0.0,0.0,0.0};
  
               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_all[0], Q_all[1], Q_all[2], Q_all[3], Q_all[4]);
               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)) {
                   const double charge = Q_all[strip+2];
                   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_all[2]); // 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 SCT_SurfaceChargesGenerator::setFixedTime ( float fixedTime )

inlineoverrideprivatevirtual

Definition at line 96 of file SCT_SurfaceChargesGenerator.h.

96 {m_tfix = fixedTime;}

◆ surfaceDriftTime()

float SCT_SurfaceChargesGenerator::surfaceDriftTime ( float ysurf ) const

private

Calculate of the surface drift time.

Definition at line 270 of file SCT_SurfaceChargesGenerator.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 SCT_SurfaceChargesGenerator::m_distHalfInterStrip {0.}

private

Half way distance inter strip.

Definition at line 143 of file SCT_SurfaceChargesGenerator.h.

◆ m_distInterStrip

float SCT_SurfaceChargesGenerator::m_distInterStrip {1.0}

private

Inter strip distance normalized to 1.

Definition at line 142 of file SCT_SurfaceChargesGenerator.h.

◆ m_doHistoTrap

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

private

Definition at line 125 of file SCT_SurfaceChargesGenerator.h.

◆ m_doInducedChargeModel

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

private

Definition at line 128 of file SCT_SurfaceChargesGenerator.h.

◆ m_doRamo

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

private

Definition at line 126 of file SCT_SurfaceChargesGenerator.h.

◆ m_doTrapping

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

private

Definition at line 124 of file SCT_SurfaceChargesGenerator.h.

◆ m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> SCT_SurfaceChargesGenerator::m_fieldCacheCondObjInputKey

private

Initial value:

{

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

Definition at line 138 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_depD

TH1F* SCT_SurfaceChargesGenerator::m_h_depD {nullptr}

private

Definition at line 151 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_drift1

TProfile* SCT_SurfaceChargesGenerator::m_h_drift1 {nullptr}

private

Definition at line 163 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_drift_electrode

TH2F* SCT_SurfaceChargesGenerator::m_h_drift_electrode {nullptr}

private

Definition at line 152 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_drift_time

TH1F* SCT_SurfaceChargesGenerator::m_h_drift_time {nullptr}

private

Definition at line 154 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_efield

TH1F* SCT_SurfaceChargesGenerator::m_h_efield {nullptr}

private

Definition at line 149 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_efieldz

TProfile* SCT_SurfaceChargesGenerator::m_h_efieldz {nullptr}

private

Definition at line 148 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_gen

TProfile* SCT_SurfaceChargesGenerator::m_h_gen {nullptr}

private

Definition at line 164 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_gen1

TProfile* SCT_SurfaceChargesGenerator::m_h_gen1 {nullptr}

private

Definition at line 165 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_gen2

TProfile* SCT_SurfaceChargesGenerator::m_h_gen2 {nullptr}

private

Definition at line 166 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_mob_Char

TProfile* SCT_SurfaceChargesGenerator::m_h_mob_Char {nullptr}

private

Definition at line 161 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_mobility_trap

TProfile* SCT_SurfaceChargesGenerator::m_h_mobility_trap {nullptr}

private

Definition at line 168 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_no_ztrap

TH1F* SCT_SurfaceChargesGenerator::m_h_no_ztrap {nullptr}

private

Definition at line 158 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_notrap_drift_t

TH1F* SCT_SurfaceChargesGenerator::m_h_notrap_drift_t {nullptr}

private

Definition at line 160 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_spess

TH1F* SCT_SurfaceChargesGenerator::m_h_spess {nullptr}

private

Definition at line 150 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_t_electrode

TH1F* SCT_SurfaceChargesGenerator::m_h_t_electrode {nullptr}

private

Definition at line 155 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_trap_drift_t

TH1F* SCT_SurfaceChargesGenerator::m_h_trap_drift_t {nullptr}

private

Definition at line 159 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_trap_pos

TH1F* SCT_SurfaceChargesGenerator::m_h_trap_pos {nullptr}

private

Definition at line 169 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_vel

TProfile* SCT_SurfaceChargesGenerator::m_h_vel {nullptr}

private

Definition at line 162 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_velocity_trap

TProfile* SCT_SurfaceChargesGenerator::m_h_velocity_trap {nullptr}

private

Definition at line 167 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_zhit

TH1F* SCT_SurfaceChargesGenerator::m_h_zhit {nullptr}

private

Definition at line 156 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_ztrap

TH1F* SCT_SurfaceChargesGenerator::m_h_ztrap {nullptr}

private

Definition at line 153 of file SCT_SurfaceChargesGenerator.h.

◆ m_h_ztrap_tot

TH1F* SCT_SurfaceChargesGenerator::m_h_ztrap_tot {nullptr}

private

Definition at line 157 of file SCT_SurfaceChargesGenerator.h.

◆ m_InducedChargeModel

std::unique_ptr<InducedChargeModel> SCT_SurfaceChargesGenerator::m_InducedChargeModel

private

Definition at line 172 of file SCT_SurfaceChargesGenerator.h.

◆ m_isOverlay

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

private

Definition at line 127 of file SCT_SurfaceChargesGenerator.h.

◆ m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> SCT_SurfaceChargesGenerator::m_lorentzAngleTool {this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retreive Lorentz angle"}

private

Definition at line 134 of file SCT_SurfaceChargesGenerator.h.

◆ m_numberOfCharges

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

private

Definition at line 112 of file SCT_SurfaceChargesGenerator.h.

◆ m_radDamageTool

ToolHandle<ISCT_RadDamageSummaryTool> SCT_SurfaceChargesGenerator::m_radDamageTool {this, "RadDamageSummaryTool", "SCT_RadDamageSummaryTool", "Tool to retrieve SCT radiation damages"}

private

Definition at line 132 of file SCT_SurfaceChargesGenerator.h.

◆ m_siConditionsTool

ToolHandle<ISiliconConditionsTool> SCT_SurfaceChargesGenerator::m_siConditionsTool {this, "SiConditionsTool", "SCT_SiliconConditionsTool", "Tool to retrieve SCT silicon information"}

private

Definition at line 133 of file SCT_SurfaceChargesGenerator.h.

◆ m_siPropertiesTool

ToolHandle<ISiPropertiesTool> SCT_SurfaceChargesGenerator::m_siPropertiesTool {this, "SiPropertiesTool", "SCT_SiPropertiesTool", "Tool to retrieve SCT silicon properties"}

private

Definition at line 131 of file SCT_SurfaceChargesGenerator.h.

◆ m_smallStepLength

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

private

Definition at line 113 of file SCT_SurfaceChargesGenerator.h.

◆ m_SurfaceDriftFlag

bool SCT_SurfaceChargesGenerator::m_SurfaceDriftFlag {false}

private

surface drift ON/OFF

Definition at line 145 of file SCT_SurfaceChargesGenerator.h.

◆ m_tfix

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

private

Definition at line 118 of file SCT_SurfaceChargesGenerator.h.

◆ m_tHalfwayDrift

float SCT_SurfaceChargesGenerator::m_tHalfwayDrift {0.}

private

Surface drift time.

Definition at line 141 of file SCT_SurfaceChargesGenerator.h.

◆ m_thistSvc

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

private

Definition at line 136 of file SCT_SurfaceChargesGenerator.h.

◆ m_tsubtract

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

private

Definition at line 119 of file SCT_SurfaceChargesGenerator.h.

◆ m_tSurfaceDrift

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

private

related to the surface drift

Definition at line 116 of file SCT_SurfaceChargesGenerator.h.

◆ m_useSiCondDB

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

private

Definition at line 121 of file SCT_SurfaceChargesGenerator.h.

◆ m_vbias

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

private

Definition at line 123 of file SCT_SurfaceChargesGenerator.h.

◆ m_vdepl

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

private

Definition at line 122 of file SCT_SurfaceChargesGenerator.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SCT_SurfaceChargesGenerator()

◆ ~SCT_SurfaceChargesGenerator()

Member Function Documentation

◆ chargeIsTrapped()

◆ diffusionSigma()

◆ driftTime()

◆ finalize()

◆ initialize()

◆ maxDiffusionSigma()

◆ maxDriftTime()

◆ process()

◆ processSiHit()

◆ setFixedTime()

◆ surfaceDriftTime()

Member Data Documentation

◆ m_distHalfInterStrip

◆ m_distInterStrip

◆ m_doHistoTrap

◆ m_doInducedChargeModel

◆ m_doRamo

◆ m_doTrapping

◆ m_fieldCacheCondObjInputKey

◆ m_h_depD

◆ m_h_drift1

◆ m_h_drift_electrode

◆ m_h_drift_time

◆ m_h_efield

◆ m_h_efieldz

◆ m_h_gen

◆ m_h_gen1

◆ m_h_gen2

◆ m_h_mob_Char

◆ m_h_mobility_trap

◆ m_h_no_ztrap

◆ m_h_notrap_drift_t

◆ m_h_spess

◆ m_h_t_electrode

◆ m_h_trap_drift_t

◆ m_h_trap_pos

◆ m_h_vel

◆ m_h_velocity_trap

◆ m_h_zhit

◆ m_h_ztrap

◆ m_h_ztrap_tot

◆ m_InducedChargeModel

◆ m_isOverlay

◆ m_lorentzAngleTool

◆ m_numberOfCharges

◆ m_radDamageTool

◆ m_siConditionsTool

◆ m_siPropertiesTool

◆ m_smallStepLength

◆ m_SurfaceDriftFlag

◆ m_tfix

◆ m_tHalfwayDrift

◆ m_thistSvc

◆ m_tsubtract

◆ m_tSurfaceDrift

◆ m_useSiCondDB

◆ m_vbias

◆ m_vdepl