#include <Phase2TrackerDigitizerAlgorithm.h>

Inheritance diagram for Phase2TrackerDigitizerAlgorithm:

Classes
struct	SubdetEfficiencies

Public Member Functions
virtual void	accumulateSimHits (const std::vector< PSimHit >::const_iterator inputBegin, const std::vector< PSimHit >::const_iterator inputEnd, const size_t inputBeginGlobalIndex, const uint32_t tofBin, const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield)

virtual void	digitize (const Phase2TrackerGeomDetUnit pixdet, std::map< int, digitizerUtility::DigiSimInfo > &digi_map, const TrackerTopology tTopo)

virtual void	init (const edm::EventSetup &es)=0

virtual void	initializeEvent (CLHEP::HepRandomEngine &eng)

virtual bool	isAboveThreshold (const digitizerUtility::SimHitInfo *hitInfo, float charge, float thr) const

void	loadAccumulator (uint32_t detId, const std::map< int, float > &accumulator)

	Phase2TrackerDigitizerAlgorithm (const edm::ParameterSet &conf_common, const edm::ParameterSet &conf_specific, edm::ConsumesCollector iC)

virtual bool	select_hit (const PSimHit &hit, double tCorr, double &sigScale) const

virtual	~Phase2TrackerDigitizerAlgorithm ()

Protected Types
using	Frame = GloballyPositioned< double >

using	Parameters = std::vector< edm::ParameterSet >

using	signal_map_type = std::map< int, digitizerUtility::Ph2Amplitude, std::less< int > >

using	signalMaps = std::map< uint32_t, signal_map_type >

Protected Member Functions
virtual void	add_cross_talk (const Phase2TrackerGeomDetUnit *pixdet)

virtual void	add_noise (const Phase2TrackerGeomDetUnit *pixdet)

virtual void	add_noisy_cells (const Phase2TrackerGeomDetUnit *pixdet, float thePixelThreshold)

float	calcQ (float x)

int	convertSignalToAdc (uint32_t detID, float signal_in_elec, float threshold)

virtual std::vector< digitizerUtility::SignalPoint >	drift (const PSimHit &hit, const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield, const std::vector< digitizerUtility::EnergyDepositUnit > &ionization_points) const

LocalVector	driftDirection (const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield, const DetId &detId) const

virtual std::vector< float >	fluctuateEloss (int particleId, float momentum, float eloss, float length, int NumberOfSegments) const

virtual void	induce_signal (std::vector< PSimHit >::const_iterator inputBegin, const PSimHit &hit, const size_t hitIndex, const size_t firstHitIndex, const uint32_t tofBin, const Phase2TrackerGeomDetUnit *pixdet, const std::vector< digitizerUtility::SignalPoint > &collection_points)

virtual void	module_killing_conf (uint32_t detID)

virtual void	module_killing_DB (const Phase2TrackerGeomDetUnit *pixdet)=0

virtual void	pixel_inefficiency (const SubdetEfficiencies &eff, const Phase2TrackerGeomDetUnit pixdet, const TrackerTopology tTopo)

virtual void	pixel_inefficiency_db (uint32_t detID)

virtual std::vector< digitizerUtility::EnergyDepositUnit >	primary_ionization (const PSimHit &hit) const

Protected Attributes
signalMaps	_signal

const bool	addNoise_

const bool	addNoisyPixels_

const bool	addPixelInefficiency_

const bool	addThresholdSmearing_

const bool	addXtalk_

const bool	alpha2Order_

Parameters	badPixels_

const float	clusterWidth_

const Parameters	deadModules_

const std::unique_ptr< SiG4UniversalFluctuation >	fluctuate_

const bool	fluctuateCharge_

std::unique_ptr< CLHEP::RandGaussQ >	gaussDistribution_

const TrackerGeometry *	geom_

const float	GeVperElectron_

const float	interstripCoupling_

const bool	makeDigiSimLinks_

bool	pixelFlag_

const double	pseudoRadDamage_

const double	pseudoRadDamageRadius_

CLHEP::HepRandomEngine *	rengine_

const float	Sigma0_

const float	SigmaCoeff_

const SiPhase2OuterTrackerLorentzAngle *	siPhase2OTLorentzAngle_

const SiPixelQuality *	siPixelBadModule_

const SiPixelLorentzAngle *	siPixelLorentzAngle_

std::unique_ptr< CLHEP::RandGaussQ >	smearedThreshold_Barrel_

std::unique_ptr< CLHEP::RandGaussQ >	smearedThreshold_Endcap_

const SubdetEfficiencies	subdetEfficiencies_

const float	tanLorentzAnglePerTesla_Barrel_

const float	tanLorentzAnglePerTesla_Endcap_

const int	theAdcFullScale_

const float	theElectronPerADC_

const double	theHIPThresholdInE_Barrel_

const double	theHIPThresholdInE_Endcap_

const float	theNoiseInElectrons_

const std::unique_ptr< GaussianTailNoiseGenerator >	theNoiser_

const int	thePhase2ReadoutMode_

const float	theReadoutNoise_

const std::unique_ptr< SiPixelChargeReweightingAlgorithm >	theSiPixelChargeReweightingAlgorithm_

const std::unique_ptr< SiPixelGainCalibrationOfflineSimService >	theSiPixelGainCalibrationService_

const float	theThresholdInE_Barrel_

const float	theThresholdInE_Endcap_

const double	theThresholdSmearing_Barrel_

const double	theThresholdSmearing_Endcap_

const float	theTofLowerCut_

const float	theTofUpperCut_

const double	tMax_

const bool	use_deadmodule_DB_

const bool	use_ineff_from_db_

const bool	use_LorentzAngle_DB_

const bool	use_module_killing_

const bool	useChargeReweighting_

Detailed Description

Definition at line 55 of file Phase2TrackerDigitizerAlgorithm.h.

Member Typedef Documentation

◆ Frame

using Phase2TrackerDigitizerAlgorithm::Frame = GloballyPositioned<double>

protected

Definition at line 105 of file Phase2TrackerDigitizerAlgorithm.h.

◆ Parameters

using Phase2TrackerDigitizerAlgorithm::Parameters = std::vector<edm::ParameterSet>

protected

Definition at line 106 of file Phase2TrackerDigitizerAlgorithm.h.

◆ signal_map_type

using Phase2TrackerDigitizerAlgorithm::signal_map_type = std::map<int, digitizerUtility::Ph2Amplitude, std::less<int> >

protected

Definition at line 103 of file Phase2TrackerDigitizerAlgorithm.h.

◆ signalMaps

using Phase2TrackerDigitizerAlgorithm::signalMaps = std::map<uint32_t, signal_map_type>

protected

Definition at line 104 of file Phase2TrackerDigitizerAlgorithm.h.

Constructor & Destructor Documentation

◆ Phase2TrackerDigitizerAlgorithm()

Phase2TrackerDigitizerAlgorithm::Phase2TrackerDigitizerAlgorithm	(	const edm::ParameterSet &	conf_common,
		const edm::ParameterSet &	conf_specific,
		edm::ConsumesCollector	iC
	)

Definition at line 38 of file Phase2TrackerDigitizerAlgorithm.cc.

References addPixelInefficiency_, LogDebug, theAdcFullScale_, theElectronPerADC_, theThresholdInE_Barrel_, theThresholdInE_Endcap_, and tMax_.

     : _signal(),
       makeDigiSimLinks_(conf_common.getUntrackedParameter<bool>("makeDigiSimLinks", true)),
       use_ineff_from_db_(conf_specific.getParameter<bool>("Inefficiency_DB")),
       use_module_killing_(conf_specific.getParameter<bool>("KillModules")),    // boolean to kill or not modules
       use_deadmodule_DB_(conf_specific.getParameter<bool>("DeadModules_DB")),  // boolean to access dead modules from DB
       // boolean to access Lorentz angle from DB
       use_LorentzAngle_DB_(conf_specific.getParameter<bool>("LorentzAngle_DB")),
 
       // get dead module from cfg file
       deadModules_(use_deadmodule_DB_ ? Parameters() : conf_specific.getParameter<Parameters>("DeadModules")),
 
       // Common pixel parameters
       // These are parameters which are not likely to be changed
       GeVperElectron_(3.61E-09),                                      // 1 electron(3.61eV, 1keV(277e, mod 9/06 d.k.
       alpha2Order_(conf_specific.getParameter<bool>("Alpha2Order")),  // switch on/off of E.B effect
       addXtalk_(conf_specific.getParameter<bool>("AddXTalk")),
       // Interstrip Coupling - Not used in PixelDigitizerAlgorithm
       interstripCoupling_(conf_specific.getParameter<double>("InterstripCoupling")),
 
       Sigma0_(conf_specific.getParameter<double>("SigmaZero")),       // Charge diffusion constant 7->3.7
       SigmaCoeff_(conf_specific.getParameter<double>("SigmaCoeff")),  // delta in the diffusion across the strip pitch
       // (set between 0 to 0.9,  0-->flat Sigma0, 1-->Sigma_min=0 & Sigma_max=2*Sigma0
       // D.B.: Dist300 replaced by moduleThickness, may not work with partially depleted sensors but works otherwise
       // Dist300(0.0300),                                          //   normalized to 300micron Silicon
 
       // Charge integration spread on the collection plane
       clusterWidth_(conf_specific.getParameter<double>("ClusterWidth")),
 
       // Allowed modes of readout which has following values :
       // 0          ---> Digital or binary readout
       // -1         ---> Analog readout, current digitizer (Inner Pixel) (TDR version) with no threshold subtraction
       // Analog readout with dual slope with the "second" slope being 1/2^(n-1) and threshold subtraction (n = 1, 2, 3,4)
       thePhase2ReadoutMode_(conf_specific.getParameter<int>("Phase2ReadoutMode")),
 
       // ADC calibration 1adc count(135e.
       // Corresponds to 2adc/kev, 270[e/kev]/135[e/adc](2[adc/kev]
       // Be careful, this parameter is also used in SiPixelDet.cc to
       // calculate the noise in adc counts from noise in electrons.
       // Both defaults should be the same.
       theElectronPerADC_(conf_specific.getParameter<double>("ElectronPerAdc")),
 
       // ADC saturation value, 255(8bit adc.
       theAdcFullScale_(conf_specific.getParameter<int>("AdcFullScale")),
 
       // Noise in electrons:
       // Pixel cell noise, relevant for generating noisy pixels
       theNoiseInElectrons_(conf_specific.getParameter<double>("NoiseInElectrons")),
 
       // Fill readout noise, including all readout chain, relevant for smearing
       theReadoutNoise_(conf_specific.getParameter<double>("ReadoutNoiseInElec")),
 
       // Threshold in units of noise:
       // thePixelThreshold(conf.getParameter<double>("ThresholdInNoiseUnits")),
       // Pixel threshold in electron units.
       theThresholdInE_Endcap_(conf_specific.getParameter<double>("ThresholdInElectrons_Endcap")),
       theThresholdInE_Barrel_(conf_specific.getParameter<double>("ThresholdInElectrons_Barrel")),
 
       // Add threshold gaussian smearing:
       theThresholdSmearing_Endcap_(conf_specific.getParameter<double>("ThresholdSmearing_Endcap")),
       theThresholdSmearing_Barrel_(conf_specific.getParameter<double>("ThresholdSmearing_Barrel")),
 
       // Add HIP Threshold in electron units.
       theHIPThresholdInE_Endcap_(conf_specific.getParameter<double>("HIPThresholdInElectrons_Endcap")),
       theHIPThresholdInE_Barrel_(conf_specific.getParameter<double>("HIPThresholdInElectrons_Barrel")),
 
       // theTofCut 12.5, cut in particle TOD +/- 12.5ns
       theTofLowerCut_(conf_specific.getParameter<double>("TofLowerCut")),
       theTofUpperCut_(conf_specific.getParameter<double>("TofUpperCut")),
 
       // Get the Lorentz angle from the cfg file:
       tanLorentzAnglePerTesla_Endcap_(
           use_LorentzAngle_DB_ ? 0.0 : conf_specific.getParameter<double>("TanLorentzAnglePerTesla_Endcap")),
       tanLorentzAnglePerTesla_Barrel_(
           use_LorentzAngle_DB_ ? 0.0 : conf_specific.getParameter<double>("TanLorentzAnglePerTesla_Barrel")),
 
       // Add noise
       addNoise_(conf_specific.getParameter<bool>("AddNoise")),
 
       // Add noisy pixels
       addNoisyPixels_(conf_specific.getParameter<bool>("AddNoisyPixels")),
 
       // Fluctuate charge in track subsegments
       fluctuateCharge_(conf_specific.getUntrackedParameter<bool>("FluctuateCharge", true)),
 
       // Control the pixel inefficiency
       addPixelInefficiency_(conf_specific.getParameter<bool>("AddInefficiency")),
 
       // Add threshold gaussian smearing:
       addThresholdSmearing_(conf_specific.getParameter<bool>("AddThresholdSmearing")),
 
       // Add some pseudo-red damage
       pseudoRadDamage_(conf_specific.exists("PseudoRadDamage") ? conf_specific.getParameter<double>("PseudoRadDamage")
                                                                : double(0.0)),
       pseudoRadDamageRadius_(conf_specific.exists("PseudoRadDamageRadius")
                                  ? conf_specific.getParameter<double>("PseudoRadDamageRadius")
                                  : double(0.0)),
       // Add pixel radiation damage
       useChargeReweighting_(conf_specific.getParameter<bool>("UseReweighting")),
       theSiPixelChargeReweightingAlgorithm_(
           useChargeReweighting_ ? std::make_unique<SiPixelChargeReweightingAlgorithm>(conf_specific, iC) : nullptr),
 
       // delta cutoff in MeV, has to be same as in OSCAR(0.030/cmsim=1.0 MeV
       // tMax(0.030), // In MeV.
       // tMax(conf.getUntrackedParameter<double>("DeltaProductionCut",0.030)),
       tMax_(conf_common.getParameter<double>("DeltaProductionCut")),
 
       badPixels_(conf_specific.getParameter<Parameters>("CellsToKill")),
 
       fluctuate_(fluctuateCharge_ ? std::make_unique<SiG4UniversalFluctuation>() : nullptr),
       theNoiser_(addNoise_ ? std::make_unique<GaussianTailNoiseGenerator>() : nullptr),
       theSiPixelGainCalibrationService_(
           use_ineff_from_db_ ? std::make_unique<SiPixelGainCalibrationOfflineSimService>(conf_specific, iC) : nullptr),
       subdetEfficiencies_(conf_specific) {
   LogDebug("Phase2TrackerDigitizerAlgorithm")
       << "Phase2TrackerDigitizerAlgorithm constructed\n"
       << "Configuration parameters:\n"
       << "Threshold/Gain = "
       << "threshold in electron Endcap = " << theThresholdInE_Endcap_
       << "\nthreshold in electron Barrel = " << theThresholdInE_Barrel_ << " ElectronPerADC " << theElectronPerADC_
       << " ADC Scale (in bits) " << theAdcFullScale_ << " The delta cut-off is set to " << tMax_ << " pix-inefficiency "
       << addPixelInefficiency_;
 }

◆ ~Phase2TrackerDigitizerAlgorithm()

Phase2TrackerDigitizerAlgorithm::~Phase2TrackerDigitizerAlgorithm ( )

virtual

Definition at line 164 of file Phase2TrackerDigitizerAlgorithm.cc.

References LogDebug.

                                                                   {
   LogDebug("Phase2TrackerDigitizerAlgorithm") << "Phase2TrackerDigitizerAlgorithm deleted";
 }

Member Function Documentation

◆ accumulateSimHits()

void Phase2TrackerDigitizerAlgorithm::accumulateSimHits	(	const std::vector< PSimHit >::const_iterator	inputBegin,
		const std::vector< PSimHit >::const_iterator	inputEnd,
		const size_t	inputBeginGlobalIndex,
		const uint32_t	tofBin,
		const Phase2TrackerGeomDetUnit *	pixdet,
		const GlobalVector &	bfield
	)

virtual

Definition at line 173 of file Phase2TrackerDigitizerAlgorithm.cc.

References c_inv, hcalRecHitTable_cff::detId, drift(), GeomDet::geographicalId(), induce_signal(), LogDebug, mag(), primary_ionization(), DetId::rawId(), select_hit(), GeomDet::surface(), and Surface::toGlobal().

                                                                                     {
   // produce SignalPoint's for all SimHit's in detector
   // Loop over hits
   uint32_t detId = pixdet->geographicalId().rawId();
   size_t simHitGlobalIndex = inputBeginGlobalIndex;  // This needs to be stored to create the digi-sim link later
 
   // find the relevant hits
   std::vector<PSimHit> matchedSimHits;
   std::copy_if(inputBegin, inputEnd, std::back_inserter(matchedSimHits), [detId](auto const& hit) -> bool {
     return hit.detUnitId() == detId;
   });
   // loop over a much reduced set of SimHits
   for (auto const& hit : matchedSimHits) {
     LogDebug("Phase2DigitizerAlgorithm") << hit.particleType() << " " << hit.pabs() << " " << hit.energyLoss() << " "
                                          << hit.tof() << " " << hit.trackId() << " " << hit.processType() << " "
                                          << hit.detUnitId() << hit.entryPoint() << " " << hit.exitPoint();
     double signalScale = 1.0;
     // fill collection_points for this SimHit, indpendent of topology
     if (select_hit(hit, (pixdet->surface().toGlobal(hit.localPosition()).mag() * c_inv), signalScale)) {
       const auto& ionization_points = primary_ionization(hit);  // fills ionization_points
 
       // transforms ionization_points -> collection_points
       const auto& collection_points = drift(hit, pixdet, bfield, ionization_points);
 
       // compute induced signal on readout elements and add to _signal
       // hit needed only for SimHit<-->Digi link
       induce_signal(inputBegin, hit, simHitGlobalIndex, inputBeginGlobalIndex, tofBin, pixdet, collection_points);
       LogDebug("Phase2DigitizerAlgorithm") << "Induced signal was computed";
     }
     ++simHitGlobalIndex;
   }
 }

◆ add_cross_talk()

void Phase2TrackerDigitizerAlgorithm::add_cross_talk ( const Phase2TrackerGeomDetUnit * pixdet )

protectedvirtual

Reimplemented in PixelDigitizerAlgorithm.

Definition at line 637 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, officialStyle::chan, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), GeomDet::geographicalId(), interstripCoupling_, MainPageGenerator::l, PixelTopology::nrows(), pixelFlag_, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), alignCSCRings::s, and PixelGeomDetUnit::specificTopology().

Referenced by digitize().

                                                                                            {
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
   signal_map_type signalNew;
   const Phase2TrackerTopology* topol = &pixdet->specificTopology();
   int numRows = topol->nrows();
 
   for (auto& s : theSignal) {
     float signalInElectrons = s.second.ampl();  // signal in electrons
 
     std::pair<int, int> hitChan;
     if (pixelFlag_)
       hitChan = PixelDigi::channelToPixel(s.first);
     else
       hitChan = Phase2TrackerDigi::channelToPixel(s.first);
 
     float signalInElectrons_Xtalk = signalInElectrons * interstripCoupling_;
     // subtract the charge which will be shared
     s.second.set(signalInElectrons - signalInElectrons_Xtalk);
 
     if (hitChan.first != 0) {
       auto XtalkPrev = std::make_pair(hitChan.first - 1, hitChan.second);
       int chanXtalkPrev = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second)
                                      : Phase2TrackerDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second);
       signalNew.emplace(chanXtalkPrev, digitizerUtility::Ph2Amplitude(signalInElectrons_Xtalk, nullptr, -1.0));
     }
     if (hitChan.first < numRows - 1) {
       auto XtalkNext = std::make_pair(hitChan.first + 1, hitChan.second);
       int chanXtalkNext = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkNext.first, XtalkNext.second)
                                      : Phase2TrackerDigi::pixelToChannel(XtalkNext.first, XtalkNext.second);
       signalNew.emplace(chanXtalkNext, digitizerUtility::Ph2Amplitude(signalInElectrons_Xtalk, nullptr, -1.0));
     }
   }
   for (auto const& l : signalNew) {
     int chan = l.first;
     auto iter = theSignal.find(chan);
     if (iter != theSignal.end()) {
       theSignal[chan] += l.second.ampl();
     } else {
       theSignal.emplace(chan, digitizerUtility::Ph2Amplitude(l.second.ampl(), nullptr, -1.0));
     }
   }
 }

◆ add_noise()

void Phase2TrackerDigitizerAlgorithm::add_noise ( const Phase2TrackerGeomDetUnit * pixdet )

protectedvirtual

Definition at line 620 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, gaussDistribution_, GeomDet::geographicalId(), hgchebackDigitizer_cfi::noise, DetId::rawId(), and alignCSCRings::s.

Referenced by digitize().

                                                                                       {
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
   for (auto& s : theSignal) {
     float noise = gaussDistribution_->fire();
     if ((s.second.ampl() + noise) < 0.)
       s.second.set(0);
     else
       s.second += noise;
   }
 }

◆ add_noisy_cells()

void Phase2TrackerDigitizerAlgorithm::add_noisy_cells	(	const Phase2TrackerGeomDetUnit *	pixdet,
		float	thePixelThreshold
	)

protectedvirtual

Definition at line 686 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, officialStyle::chan, GeomDet::geographicalId(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::ix(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy(), LogDebug, PixelTopology::ncolumns(), PixelTopology::nrows(), pixelFlag_, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), rengine_, PixelGeomDetUnit::specificTopology(), theNoiseInElectrons_, theNoiser_, theThresholdInE_Barrel_, and theThresholdInE_Endcap_.

Referenced by digitize().

                                                                                                                      {
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
   const Phase2TrackerTopology* topol = &pixdet->specificTopology();
 
   int numColumns = topol->ncolumns();  // det module number of cols&rows
   int numRows = topol->nrows();
 
   int numberOfPixels = numRows * numColumns;
   std::map<int, float, std::less<int> > otherPixels;
 
   theNoiser_->generate(numberOfPixels,
                        thePixelThreshold,     //thr. in un. of nois
                        theNoiseInElectrons_,  // noise in elec.
                        otherPixels,
                        rengine_);
 
   LogDebug("Phase2TrackerDigitizerAlgorithm")
       << " Add noisy pixels " << numRows << " " << numColumns << " " << theNoiseInElectrons_ << " "
       << theThresholdInE_Endcap_ << "  " << theThresholdInE_Barrel_ << " " << numberOfPixels << " "
       << otherPixels.size();
 
   // Add noisy pixels
   for (auto const& el : otherPixels) {
     int iy = el.first / numRows;
     if (iy < 0 || iy > numColumns - 1)
       LogWarning("Phase2TrackerDigitizerAlgorithm") << " error in iy " << iy;
 
     int ix = el.first - iy * numRows;
     if (ix < 0 || ix > numRows - 1)
       LogWarning("Phase2TrackerDigitizerAlgorithm") << " error in ix " << ix;
 
     int chan = pixelFlag_ ? PixelDigi::pixelToChannel(ix, iy) : Phase2TrackerDigi::pixelToChannel(ix, iy);
 
     LogDebug("Phase2TrackerDigitizerAlgorithm")
         << " Storing noise = " << el.first << " " << el.second << " " << ix << " " << iy << " " << chan;
 
     if (theSignal[chan] == 0)
       theSignal[chan] = digitizerUtility::Ph2Amplitude(el.second, nullptr, -1.);
   }
 }

◆ calcQ()

float Phase2TrackerDigitizerAlgorithm::calcQ ( float x )

protected

Definition at line 1021 of file Phase2TrackerDigitizerAlgorithm.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), f, SiStripPI::min, LaserDQM_cfg::p1, SiStripOfflineCRack_cfg::p2, chargedHadronTrackResolutionFilter_cfi::p3, mathSSE::sqrt(), x, and geometryCSVtoXML::xx.

Referenced by induce_signal().

                                                     {
   constexpr float p1 = 12.5f;
   constexpr float p2 = 0.2733f;
   constexpr float p3 = 0.147f;
 
   auto xx = std::min(0.5f * x * x, p1);
   return 0.5f * (1.f - std::copysign(std::sqrt(1.f - unsafe_expf<4>(-xx * (1.f + p2 / (1.f + p3 * xx)))), x));
 }

◆ convertSignalToAdc()

int Phase2TrackerDigitizerAlgorithm::convertSignalToAdc	(	uint32_t	detID,
		float	signal_in_elec,
		float	threshold
	)

protected

Definition at line 992 of file Phase2TrackerDigitizerAlgorithm.cc.

References funct::abs(), LogTrace, SiStripPI::min, funct::pow(), theAdcFullScale_, theElectronPerADC_, thePhase2ReadoutMode_, and DiMuonV_cfg::threshold.

Referenced by digitize().

                                                                                                              {
   int signal_in_adc;
   int temp_signal;
   const int max_limit = 10;
   if (thePhase2ReadoutMode_ == 0) {
     signal_in_adc = theAdcFullScale_;
   } else {
     if (thePhase2ReadoutMode_ == -1) {
       temp_signal = std::min(static_cast<int>(std::round(signal_in_elec / theElectronPerADC_)), theAdcFullScale_);
     } else {
       // calculate the kink point and the slope
       int dualslope_param = std::min(std::abs(thePhase2ReadoutMode_), max_limit);
       int kink_point = static_cast<int>(theAdcFullScale_ / 2) + 1;
       // C-ROC: first valid ToT code above threshold is 0b0000
       temp_signal = std::floor((signal_in_elec - threshold) / theElectronPerADC_);
       if (temp_signal > kink_point)
         temp_signal =
             static_cast<int>(std::floor((temp_signal - kink_point) / (pow(2, dualslope_param - 1)))) + kink_point;
     }
     signal_in_adc = std::min(temp_signal, theAdcFullScale_);
     LogTrace("Phase2TrackerDigitizerAlgorithm")
         << " DetId " << detID << " signal_in_elec " << signal_in_elec << " threshold " << threshold
         << " signal_above_thr " << signal_in_elec - threshold << " temp conversion "
         << std::floor((signal_in_elec - threshold) / theElectronPerADC_) + 1 << " signal after slope correction "
         << temp_signal << " signal_in_adc " << signal_in_adc;
   }
   return signal_in_adc;
 }

◆ digitize()

void Phase2TrackerDigitizerAlgorithm::digitize	(	const Phase2TrackerGeomDetUnit *	pixdet,
		std::map< int, digitizerUtility::DigiSimInfo > &	digi_map,
		const TrackerTopology *	tTopo
	)

virtual

Definition at line 913 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, add_cross_talk(), add_noise(), add_noisy_cells(), addNoise_, addNoisyPixels_, addPixelInefficiency_, addThresholdSmearing_, addXtalk_, digitizerUtility::Ph2Amplitude::ampl(), convertSignalToAdc(), GeomDet::geographicalId(), info(), isAboveThreshold(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, MainPageGenerator::l, makeDigiSimLinks_, module_killing_conf(), module_killing_DB(), pixel_inefficiency(), pixel_inefficiency_db(), PixelSubdetector::PixelBarrel, DetId::rawId(), alignCSCRings::s, edm::second(), digitizerUtility::Ph2Amplitude::simInfoList(), smearedThreshold_Barrel_, smearedThreshold_Endcap_, subdetEfficiencies_, DetId::subdetId(), theHIPThresholdInE_Barrel_, theHIPThresholdInE_Endcap_, theNoiseInElectrons_, theThresholdInE_Barrel_, theThresholdInE_Endcap_, StripSubdetector::TOB, funct::true, use_deadmodule_DB_, use_ineff_from_db_, and use_module_killing_.

                                                                              {
   uint32_t detID = pixdet->geographicalId().rawId();
   auto it = _signal.find(detID);
   if (it == _signal.end())
     return;
 
   const signal_map_type& theSignal = _signal[detID];
 
   uint32_t Sub_detid = DetId(detID).subdetId();
 
   float theThresholdInE = 0.;
   float theHIPThresholdInE = 0.;
   // Define Threshold
   if (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == StripSubdetector::TOB) {  // Barrel modules
     theThresholdInE = addThresholdSmearing_ ? smearedThreshold_Barrel_->fire()             // gaussian smearing
                                             : theThresholdInE_Barrel_;                     // no smearing
     theHIPThresholdInE = theHIPThresholdInE_Barrel_;
   } else {                                                                      // Forward disks modules
     theThresholdInE = addThresholdSmearing_ ? smearedThreshold_Endcap_->fire()  // gaussian smearing
                                             : theThresholdInE_Endcap_;          // no smearing
     theHIPThresholdInE = theHIPThresholdInE_Endcap_;
   }
 
   //  if (addNoise) add_noise(pixdet, theThresholdInE/theNoiseInElectrons_);  // generate noise
   if (addNoise_)
     add_noise(pixdet);  // generate noise
   if (addXtalk_)
     add_cross_talk(pixdet);
   if (addNoisyPixels_) {
     float thresholdInNoiseUnits = 99.9;
     if (theNoiseInElectrons_)
       thresholdInNoiseUnits = theThresholdInE / theNoiseInElectrons_;
     add_noisy_cells(pixdet, thresholdInNoiseUnits);
   }
 
   // Do only if needed
   if (addPixelInefficiency_ && !theSignal.empty()) {
     if (use_ineff_from_db_)
       pixel_inefficiency_db(detID);
     else
       pixel_inefficiency(subdetEfficiencies_, pixdet, tTopo);
   }
   if (use_module_killing_) {
     if (use_deadmodule_DB_)  // remove dead modules using DB
       module_killing_DB(pixdet);
     else  // remove dead modules using the list in cfg file
       module_killing_conf(detID);
   }
 
   // Digitize if the signal is greater than threshold
   for (auto const& s : theSignal) {
     const digitizerUtility::Ph2Amplitude& sig_data = s.second;
     float signalInElectrons = sig_data.ampl();
 
     const auto& info_list = sig_data.simInfoList();
     const digitizerUtility::SimHitInfo* hitInfo = nullptr;
     if (!info_list.empty())
       hitInfo = std::max_element(info_list.begin(), info_list.end())->second.get();
 
     if (isAboveThreshold(hitInfo, signalInElectrons, theThresholdInE)) {  // check threshold
       digitizerUtility::DigiSimInfo info;
       info.sig_tot = convertSignalToAdc(detID, signalInElectrons, theThresholdInE);  // adc
       info.ot_bit = signalInElectrons > theHIPThresholdInE ? true : false;
       if (makeDigiSimLinks_) {
         for (auto const& l : sig_data.simInfoList()) {
           float charge_frac = l.first / signalInElectrons;
           if (l.first > -5.0)
             info.simInfoList.push_back({charge_frac, l.second.get()});
         }
       }
       digi_map.insert({s.first, info});
     }
   }
 }

◆ drift()

std::vector< digitizerUtility::SignalPoint > Phase2TrackerDigitizerAlgorithm::drift	(	const PSimHit &	hit,
		const Phase2TrackerGeomDetUnit *	pixdet,
		const GlobalVector &	bfield,
		const std::vector< digitizerUtility::EnergyDepositUnit > &	ionization_points
	)		const

protectedvirtual

Reimplemented in Pixel3DDigitizerAlgorithm.

Definition at line 323 of file Phase2TrackerDigitizerAlgorithm.cc.

References alpha2Order_, Surface::bounds(), funct::cos(), driftDirection(), JetChargeProducer_cfi::exp, LogDebug, M_PI, PV3DBase< T, PVType, FrameType >::perp(), PixelTopology::pitch(), GloballyPositioned< T >::position(), funct::pow(), pseudoRadDamage_, pseudoRadDamageRadius_, Sigma0_, SigmaCoeff_, GeomDet::specificSurface(), PixelGeomDetUnit::specificTopology(), mathSSE::sqrt(), GeomDet::surface(), Bounds::thickness(), heppy_batch::val, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by accumulateSimHits().

                                                                                  {
   LogDebug("Phase2TrackerDigitizerAlgorithm") << "Enter drift ";
 
   std::vector<digitizerUtility::SignalPoint> collection_points;
   collection_points.reserve(ionization_points.size());                     // set size
   LocalVector driftDir = driftDirection(pixdet, bfield, hit.detUnitId());  // get the charge drift direction
   if (driftDir.z() == 0.) {
     LogWarning("Phase2TrackerDigitizerAlgorithm") << " pxlx: drift in z is zero ";
     return collection_points;
   }
 
   float TanLorenzAngleX = driftDir.x();                                       // tangent of Lorentz angle
   float TanLorenzAngleY = 0.;                                                 // force to 0, driftDir.y()/driftDir.z();
   float dir_z = driftDir.z();                                                 // The z drift direction
   float CosLorenzAngleX = 1. / std::sqrt(1. + std::pow(TanLorenzAngleX, 2));  // cosine to estimate the path length
   float CosLorenzAngleY = 1.;
   if (alpha2Order_) {
     TanLorenzAngleY = driftDir.y();
     CosLorenzAngleY = 1. / std::sqrt(1. + std::pow(TanLorenzAngleY, 2));  // cosine
   }
 
   float moduleThickness = pixdet->specificSurface().bounds().thickness();
   float stripPitch = pixdet->specificTopology().pitch().first;
 
   LogDebug("Phase2TrackerDigitizerAlgorithm")
       << " Lorentz Tan-X " << TanLorenzAngleX << "  Lorentz Tan-Y " << TanLorenzAngleY << " Lorentz Cos-X "
       << CosLorenzAngleX << " Lorentz Cos-Y " << CosLorenzAngleY
       << " ticknes * Lorentz Tan-X = " << moduleThickness * TanLorenzAngleX << " drift direction " << driftDir;
 
   for (auto const& val : ionization_points) {
     // position
     float SegX = val.x(), SegY = val.y(), SegZ = val.z();
 
     // Distance from the collection plane
     // DriftDistance = (moduleThickness/2. + SegZ); // Drift to -z
     // Include explixitely the E drift direction (for CMS dir_z=-1)
 
     // Distance between charge generation and collection
     float driftDistance = moduleThickness / 2. - (dir_z * SegZ);  // Drift to -z
 
     if (driftDistance < 0.)
       driftDistance = 0.;
     else if (driftDistance > moduleThickness)
       driftDistance = moduleThickness;
 
     // Assume full depletion now, partial depletion will come later.
     float XDriftDueToMagField = driftDistance * TanLorenzAngleX;
     float YDriftDueToMagField = driftDistance * TanLorenzAngleY;
 
     // Shift cloud center
     float CloudCenterX = SegX + XDriftDueToMagField;
     float CloudCenterY = SegY + YDriftDueToMagField;
 
     // Calculate how long is the charge drift path
     // Actual Drift Lentgh
     float driftLength =
         std::sqrt(std::pow(driftDistance, 2) + std::pow(XDriftDueToMagField, 2) + std::pow(YDriftDueToMagField, 2));
 
     // What is the charge diffusion after this path
     // Sigma0=0.00037 is for 300um thickness (make sure moduleThickness is in [cm])
     float Sigma = std::sqrt(driftLength / moduleThickness) * Sigma0_ * moduleThickness / 0.0300;
     // D.B.: sigmaCoeff=0 means no modulation
     if (SigmaCoeff_)
       Sigma *= (SigmaCoeff_ * std::pow(cos(SegX * M_PI / stripPitch), 2) + 1);
     // NB: divided by 4 to get a periodicity of stripPitch
 
     // Project the diffusion sigma on the collection plane
     float Sigma_x = Sigma / CosLorenzAngleX;
     float Sigma_y = Sigma / CosLorenzAngleY;
 
     // Insert a charge loss due to Rad Damage here
     float energyOnCollector = val.energy();  // The energy that reaches the collector
 
     // pseudoRadDamage
     if (pseudoRadDamage_) {
       float moduleRadius = pixdet->surface().position().perp();
       if (moduleRadius <= pseudoRadDamageRadius_) {
         float kValue = pseudoRadDamage_ / std::pow(moduleRadius, 2);
         energyOnCollector *= exp(-1 * kValue * driftDistance / moduleThickness);
       }
     }
     LogDebug("Phase2TrackerDigitizerAlgorithm")
         << "Dift DistanceZ = " << driftDistance << " module thickness = " << moduleThickness
         << " Start Energy = " << val.energy() << " Energy after loss= " << energyOnCollector;
     digitizerUtility::SignalPoint sp(CloudCenterX, CloudCenterY, Sigma_x, Sigma_y, hit.tof(), energyOnCollector);
 
     // Load the Charge distribution parameters
     collection_points.push_back(sp);
   }
   return collection_points;
 }

◆ driftDirection()

LocalVector Phase2TrackerDigitizerAlgorithm::driftDirection	(	const Phase2TrackerGeomDetUnit *	pixdet,
		const GlobalVector &	bfield,
		const DetId &	detId
	)		const

protected

Definition at line 788 of file Phase2TrackerDigitizerAlgorithm.cc.

References alpha2Order_, mkfit::Config::Bfield, hcalRecHitTable_cff::detId, GeomDet::geographicalId(), SiPixelLorentzAngle::getLorentzAngle(), SiPhase2OuterTrackerLorentzAngle::getLorentzAngle(), fastTrackerRecHitType::isPixel(), LogDebug, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, GloballyPositioned< T >::position(), funct::pow(), DetId::rawId(), GloballyPositioned< T >::rotation(), isotrackNtupler::scale, siPhase2OTLorentzAngle_, siPixelLorentzAngle_, DetId::subdetId(), GeomDet::surface(), tanLorentzAnglePerTesla_Barrel_, tanLorentzAnglePerTesla_Endcap_, StripSubdetector::TOB, and use_LorentzAngle_DB_.

Referenced by drift().

                                                                                       {
   Frame detFrame(pixdet->surface().position(), pixdet->surface().rotation());
   LocalVector Bfield = detFrame.toLocal(bfield);
 
   float dir_x = 0.0;
   float dir_y = 0.0;
   float dir_z = 0.0;
   float scale = 1.0;
 
   uint32_t detID = pixdet->geographicalId().rawId();
   uint32_t Sub_detid = DetId(detID).subdetId();
 
   // Read Lorentz angle from DB:
   if (use_LorentzAngle_DB_) {
     bool isPixel = (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == PixelSubdetector::PixelEndcap);
     if (isPixel) {
       LogDebug("Phase2TrackerDigitizerAlgorithm") << "Read Lorentz angle from DB for Phase-2 IT";
     } else {
       LogDebug("Phase2TrackerDigitizerAlgorithm") << "Read Lorentz angle from DB for Phase-2 OT";
     }
 
     float lorentzAngle =
         isPixel ? siPixelLorentzAngle_->getLorentzAngle(detId) : siPhase2OTLorentzAngle_->getLorentzAngle(detId);
     float alpha2 = std::pow(lorentzAngle, 2);
 
     dir_x = -(lorentzAngle * Bfield.y() + alpha2 * Bfield.z() * Bfield.x());
     dir_y = +(lorentzAngle * Bfield.x() - alpha2 * Bfield.z() * Bfield.y());
     dir_z = -(1 + alpha2 * std::pow(Bfield.z(), 2));
     scale = (1 + alpha2 * std::pow(Bfield.z(), 2));
   } else {
     // Read Lorentz angle from cfg file:
     LogDebug("Phase2TrackerDigitizerAlgorithm") << "Read Lorentz angle from cfg file";
     float alpha2_Endcap = 0.0;
     float alpha2_Barrel = 0.0;
     if (alpha2Order_) {
       alpha2_Endcap = std::pow(tanLorentzAnglePerTesla_Endcap_, 2);
       alpha2_Barrel = std::pow(tanLorentzAnglePerTesla_Barrel_, 2);
     }
 
     if (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == StripSubdetector::TOB) {  // barrel layers
       dir_x = -(tanLorentzAnglePerTesla_Barrel_ * Bfield.y() + alpha2_Barrel * Bfield.z() * Bfield.x());
       dir_y = +(tanLorentzAnglePerTesla_Barrel_ * Bfield.x() - alpha2_Barrel * Bfield.z() * Bfield.y());
       dir_z = -(1 + alpha2_Barrel * std::pow(Bfield.z(), 2));
       scale = (1 + alpha2_Barrel * std::pow(Bfield.z(), 2));
 
     } else {  // forward disks
       dir_x = -(tanLorentzAnglePerTesla_Endcap_ * Bfield.y() + alpha2_Endcap * Bfield.z() * Bfield.x());
       dir_y = +(tanLorentzAnglePerTesla_Endcap_ * Bfield.x() - alpha2_Endcap * Bfield.z() * Bfield.y());
       dir_z = -(1 + alpha2_Endcap * std::pow(Bfield.z(), 2));
       scale = (1 + alpha2_Endcap * std::pow(Bfield.z(), 2));
     }
   }
 
   LocalVector theDriftDirection = LocalVector(dir_x / scale, dir_y / scale, dir_z / scale);
   LogDebug("Phase2TrackerDigitizerAlgorithm") << " The drift direction in local coordinate is " << theDriftDirection;
   return theDriftDirection;
 }

◆ fluctuateEloss()

std::vector< float > Phase2TrackerDigitizerAlgorithm::fluctuateEloss	(	int	particleId,
		float	momentum,
		float	eloss,
		float	length,
		int	NumberOfSegments
	)		const

protectedvirtual

Definition at line 266 of file Phase2TrackerDigitizerAlgorithm.cc.

References funct::abs(), DummyCfis::c, fluctuate_, mps_fire::i, ph2tkdigialgo::m_electron, ph2tkdigialgo::m_kaon, ph2tkdigialgo::m_muon, ph2tkdigialgo::m_pion, ph2tkdigialgo::m_proton, rengine_, tMax_, and HcalDetIdTransform::transform().

Referenced by primary_ionization().

                                                                                         {
   double particleMass = ph2tkdigialgo::m_pion;  // Mass in MeV, assume pion
   pid = std::abs(pid);
   if (pid != 211) {  // Mass in MeV
     if (pid == 11)
       particleMass = ph2tkdigialgo::m_electron;
     else if (pid == 13)
       particleMass = ph2tkdigialgo::m_muon;
     else if (pid == 321)
       particleMass = ph2tkdigialgo::m_kaon;
     else if (pid == 2212)
       particleMass = ph2tkdigialgo::m_proton;
   }
   // What is the track segment length.
   float segmentLength = length / NumberOfSegs;
 
   // Generate charge fluctuations.
   float sum = 0.;
   double segmentEloss = (1000. * eloss) / NumberOfSegs;  //eloss in MeV
   std::vector<float> elossVector;
   elossVector.reserve(NumberOfSegs);
   for (int i = 0; i < NumberOfSegs; ++i) {
     // The G4 routine needs momentum in MeV, mass in Mev, delta-cut in MeV,
     // track segment length in mm, segment eloss in MeV
     // Returns fluctuated eloss in MeV
     double deltaCutoff = tMax_;  // the cutoff is sometimes redefined inside, so fix it.
     float de = fluctuate_->SampleFluctuations(particleMomentum * 1000.,
                                               particleMass,
                                               deltaCutoff,
                                               segmentLength * 10.,
                                               segmentEloss,
                                               rengine_) /
                1000.;  //convert to GeV
     elossVector.push_back(de);
     sum += de;
   }
   if (sum > 0.) {  // if fluctuations give eloss>0.
     // Rescale to the same total eloss
     float ratio = eloss / sum;
     std::transform(
         std::begin(elossVector), std::end(elossVector), std::begin(elossVector), [&ratio](auto const& c) -> float {
           return c * ratio;
         });  // use a simple lambda expression
   } else {   // if fluctuations gives 0 eloss
     float averageEloss = eloss / NumberOfSegs;
     elossVector.resize(NumberOfSegs, averageEloss);
   }
   return elossVector;
 }

◆ induce_signal()

void Phase2TrackerDigitizerAlgorithm::induce_signal	(	std::vector< PSimHit >::const_iterator	inputBegin,
		const PSimHit &	hit,
		const size_t	hitIndex,
		const size_t	firstHitIndex,
		const uint32_t	tofBin,
		const Phase2TrackerGeomDetUnit *	pixdet,
		const std::vector< digitizerUtility::SignalPoint > &	collection_points
	)

protectedvirtual

Reimplemented in Pixel3DDigitizerAlgorithm.

Definition at line 422 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, c_inv, calcQ(), officialStyle::chan, Topology::channel(), PixelTestBeamValidation_cfi::Charge, clusterWidth_, GeomDet::geographicalId(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::ix(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy(), Topology::localPosition(), LogDebug, mag(), makeDigiSimLinks_, Topology::measurementPosition(), PixelTopology::ncolumns(), PixelTopology::nrows(), PixelTopology::pitch(), pixelFlag_, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), VtxSmearedHGCALCloseBy_cfi::SigmaX, VtxSmearedHGCALCloseBy_cfi::SigmaY, PixelGeomDetUnit::specificTopology(), GeomDet::surface(), theSiPixelChargeReweightingAlgorithm_, Surface::toGlobal(), useChargeReweighting_, findQualityFiles::v, x, PV2DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::x(), y, PV2DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by accumulateSimHits().

                                                                      {
   // X  - Rows, Left-Right, 160, (1.6cm)   for barrel
   // Y  - Columns, Down-Up, 416, (6.4cm)
   const Phase2TrackerTopology* topol = &pixdet->specificTopology();
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
 
   LogDebug("Phase2TrackerDigitizerAlgorithm")
       << "Enter induce_signal, Pitch size is " << topol->pitch().first << " cm vs " << topol->pitch().second << " cm";
 
   // local map to store pixels hit by 1 Hit.
   using hit_map_type = std::map<int, float, std::less<int> >;
   hit_map_type hit_signal;
 
   // Assign signals to readout channels and store sorted by channel number
   // Iterate over collection points on the collection plane
   for (auto const& v : collection_points) {
     float CloudCenterX = v.position().x();  // Charge position in x
     float CloudCenterY = v.position().y();  //                 in y
     float SigmaX = v.sigma_x();             // Charge spread in x
     float SigmaY = v.sigma_y();             //               in y
     float Charge = v.amplitude();           // Charge amplitude
 
     LogDebug("Phase2TrackerDigitizerAlgorithm") << " cloud " << v.position().x() << " " << v.position().y() << " "
                                                 << v.sigma_x() << " " << v.sigma_y() << " " << v.amplitude();
 
     // Find the maximum cloud spread in 2D plane , assume 3*sigma
     float CloudRight = CloudCenterX + clusterWidth_ * SigmaX;
     float CloudLeft = CloudCenterX - clusterWidth_ * SigmaX;
     float CloudUp = CloudCenterY + clusterWidth_ * SigmaY;
     float CloudDown = CloudCenterY - clusterWidth_ * SigmaY;
 
     // Define 2D cloud limit points
     LocalPoint PointRightUp = LocalPoint(CloudRight, CloudUp);
     LocalPoint PointLeftDown = LocalPoint(CloudLeft, CloudDown);
 
     // This points can be located outside the sensor area.
     // The conversion to measurement point does not check for that
     // so the returned pixel index might be wrong (outside range).
     // We rely on the limits check below to fix this.
     // But remember whatever we do here THE CHARGE OUTSIDE THE ACTIVE
     // PIXEL ARE IS LOST, it should not be collected.
 
     // Convert the 2D points to pixel indices
     MeasurementPoint mp = topol->measurementPosition(PointRightUp);
     int IPixRightUpX = static_cast<int>(std::floor(mp.x()));  // cast reqd.
     int IPixRightUpY = static_cast<int>(std::floor(mp.y()));
     LogDebug("Phase2TrackerDigitizerAlgorithm")
         << " right-up " << PointRightUp << " " << mp.x() << " " << mp.y() << " " << IPixRightUpX << " " << IPixRightUpY;
 
     mp = topol->measurementPosition(PointLeftDown);
     int IPixLeftDownX = static_cast<int>(std::floor(mp.x()));
     int IPixLeftDownY = static_cast<int>(std::floor(mp.y()));
     LogDebug("Phase2TrackerDigitizerAlgorithm") << " left-down " << PointLeftDown << " " << mp.x() << " " << mp.y()
                                                 << " " << IPixLeftDownX << " " << IPixLeftDownY;
 
     // Check detector limits to correct for pixels outside range.
     int numColumns = topol->ncolumns();  // det module number of cols&rows
     int numRows = topol->nrows();
 
     IPixRightUpX = numRows > IPixRightUpX ? IPixRightUpX : numRows - 1;
     IPixRightUpY = numColumns > IPixRightUpY ? IPixRightUpY : numColumns - 1;
     IPixLeftDownX = 0 < IPixLeftDownX ? IPixLeftDownX : 0;
     IPixLeftDownY = 0 < IPixLeftDownY ? IPixLeftDownY : 0;
 
     // First integrate charge strips in x
     hit_map_type x;
     for (int ix = IPixLeftDownX; ix <= IPixRightUpX; ++ix) {  // loop over x index
       float xLB, LowerBound;
       // Why is set to 0 if ix=0, does it meen that we accept charge
       // outside the sensor?
       if (ix == 0 || SigmaX == 0.) {  // skip for surface segemnts
         LowerBound = 0.;
       } else {
         mp = MeasurementPoint(ix, 0.0);
         xLB = topol->localPosition(mp).x();
         LowerBound = 1 - calcQ((xLB - CloudCenterX) / SigmaX);
       }
 
       float xUB, UpperBound;
       if (ix == numRows - 1 || SigmaX == 0.) {
         UpperBound = 1.;
       } else {
         mp = MeasurementPoint(ix + 1, 0.0);
         xUB = topol->localPosition(mp).x();
         UpperBound = 1. - calcQ((xUB - CloudCenterX) / SigmaX);
       }
       float TotalIntegrationRange = UpperBound - LowerBound;  // get strip
       x.emplace(ix, TotalIntegrationRange);                   // save strip integral
     }
 
     // Now integrate strips in y
     hit_map_type y;
     for (int iy = IPixLeftDownY; iy <= IPixRightUpY; ++iy) {  // loop over y index
       float yLB, LowerBound;
       if (iy == 0 || SigmaY == 0.) {
         LowerBound = 0.;
       } else {
         mp = MeasurementPoint(0.0, iy);
         yLB = topol->localPosition(mp).y();
         LowerBound = 1. - calcQ((yLB - CloudCenterY) / SigmaY);
       }
 
       float yUB, UpperBound;
       if (iy == numColumns - 1 || SigmaY == 0.) {
         UpperBound = 1.;
       } else {
         mp = MeasurementPoint(0.0, iy + 1);
         yUB = topol->localPosition(mp).y();
         UpperBound = 1. - calcQ((yUB - CloudCenterY) / SigmaY);
       }
 
       float TotalIntegrationRange = UpperBound - LowerBound;
       y.emplace(iy, TotalIntegrationRange);  // save strip integral
     }
 
     // Get the 2D charge integrals by folding x and y strips
     for (int ix = IPixLeftDownX; ix <= IPixRightUpX; ++ix) {    // loop over x index
       for (int iy = IPixLeftDownY; iy <= IPixRightUpY; ++iy) {  // loop over y index
         float ChargeFraction = Charge * x[ix] * y[iy];
         int chanFired = -1;
         if (ChargeFraction > 0.) {
           chanFired =
               pixelFlag_ ? PixelDigi::pixelToChannel(ix, iy) : Phase2TrackerDigi::pixelToChannel(ix, iy);  // Get index
           // Load the amplitude
           hit_signal[chanFired] += ChargeFraction;
         }
 
         mp = MeasurementPoint(ix, iy);
         LocalPoint lp = topol->localPosition(mp);
         int chan = topol->channel(lp);
 
         LogDebug("Phase2TrackerDigitizerAlgorithm")
             << " pixel " << ix << " " << iy << " - "
             << " " << chanFired << " " << ChargeFraction << " " << mp.x() << " " << mp.y() << " " << lp.x() << " "
             << lp.y() << " "  // givex edge position
             << chan;          // edge belongs to previous ?
       }
     }
   }
   // Fill the global map with all hit pixels from this event
   bool reweighted = false;
   size_t referenceIndex4CR = 0;
 
   if (useChargeReweighting_) {
     if (hit.processType() == 0) {
       referenceIndex4CR = hitIndex;
       reweighted =
           theSiPixelChargeReweightingAlgorithm_->hitSignalReweight<digitizerUtility::Ph2Amplitude>(hit,
                                                                                                    hit_signal,
                                                                                                    hitIndex,
                                                                                                    referenceIndex4CR,
                                                                                                    tofBin,
                                                                                                    topol,
                                                                                                    detID,
                                                                                                    theSignal,
                                                                                                    hit.processType(),
                                                                                                    makeDigiSimLinks_);
     } else {
       // If it's not the primary particle, use the first hit in the collection as SimHit, which should be the corresponding primary.
       referenceIndex4CR = firstHitIndex;
       reweighted =
           theSiPixelChargeReweightingAlgorithm_->hitSignalReweight<digitizerUtility::Ph2Amplitude>((*inputBegin),
                                                                                                    hit_signal,
                                                                                                    hitIndex,
                                                                                                    referenceIndex4CR,
                                                                                                    tofBin,
                                                                                                    topol,
                                                                                                    detID,
                                                                                                    theSignal,
                                                                                                    hit.processType(),
                                                                                                    makeDigiSimLinks_);
     }
   }
 
   float corr_time = hit.tof() - pixdet->surface().toGlobal(hit.localPosition()).mag() * c_inv;
   if (!reweighted) {
     for (auto const& hit_s : hit_signal) {
       int chan = hit_s.first;
       theSignal[chan] += (makeDigiSimLinks_ ? digitizerUtility::Ph2Amplitude(
                                                   hit_s.second, &hit, hit_s.second, corr_time, hitIndex, tofBin)
                                             : digitizerUtility::Ph2Amplitude(hit_s.second, nullptr, hit_s.second));
     }
   }
 }  // end of induce_signal function

◆ init()

virtual void Phase2TrackerDigitizerAlgorithm::init ( const edm::EventSetup & es )

pure virtual

Implemented in PixelDigitizerAlgorithm, PSSDigitizerAlgorithm, SSDigitizerAlgorithm, and PSPDigitizerAlgorithm.

◆ initializeEvent()

void Phase2TrackerDigitizerAlgorithm::initializeEvent ( CLHEP::HepRandomEngine & eng )

virtual

Definition at line 765 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, addNoise_, addPixelInefficiency_, addThresholdSmearing_, fluctuateCharge_, gaussDistribution_, rengine_, smearedThreshold_Barrel_, smearedThreshold_Endcap_, theNoiseInElectrons_, theThresholdInE_Barrel_, theThresholdInE_Endcap_, theThresholdSmearing_Barrel_, and theThresholdSmearing_Endcap_.

                                                                                {
   if (addNoise_ || addPixelInefficiency_ || fluctuateCharge_ || addThresholdSmearing_) {
     gaussDistribution_ = std::make_unique<CLHEP::RandGaussQ>(eng, 0., theNoiseInElectrons_);
   }
   // Threshold smearing with gaussian distribution:
   if (addThresholdSmearing_) {
     smearedThreshold_Endcap_ =
         std::make_unique<CLHEP::RandGaussQ>(eng, theThresholdInE_Endcap_, theThresholdSmearing_Endcap_);
     smearedThreshold_Barrel_ =
         std::make_unique<CLHEP::RandGaussQ>(eng, theThresholdInE_Barrel_, theThresholdSmearing_Barrel_);
   }
   rengine_ = &eng;
   _signal.clear();
 }

◆ isAboveThreshold()

virtual bool Phase2TrackerDigitizerAlgorithm::isAboveThreshold	(	const digitizerUtility::SimHitInfo *	hitInfo,
		float	charge,
		float	thr
	)		const

inlinevirtual

Reimplemented in PixelDigitizerAlgorithm, PSSDigitizerAlgorithm, SSDigitizerAlgorithm, and PSPDigitizerAlgorithm.

Definition at line 77 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

                                                                                                           {
     return true;
   }

◆ loadAccumulator()

void Phase2TrackerDigitizerAlgorithm::loadAccumulator	(	uint32_t	detId,
		const std::map< int, float > &	accumulator
	)

Definition at line 901 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, mixOne_premix_on_sim_cfi::accumulator, hcalRecHitTable_cff::detId, and Exception.

                                                                                                            {
   auto& theSignal = _signal[detId];
   // the input channel is always with PixelDigi definition
   // if needed, that has to be converted to Phase2TrackerDigi convention
   for (const auto& elem : accumulator) {
     auto inserted = theSignal.emplace(elem.first, digitizerUtility::Ph2Amplitude(elem.second, nullptr));
     if (!inserted.second) {
       throw cms::Exception("LogicError") << "Signal was already set for DetId " << detId;
     }
   }
 }

◆ module_killing_conf()

void Phase2TrackerDigitizerAlgorithm::module_killing_conf ( uint32_t detID )

protectedvirtual

Definition at line 871 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), deadModules_, ALCARECOPPSCalTrackBasedSel_cff::detid, pixelFlag_, alignCSCRings::s, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by digitize().

                                                                         {
   bool isbad = false;
   int detid = detID;
   std::string Module;
   for (auto const& det_m : deadModules_) {
     int Dead_detID = det_m.getParameter<int>("Dead_detID");
     Module = det_m.getParameter<std::string>("Module");
     if (detid == Dead_detID) {
       isbad = true;
       break;
     }
   }
 
   if (!isbad)
     return;
 
   signal_map_type& theSignal = _signal[detID];  // check validity
   for (auto& s : theSignal) {
     std::pair<int, int> ip;
     if (pixelFlag_)
       ip = PixelDigi::channelToPixel(s.first);
     else
       ip = Phase2TrackerDigi::channelToPixel(s.first);  //get pixel pos
 
     if (Module == "whole" || (Module == "tbmA" && ip.first >= 80 && ip.first <= 159) ||
         (Module == "tbmB" && ip.first <= 79))
       s.second.set(0.);
   }
 }

◆ module_killing_DB()

virtual void Phase2TrackerDigitizerAlgorithm::module_killing_DB ( const Phase2TrackerGeomDetUnit * pixdet )

protectedpure virtual

Implemented in PixelDigitizerAlgorithm, SSDigitizerAlgorithm, PSPDigitizerAlgorithm, and PSSDigitizerAlgorithm.

Referenced by digitize().

◆ pixel_inefficiency()

void Phase2TrackerDigitizerAlgorithm::pixel_inefficiency	(	const SubdetEfficiencies &	eff,
		const Phase2TrackerGeomDetUnit *	pixdet,
		const TrackerTopology *	tTopo
	)

protectedvirtual

Definition at line 731 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, Phase2TrackerDigitizerAlgorithm::SubdetEfficiencies::barrel_efficiencies, Phase2TrackerDigitizerAlgorithm::SubdetEfficiencies::endcap_efficiencies, GeomDet::geographicalId(), LogDebug, PixelSubdetector::PixelBarrel, TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfSide(), DetId::rawId(), rengine_, alignCSCRings::s, DetId::subdetId(), and StripSubdetector::TOB.

Referenced by digitize().

                                                                                        {
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];  // check validity
 
   // Predefined efficiencies
   float subdetEfficiency = 1.0;
 
   // setup the chip indices conversion
   uint32_t Subid = DetId(detID).subdetId();
   if (Subid == PixelSubdetector::PixelBarrel || Subid == StripSubdetector::TOB) {  // barrel layers
     uint32_t layerIndex = tTopo->pxbLayer(detID);
     if (layerIndex - 1 < eff.barrel_efficiencies.size())
       subdetEfficiency = eff.barrel_efficiencies[layerIndex - 1];
   } else {  // forward disks
     uint32_t diskIndex = 2 * tTopo->pxfDisk(detID) - tTopo->pxfSide(detID);
     if (diskIndex - 1 < eff.endcap_efficiencies.size())
       subdetEfficiency = eff.endcap_efficiencies[diskIndex - 1];
   }
 
   LogDebug("Phase2TrackerDigitizerAlgorithm") << " enter pixel_inefficiency " << subdetEfficiency;
 
   // Now loop again over pixels to kill some of them.
   // Loop over hits, amplitude in electrons, channel = coded row,col
   for (auto& s : theSignal) {
     float rand = rengine_->flat();
     if (rand > subdetEfficiency) {
       // make amplitude =0
       s.second.set(0.);  // reset amplitude
     }
   }
 }

◆ pixel_inefficiency_db()

void Phase2TrackerDigitizerAlgorithm::pixel_inefficiency_db ( uint32_t detID )

protectedvirtual

Definition at line 850 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), cuy::col, pixelFlag_, alignCSCRings::s, and theSiPixelGainCalibrationService_.

Referenced by digitize().

                                                                           {
   signal_map_type& theSignal = _signal[detID];  // check validity
 
   // Loop over hit pixels, amplitude in electrons, channel = coded row,col
   for (auto& s : theSignal) {
     std::pair<int, int> ip;
     if (pixelFlag_)
       ip = PixelDigi::channelToPixel(s.first);  //get pixel pos
     else
       ip = Phase2TrackerDigi::channelToPixel(s.first);  //get pixel pos
 
     int row = ip.first;   // X in row
     int col = ip.second;  // Y is in col
     // transform to ROC index coordinates
     if (theSiPixelGainCalibrationService_->isDead(detID, col, row))
       s.second.set(0.);  // reset amplitude
   }
 }

◆ primary_ionization()

std::vector< digitizerUtility::EnergyDepositUnit > Phase2TrackerDigitizerAlgorithm::primary_ionization ( const PSimHit & hit ) const

protectedvirtual

Definition at line 216 of file Phase2TrackerDigitizerAlgorithm.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), simKBmtfDigis_cfi::eLoss, HBHEDarkening_cff::energy, digitizerUtility::EnergyDepositUnit::energy(), fluctuateCharge_, fluctuateEloss(), GeVperElectron_, mps_fire::i, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), point, hit::x, digitizerUtility::EnergyDepositUnit::x(), hit::y, digitizerUtility::EnergyDepositUnit::y(), hit::z, and digitizerUtility::EnergyDepositUnit::z().

Referenced by accumulateSimHits().

                               {
   // Straight line approximation for trajectory inside active media
   constexpr float SegmentLength = 0.0010;  // in cm (10 microns)
   // Get the 3D segment direction vector
   LocalVector direction = hit.exitPoint() - hit.entryPoint();
 
   float eLoss = hit.energyLoss();  // Eloss in GeV
   float length = direction.mag();  // Track length in Silicon
 
   int NumberOfSegments = static_cast<int>(length / SegmentLength);  // Number of segments
   if (NumberOfSegments < 1)
     NumberOfSegments = 1;
   LogDebug("Phase2TrackerDigitizerAlgorithm")
       << "enter primary_ionzation " << NumberOfSegments << " shift = " << hit.exitPoint().x() - hit.entryPoint().x()
       << " " << hit.exitPoint().y() - hit.entryPoint().y() << " " << hit.exitPoint().z() - hit.entryPoint().z() << " "
       << hit.particleType() << " " << hit.pabs();
 
   std::vector<float> elossVector;
   elossVector.reserve(NumberOfSegments);
   if (fluctuateCharge_) {
     // Generate fluctuated charge points
     elossVector = fluctuateEloss(hit.particleType(), hit.pabs(), eLoss, length, NumberOfSegments);
   } else {
     float averageEloss = eLoss / NumberOfSegments;
     elossVector.resize(NumberOfSegments, averageEloss);
   }
 
   std::vector<digitizerUtility::EnergyDepositUnit> ionization_points;
   ionization_points.reserve(NumberOfSegments);  // set size
   // loop over segments
   for (size_t i = 0; i < elossVector.size(); ++i) {
     // Divide the segment into equal length subsegments
     Local3DPoint point = hit.entryPoint() + ((i + 0.5) / NumberOfSegments) * direction;
     float energy = elossVector[i] / GeVperElectron_;  // Convert charge to elec.
 
     digitizerUtility::EnergyDepositUnit edu(energy, point);  // define position,energy point
     ionization_points.push_back(edu);                        // save
     LogDebug("Phase2TrackerDigitizerAlgorithm")
         << "For index = " << i << " EnergyDepositUnit-x = " << edu.x() << " EnergyDepositUnit-y = " << edu.y()
         << " EnergyDepositUnit-z = " << edu.z() << " EnergyDepositUnit-energy = " << edu.energy();
   }
   return ionization_points;
 }

◆ select_hit()

virtual bool Phase2TrackerDigitizerAlgorithm::select_hit	(	const PSimHit &	hit,
		double	tCorr,
		double &	sigScale
	)		const

inlinevirtual

Reimplemented in PixelDigitizerAlgorithm, PSSDigitizerAlgorithm, SSDigitizerAlgorithm, and PSPDigitizerAlgorithm.

Definition at line 76 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by accumulateSimHits().

76 { return true; }

Member Data Documentation

◆ _signal

signalMaps Phase2TrackerDigitizerAlgorithm::_signal

protected

Definition at line 109 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by PixelDigitizerAlgorithm::add_cross_talk(), add_cross_talk(), add_noise(), add_noisy_cells(), digitize(), Pixel3DDigitizerAlgorithm::induce_signal(), induce_signal(), initializeEvent(), loadAccumulator(), module_killing_conf(), PSSDigitizerAlgorithm::module_killing_DB(), SSDigitizerAlgorithm::module_killing_DB(), pixel_inefficiency(), and pixel_inefficiency_db().

◆ addNoise_

const bool Phase2TrackerDigitizerAlgorithm::addNoise_

protected

Definition at line 158 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ addNoisyPixels_

const bool Phase2TrackerDigitizerAlgorithm::addNoisyPixels_

protected

Definition at line 159 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ addPixelInefficiency_

const bool Phase2TrackerDigitizerAlgorithm::addPixelInefficiency_

protected

Definition at line 163 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), initializeEvent(), Phase2TrackerDigitizerAlgorithm(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ addThresholdSmearing_

const bool Phase2TrackerDigitizerAlgorithm::addThresholdSmearing_

protected

Definition at line 165 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ addXtalk_

const bool Phase2TrackerDigitizerAlgorithm::addXtalk_

protected

Definition at line 127 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ alpha2Order_

const bool Phase2TrackerDigitizerAlgorithm::alpha2Order_

protected

Definition at line 126 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift(), and driftDirection().

◆ badPixels_

Parameters Phase2TrackerDigitizerAlgorithm::badPixels_

protected

Definition at line 184 of file Phase2TrackerDigitizerAlgorithm.h.

◆ clusterWidth_

const float Phase2TrackerDigitizerAlgorithm::clusterWidth_

protected

Definition at line 133 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by induce_signal().

◆ deadModules_

const Parameters Phase2TrackerDigitizerAlgorithm::deadModules_

protected

Definition at line 118 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_conf().

◆ fluctuate_

const std::unique_ptr<SiG4UniversalFluctuation> Phase2TrackerDigitizerAlgorithm::fluctuate_

protected

Definition at line 187 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by fluctuateEloss().

◆ fluctuateCharge_

const bool Phase2TrackerDigitizerAlgorithm::fluctuateCharge_

protected

Definition at line 160 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent(), and primary_ionization().

◆ gaussDistribution_

std::unique_ptr<CLHEP::RandGaussQ> Phase2TrackerDigitizerAlgorithm::gaussDistribution_

protected

Definition at line 232 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise(), and initializeEvent().

◆ geom_

const TrackerGeometry* Phase2TrackerDigitizerAlgorithm::geom_

protected

Definition at line 95 of file Phase2TrackerDigitizerAlgorithm.h.

◆ GeVperElectron_

const float Phase2TrackerDigitizerAlgorithm::GeVperElectron_

protected

Definition at line 123 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by primary_ionization(), SSDigitizerAlgorithm::select_hit_latchedMode(), and SSDigitizerAlgorithm::select_hit_sampledMode().

◆ interstripCoupling_

const float Phase2TrackerDigitizerAlgorithm::interstripCoupling_

protected

Definition at line 128 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_cross_talk().

◆ makeDigiSimLinks_

const bool Phase2TrackerDigitizerAlgorithm::makeDigiSimLinks_

protected

Definition at line 111 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), Pixel3DDigitizerAlgorithm::induce_signal(), and induce_signal().

◆ pixelFlag_

bool Phase2TrackerDigitizerAlgorithm::pixelFlag_

protected

Definition at line 244 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by PixelDigitizerAlgorithm::add_cross_talk(), add_cross_talk(), add_noisy_cells(), Pixel3DDigitizerAlgorithm::induce_signal(), induce_signal(), module_killing_conf(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), pixel_inefficiency_db(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ pseudoRadDamage_

const double Phase2TrackerDigitizerAlgorithm::pseudoRadDamage_

protected

Definition at line 168 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift(), and Pixel3DDigitizerAlgorithm::driftFor3DSensors().

◆ pseudoRadDamageRadius_

const double Phase2TrackerDigitizerAlgorithm::pseudoRadDamageRadius_

protected

Definition at line 169 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift(), and Pixel3DDigitizerAlgorithm::driftFor3DSensors().

◆ rengine_

CLHEP::HepRandomEngine* Phase2TrackerDigitizerAlgorithm::rengine_

protected

Definition at line 239 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells(), fluctuateEloss(), initializeEvent(), and pixel_inefficiency().

◆ Sigma0_

const float Phase2TrackerDigitizerAlgorithm::Sigma0_

protected

Definition at line 129 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

◆ SigmaCoeff_

const float Phase2TrackerDigitizerAlgorithm::SigmaCoeff_

protected

Definition at line 130 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

◆ siPhase2OTLorentzAngle_

const SiPhase2OuterTrackerLorentzAngle* Phase2TrackerDigitizerAlgorithm::siPhase2OTLorentzAngle_

protected

Definition at line 89 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by driftDirection().

◆ siPixelBadModule_

const SiPixelQuality* Phase2TrackerDigitizerAlgorithm::siPixelBadModule_

protected

Definition at line 92 of file Phase2TrackerDigitizerAlgorithm.h.

◆ siPixelLorentzAngle_

const SiPixelLorentzAngle* Phase2TrackerDigitizerAlgorithm::siPixelLorentzAngle_

protected

Definition at line 86 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by driftDirection().

◆ smearedThreshold_Barrel_

std::unique_ptr<CLHEP::RandGaussQ> Phase2TrackerDigitizerAlgorithm::smearedThreshold_Barrel_

protected

Definition at line 236 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ smearedThreshold_Endcap_

std::unique_ptr<CLHEP::RandGaussQ> Phase2TrackerDigitizerAlgorithm::smearedThreshold_Endcap_

protected

Definition at line 235 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ subdetEfficiencies_

const SubdetEfficiencies Phase2TrackerDigitizerAlgorithm::subdetEfficiencies_

protected

Definition at line 228 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ tanLorentzAnglePerTesla_Barrel_

const float Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Barrel_

protected

Definition at line 155 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by driftDirection().

◆ tanLorentzAnglePerTesla_Endcap_

const float Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Endcap_

protected

Definition at line 154 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by driftDirection().

◆ theAdcFullScale_

const int Phase2TrackerDigitizerAlgorithm::theAdcFullScale_

protected

Definition at line 138 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by convertSignalToAdc(), Phase2TrackerDigitizerAlgorithm(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ theElectronPerADC_

const float Phase2TrackerDigitizerAlgorithm::theElectronPerADC_

protected

Definition at line 137 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by convertSignalToAdc(), Phase2TrackerDigitizerAlgorithm(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ theHIPThresholdInE_Barrel_

const double Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Barrel_

protected

Definition at line 150 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ theHIPThresholdInE_Endcap_

const double Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Endcap_

protected

Definition at line 149 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ theNoiseInElectrons_

const float Phase2TrackerDigitizerAlgorithm::theNoiseInElectrons_

protected

Definition at line 139 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells(), digitize(), and initializeEvent().

◆ theNoiser_

const std::unique_ptr<GaussianTailNoiseGenerator> Phase2TrackerDigitizerAlgorithm::theNoiser_

protected

Definition at line 188 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells().

◆ thePhase2ReadoutMode_

const int Phase2TrackerDigitizerAlgorithm::thePhase2ReadoutMode_

protected

Definition at line 136 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by convertSignalToAdc().

◆ theReadoutNoise_

const float Phase2TrackerDigitizerAlgorithm::theReadoutNoise_

protected

Definition at line 140 of file Phase2TrackerDigitizerAlgorithm.h.

◆ theSiPixelChargeReweightingAlgorithm_

const std::unique_ptr<SiPixelChargeReweightingAlgorithm> Phase2TrackerDigitizerAlgorithm::theSiPixelChargeReweightingAlgorithm_

protected

Definition at line 174 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by induce_signal().

◆ theSiPixelGainCalibrationService_

const std::unique_ptr<SiPixelGainCalibrationOfflineSimService> Phase2TrackerDigitizerAlgorithm::theSiPixelGainCalibrationService_

protected

Definition at line 217 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by pixel_inefficiency_db().

◆ theThresholdInE_Barrel_

const float Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_

protected

Definition at line 144 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells(), digitize(), initializeEvent(), Phase2TrackerDigitizerAlgorithm(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), SSDigitizerAlgorithm::select_hit_latchedMode(), SSDigitizerAlgorithm::select_hit_sampledMode(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ theThresholdInE_Endcap_

const float Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap_

protected

Definition at line 143 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells(), digitize(), initializeEvent(), Phase2TrackerDigitizerAlgorithm(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), SSDigitizerAlgorithm::select_hit_latchedMode(), SSDigitizerAlgorithm::select_hit_sampledMode(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ theThresholdSmearing_Barrel_

const double Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Barrel_

protected

Definition at line 147 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent().

◆ theThresholdSmearing_Endcap_

const double Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Endcap_

protected

Definition at line 146 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent().

◆ theTofLowerCut_

const float Phase2TrackerDigitizerAlgorithm::theTofLowerCut_

protected

Definition at line 152 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by PixelDigitizerAlgorithm::isAboveThreshold(), PSPDigitizerAlgorithm::select_hit(), PSSDigitizerAlgorithm::select_hit(), SSDigitizerAlgorithm::select_hit(), and PixelDigitizerAlgorithm::select_hit().

◆ theTofUpperCut_

const float Phase2TrackerDigitizerAlgorithm::theTofUpperCut_

protected

Definition at line 153 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by PixelDigitizerAlgorithm::isAboveThreshold(), PSPDigitizerAlgorithm::select_hit(), PSSDigitizerAlgorithm::select_hit(), SSDigitizerAlgorithm::select_hit(), and PixelDigitizerAlgorithm::select_hit().

◆ tMax_

const double Phase2TrackerDigitizerAlgorithm::tMax_

protected

Definition at line 181 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by fluctuateEloss(), Phase2TrackerDigitizerAlgorithm(), Pixel3DDigitizerAlgorithm::Pixel3DDigitizerAlgorithm(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ use_deadmodule_DB_

const bool Phase2TrackerDigitizerAlgorithm::use_deadmodule_DB_

protected

Definition at line 115 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ use_ineff_from_db_

const bool Phase2TrackerDigitizerAlgorithm::use_ineff_from_db_

protected

Definition at line 113 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ use_LorentzAngle_DB_

const bool Phase2TrackerDigitizerAlgorithm::use_LorentzAngle_DB_

protected

Definition at line 116 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by driftDirection(), PixelDigitizerAlgorithm::PixelDigitizerAlgorithm(), PSPDigitizerAlgorithm::PSPDigitizerAlgorithm(), PSSDigitizerAlgorithm::PSSDigitizerAlgorithm(), and SSDigitizerAlgorithm::SSDigitizerAlgorithm().

◆ use_module_killing_

const bool Phase2TrackerDigitizerAlgorithm::use_module_killing_

protected

Definition at line 114 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ useChargeReweighting_

const bool Phase2TrackerDigitizerAlgorithm::useChargeReweighting_

protected

Definition at line 172 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by induce_signal().

Classes

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Frame

◆ Parameters

◆ signal_map_type

◆ signalMaps

Constructor & Destructor Documentation

◆ Phase2TrackerDigitizerAlgorithm()

◆ ~Phase2TrackerDigitizerAlgorithm()

Member Function Documentation

◆ accumulateSimHits()

◆ add_cross_talk()

◆ add_noise()

◆ add_noisy_cells()

◆ calcQ()

◆ convertSignalToAdc()

◆ digitize()

◆ drift()

◆ driftDirection()

◆ fluctuateEloss()

◆ induce_signal()

◆ init()

◆ initializeEvent()

◆ isAboveThreshold()

◆ loadAccumulator()

◆ module_killing_conf()

◆ module_killing_DB()

◆ pixel_inefficiency()

◆ pixel_inefficiency_db()

◆ primary_ionization()

◆ select_hit()

Member Data Documentation

◆ _signal

◆ addNoise_

◆ addNoisyPixels_

◆ addPixelInefficiency_

◆ addThresholdSmearing_

◆ addXtalk_

◆ alpha2Order_

◆ badPixels_

◆ clusterWidth_

◆ deadModules_

◆ fluctuate_

◆ fluctuateCharge_

◆ gaussDistribution_

◆ geom_

◆ GeVperElectron_

◆ interstripCoupling_

◆ makeDigiSimLinks_

◆ pixelFlag_

◆ pseudoRadDamage_

◆ pseudoRadDamageRadius_

◆ rengine_

◆ Sigma0_

◆ SigmaCoeff_

◆ siPhase2OTLorentzAngle_

◆ siPixelBadModule_

◆ siPixelLorentzAngle_

◆ smearedThreshold_Barrel_

◆ smearedThreshold_Endcap_

◆ subdetEfficiencies_

◆ tanLorentzAnglePerTesla_Barrel_

◆ tanLorentzAnglePerTesla_Endcap_

◆ theAdcFullScale_

◆ theElectronPerADC_

◆ theHIPThresholdInE_Barrel_

◆ theHIPThresholdInE_Endcap_

◆ theNoiseInElectrons_

◆ theNoiser_

◆ thePhase2ReadoutMode_

◆ theReadoutNoise_

◆ theSiPixelChargeReweightingAlgorithm_

◆ theSiPixelGainCalibrationService_

◆ theThresholdInE_Barrel_

◆ theThresholdInE_Endcap_