CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes
Phase2TrackerDigitizerAlgorithm Class Referenceabstract

#include <Phase2TrackerDigitizerAlgorithm.h>

Inheritance diagram for Phase2TrackerDigitizerAlgorithm:
Pixel3DDigitizerAlgorithm PixelDigitizerAlgorithm PSPDigitizerAlgorithm PSSDigitizerAlgorithm SSDigitizerAlgorithm

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)=0
 
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)
 
void loadAccumulator (uint32_t detId, const std::map< int, float > &accumulator)
 
 Phase2TrackerDigitizerAlgorithm (const edm::ParameterSet &conf_common, const edm::ParameterSet &conf_specific)
 
virtual bool select_hit (const PSimHit &hit, double tCorr, double &sigScale)
 
virtual ~Phase2TrackerDigitizerAlgorithm ()
 

Protected Types

using Frame = GloballyPositioned< double >
 
using Parameters = std::vector< edm::ParameterSet >
 
using signal_map_type = std::map< int, DigitizerUtility::Amplitude, 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)
 
double calcQ (float x) const
 
int convertSignalToAdc (uint32_t detID, float signal_in_elec, float threshold)
 
void drift (const PSimHit &hit, const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield, const std::vector< DigitizerUtility::EnergyDepositUnit > &ionization_points, std::vector< DigitizerUtility::SignalPoint > &collection_points) const
 
LocalVector DriftDirection (const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield, const DetId &detId) const
 
void fluctuateEloss (int particleId, float momentum, float eloss, float length, int NumberOfSegments, std::vector< float > &elossVector) const
 
void induce_signal (const PSimHit &hit, const size_t hitIndex, 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)
 
virtual void pixel_inefficiency (const SubdetEfficiencies &eff, const Phase2TrackerGeomDetUnit *pixdet, const TrackerTopology *tTopo)
 
virtual void pixel_inefficiency_db (uint32_t detID)
 
void primary_ionization (const PSimHit &hit, std::vector< DigitizerUtility::EnergyDepositUnit > &ionization_points) 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_
 
edm::ESHandle< SiPixelFedCablingMap > fedCablingMap_
 
const std::unique_ptr< SiG4UniversalFluctuation > fluctuate_
 
const bool fluctuateCharge_
 
std::unique_ptr< CLHEP::RandGaussQ > gaussDistribution_
 
edm::ESHandle< 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_
 
edm::ESHandle< SiPixelQuality > SiPixelBadModule_
 
edm::ESHandle< 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< 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_
 

Detailed Description

Definition at line 58 of file Phase2TrackerDigitizerAlgorithm.h.

Member Typedef Documentation

◆ Frame

using Phase2TrackerDigitizerAlgorithm::Frame = GloballyPositioned<double>
protected

Definition at line 102 of file Phase2TrackerDigitizerAlgorithm.h.

◆ Parameters

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

Definition at line 103 of file Phase2TrackerDigitizerAlgorithm.h.

◆ signal_map_type

using Phase2TrackerDigitizerAlgorithm::signal_map_type = std::map<int, DigitizerUtility::Amplitude, std::less<int> >
protected

Definition at line 100 of file Phase2TrackerDigitizerAlgorithm.h.

◆ signalMaps

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

Definition at line 101 of file Phase2TrackerDigitizerAlgorithm.h.

Constructor & Destructor Documentation

◆ Phase2TrackerDigitizerAlgorithm()

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

Definition at line 48 of file Phase2TrackerDigitizerAlgorithm.cc.

50  : _signal(),
51  makeDigiSimLinks_(conf_common.getUntrackedParameter<bool>("makeDigiSimLinks", true)),
52  use_ineff_from_db_(conf_specific.getParameter<bool>("Inefficiency_DB")),
53  use_module_killing_(conf_specific.getParameter<bool>("KillModules")), // boolean to kill or not modules
54  use_deadmodule_DB_(conf_specific.getParameter<bool>("DeadModules_DB")), // boolean to access dead modules from DB
55  // boolean to access Lorentz angle from DB
56  use_LorentzAngle_DB_(conf_specific.getParameter<bool>("LorentzAngle_DB")),
57 
58  // get dead module from cfg file
59  deadModules_(use_deadmodule_DB_ ? Parameters() : conf_specific.getParameter<Parameters>("DeadModules")),
60 
61  // Common pixel parameters
62  // These are parameters which are not likely to be changed
63  GeVperElectron_(3.61E-09), // 1 electron(3.61eV, 1keV(277e, mod 9/06 d.k.
64  alpha2Order_(conf_specific.getParameter<bool>("Alpha2Order")), // switch on/off of E.B effect
65  addXtalk_(conf_specific.getParameter<bool>("AddXTalk")),
66  // Interstrip Coupling - Not used in PixelDigitizerAlgorithm
67  interstripCoupling_(conf_specific.getParameter<double>("InterstripCoupling")),
68 
69  Sigma0_(conf_specific.getParameter<double>("SigmaZero")), // Charge diffusion constant 7->3.7
70  SigmaCoeff_(conf_specific.getParameter<double>("SigmaCoeff")), // delta in the diffusion across the strip pitch
71  // (set between 0 to 0.9, 0-->flat Sigma0, 1-->Sigma_min=0 & Sigma_max=2*Sigma0
72  // D.B.: Dist300 replaced by moduleThickness, may not work with partially depleted sensors but works otherwise
73  // Dist300(0.0300), // normalized to 300micron Silicon
74 
75  // Charge integration spread on the collection plane
76  clusterWidth_(conf_specific.getParameter<double>("ClusterWidth")),
77 
78  // Allowed modes of readout which has following values :
79  // 0 ---> Digital or binary readout
80  // -1 ---> Analog readout, current digitizer (Inner Pixel) (TDR version) with no threshold subtraction
81  // Analog readout with dual slope with the "second" slope being 1/2^(n-1) and threshold subtraction (n = 1, 2, 3,4)
82  thePhase2ReadoutMode_(conf_specific.getParameter<int>("Phase2ReadoutMode")),
83 
84  // ADC calibration 1adc count(135e.
85  // Corresponds to 2adc/kev, 270[e/kev]/135[e/adc](2[adc/kev]
86  // Be careful, this parameter is also used in SiPixelDet.cc to
87  // calculate the noise in adc counts from noise in electrons.
88  // Both defaults should be the same.
89  theElectronPerADC_(conf_specific.getParameter<double>("ElectronPerAdc")),
90 
91  // ADC saturation value, 255(8bit adc.
92  theAdcFullScale_(conf_specific.getParameter<int>("AdcFullScale")),
93 
94  // Noise in electrons:
95  // Pixel cell noise, relevant for generating noisy pixels
96  theNoiseInElectrons_(conf_specific.getParameter<double>("NoiseInElectrons")),
97 
98  // Fill readout noise, including all readout chain, relevant for smearing
99  theReadoutNoise_(conf_specific.getParameter<double>("ReadoutNoiseInElec")),
100 
101  // Threshold in units of noise:
102  // thePixelThreshold(conf.getParameter<double>("ThresholdInNoiseUnits")),
103  // Pixel threshold in electron units.
104  theThresholdInE_Endcap_(conf_specific.getParameter<double>("ThresholdInElectrons_Endcap")),
105  theThresholdInE_Barrel_(conf_specific.getParameter<double>("ThresholdInElectrons_Barrel")),
106 
107  // Add threshold gaussian smearing:
108  theThresholdSmearing_Endcap_(conf_specific.getParameter<double>("ThresholdSmearing_Endcap")),
109  theThresholdSmearing_Barrel_(conf_specific.getParameter<double>("ThresholdSmearing_Barrel")),
110 
111  // Add HIP Threshold in electron units.
112  theHIPThresholdInE_Endcap_(conf_specific.getParameter<double>("HIPThresholdInElectrons_Endcap")),
113  theHIPThresholdInE_Barrel_(conf_specific.getParameter<double>("HIPThresholdInElectrons_Barrel")),
114 
115  // theTofCut 12.5, cut in particle TOD +/- 12.5ns
116  theTofLowerCut_(conf_specific.getParameter<double>("TofLowerCut")),
117  theTofUpperCut_(conf_specific.getParameter<double>("TofUpperCut")),
118 
119  // Get the Lorentz angle from the cfg file:
120  tanLorentzAnglePerTesla_Endcap_(
121  use_LorentzAngle_DB_ ? 0.0 : conf_specific.getParameter<double>("TanLorentzAnglePerTesla_Endcap")),
122  tanLorentzAnglePerTesla_Barrel_(
123  use_LorentzAngle_DB_ ? 0.0 : conf_specific.getParameter<double>("TanLorentzAnglePerTesla_Barrel")),
124 
125  // Add noise
126  addNoise_(conf_specific.getParameter<bool>("AddNoise")),
127 
128  // Add noisy pixels
129  addNoisyPixels_(conf_specific.getParameter<bool>("AddNoisyPixels")),
130 
131  // Fluctuate charge in track subsegments
132  fluctuateCharge_(conf_specific.getUntrackedParameter<bool>("FluctuateCharge", true)),
133 
134  // Control the pixel inefficiency
135  addPixelInefficiency_(conf_specific.getParameter<bool>("AddInefficiency")),
136 
137  // Add threshold gaussian smearing:
138  addThresholdSmearing_(conf_specific.getParameter<bool>("AddThresholdSmearing")),
139 
140  // Add some pseudo-red damage
141  pseudoRadDamage_(conf_specific.exists("PseudoRadDamage") ? conf_specific.getParameter<double>("PseudoRadDamage")
142  : double(0.0)),
143  pseudoRadDamageRadius_(conf_specific.exists("PseudoRadDamageRadius")
144  ? conf_specific.getParameter<double>("PseudoRadDamageRadius")
145  : double(0.0)),
146 
147  // delta cutoff in MeV, has to be same as in OSCAR(0.030/cmsim=1.0 MeV
148  // tMax(0.030), // In MeV.
149  // tMax(conf.getUntrackedParameter<double>("DeltaProductionCut",0.030)),
150  tMax_(conf_common.getParameter<double>("DeltaProductionCut")),
151 
152  badPixels_(conf_specific.getParameter<Parameters>("CellsToKill")),
153 
154  fluctuate_(fluctuateCharge_ ? std::make_unique<SiG4UniversalFluctuation>() : nullptr),
155  theNoiser_(addNoise_ ? std::make_unique<GaussianTailNoiseGenerator>() : nullptr),
156  theSiPixelGainCalibrationService_(
157  use_ineff_from_db_ ? std::make_unique<SiPixelGainCalibrationOfflineSimService>(conf_specific) : nullptr),
158  subdetEfficiencies_(conf_specific) {
159  LogDebug("Phase2TrackerDigitizerAlgorithm")
160  << "Phase2TrackerDigitizerAlgorithm constructed\n"
161  << "Configuration parameters:\n"
162  << "Threshold/Gain = "
163  << "threshold in electron Endcap = " << theThresholdInE_Endcap_
164  << "\nthreshold in electron Barrel = " << theThresholdInE_Barrel_ << " ElectronPerADC " << theElectronPerADC_
165  << " ADC Scale (in bits) " << theAdcFullScale_ << " The delta cut-off is set to " << tMax_ << " pix-inefficiency "
166  << addPixelInefficiency_;
167 }

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

◆ ~Phase2TrackerDigitizerAlgorithm()

Phase2TrackerDigitizerAlgorithm::~Phase2TrackerDigitizerAlgorithm ( )
virtual

Definition at line 169 of file Phase2TrackerDigitizerAlgorithm.cc.

169  {
170  LogDebug("Phase2TrackerDigitizerAlgorithm") << "Phase2TrackerDigitizerAlgorithm deleted";
171 }

References LogDebug.

Member Function Documentation

◆ accumulateSimHits()

virtual 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 
)
pure virtual

Implemented in PixelDigitizerAlgorithm, PSPDigitizerAlgorithm, PSSDigitizerAlgorithm, and SSDigitizerAlgorithm.

◆ add_cross_talk()

void Phase2TrackerDigitizerAlgorithm::add_cross_talk ( const Phase2TrackerGeomDetUnit *  pixdet)
protectedvirtual

Reimplemented in PixelDigitizerAlgorithm.

Definition at line 564 of file Phase2TrackerDigitizerAlgorithm.cc.

564  {
565  uint32_t detID = pixdet->geographicalId().rawId();
566  signal_map_type& theSignal = _signal[detID];
567  signal_map_type signalNew;
568  const Phase2TrackerTopology* topol = &pixdet->specificTopology();
569  int numRows = topol->nrows();
570 
571  for (auto& s : theSignal) {
572  float signalInElectrons = s.second.ampl(); // signal in electrons
573 
574  std::pair<int, int> hitChan;
575  if (pixelFlag_)
576  hitChan = PixelDigi::channelToPixel(s.first);
577  else
578  hitChan = Phase2TrackerDigi::channelToPixel(s.first);
579 
580  float signalInElectrons_Xtalk = signalInElectrons * interstripCoupling_;
581  // subtract the charge which will be shared
582  s.second.set(signalInElectrons - signalInElectrons_Xtalk);
583 
584  if (hitChan.first != 0) {
585  auto XtalkPrev = std::make_pair(hitChan.first - 1, hitChan.second);
586  int chanXtalkPrev = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second)
587  : Phase2TrackerDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second);
588  signalNew.emplace(chanXtalkPrev, DigitizerUtility::Amplitude(signalInElectrons_Xtalk, nullptr, -1.0));
589  }
590  if (hitChan.first < numRows - 1) {
591  auto XtalkNext = std::make_pair(hitChan.first + 1, hitChan.second);
592  int chanXtalkNext = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkNext.first, XtalkNext.second)
593  : Phase2TrackerDigi::pixelToChannel(XtalkNext.first, XtalkNext.second);
594  signalNew.emplace(chanXtalkNext, DigitizerUtility::Amplitude(signalInElectrons_Xtalk, nullptr, -1.0));
595  }
596  }
597  for (auto const& l : signalNew) {
598  int chan = l.first;
599  auto iter = theSignal.find(chan);
600  if (iter != theSignal.end()) {
601  theSignal[chan] += l.second.ampl();
602  } else {
603  theSignal.emplace(chan, DigitizerUtility::Amplitude(l.second.ampl(), nullptr, -1.0));
604  }
605  }
606 }

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

Referenced by digitize().

◆ add_noise()

void Phase2TrackerDigitizerAlgorithm::add_noise ( const Phase2TrackerGeomDetUnit *  pixdet)
protectedvirtual

Definition at line 548 of file Phase2TrackerDigitizerAlgorithm.cc.

548  {
549  uint32_t detID = pixdet->geographicalId().rawId();
550  signal_map_type& theSignal = _signal[detID];
551  for (auto& s : theSignal) {
552  float noise = gaussDistribution_->fire();
553  if ((s.second.ampl() + noise) < 0.)
554  s.second.set(0);
555  else
556  s.second += noise;
557  }
558 }

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

Referenced by digitize().

◆ add_noisy_cells()

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

Definition at line 613 of file Phase2TrackerDigitizerAlgorithm.cc.

613  {
614  uint32_t detID = pixdet->geographicalId().rawId();
615  signal_map_type& theSignal = _signal[detID];
616  const Phase2TrackerTopology* topol = &pixdet->specificTopology();
617 
618  int numColumns = topol->ncolumns(); // det module number of cols&rows
619  int numRows = topol->nrows();
620 
621  int numberOfPixels = numRows * numColumns;
622  std::map<int, float, std::less<int> > otherPixels;
623 
624  theNoiser_->generate(numberOfPixels,
625  thePixelThreshold, //thr. in un. of nois
626  theNoiseInElectrons_, // noise in elec.
627  otherPixels,
628  rengine_);
629 
630  LogDebug("Phase2TrackerDigitizerAlgorithm")
631  << " Add noisy pixels " << numRows << " " << numColumns << " " << theNoiseInElectrons_ << " "
632  << theThresholdInE_Endcap_ << " " << theThresholdInE_Barrel_ << " " << numberOfPixels << " "
633  << otherPixels.size();
634 
635  // Add noisy pixels
636  for (auto const& el : otherPixels) {
637  int iy = el.first / numRows;
638  if (iy < 0 || iy > numColumns - 1)
639  LogWarning("Phase2TrackerDigitizerAlgorithm") << " error in iy " << iy;
640 
641  int ix = el.first - iy * numRows;
642  if (ix < 0 || ix > numRows - 1)
643  LogWarning("Phase2TrackerDigitizerAlgorithm") << " error in ix " << ix;
644 
645  int chan = pixelFlag_ ? PixelDigi::pixelToChannel(ix, iy) : Phase2TrackerDigi::pixelToChannel(ix, iy);
646 
647  LogDebug("Phase2TrackerDigitizerAlgorithm")
648  << " Storing noise = " << el.first << " " << el.second << " " << ix << " " << iy << " " << chan;
649 
650  if (theSignal[chan] == 0)
651  theSignal[chan] = DigitizerUtility::Amplitude(el.second, nullptr, -1.);
652  }
653 }

References _signal, LaserClient_cfi::Amplitude, officialStyle::chan, GeomDet::geographicalId(), 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().

◆ calcQ()

double Phase2TrackerDigitizerAlgorithm::calcQ ( float  x) const
inlineprotected

Definition at line 237 of file Phase2TrackerDigitizerAlgorithm.h.

237  {
238  auto xx = std::min(0.5f * x * x, 12.5f);
239  return 0.5 * (1.0 - std::copysign(std::sqrt(1.f - unsafe_expf<4>(-xx * (1.f + 0.2733f / (1.f + 0.147f * xx)))), x));
240  }

References f, min(), mathSSE::sqrt(), x, and geometryCSVtoXML::xx.

Referenced by induce_signal().

◆ convertSignalToAdc()

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

Definition at line 968 of file Phase2TrackerDigitizerAlgorithm.cc.

968  {
969  int signal_in_adc;
970  int temp_signal;
971  const int max_limit = 10;
972  if (thePhase2ReadoutMode_ == 0) {
973  signal_in_adc = theAdcFullScale_;
974  } else {
975  if (thePhase2ReadoutMode_ == -1) {
976  temp_signal = std::min(static_cast<int>(signal_in_elec / theElectronPerADC_), theAdcFullScale_);
977  } else {
978  // calculate the kink point and the slope
979  int dualslope_param = std::min(std::abs(thePhase2ReadoutMode_), max_limit);
980  int kink_point = static_cast<int>(theAdcFullScale_ / 2) + 1;
981  temp_signal = std::floor((signal_in_elec - threshold) / theElectronPerADC_) + 1;
982  if (temp_signal > kink_point)
983  temp_signal = std::floor((temp_signal - kink_point) / (pow(2, dualslope_param - 1))) + kink_point;
984  }
985  signal_in_adc = std::min(temp_signal, theAdcFullScale_);
986  LogTrace("Phase2TrackerDigitizerAlgorithm")
987  << " DetId " << detID << " signal_in_elec " << signal_in_elec << " threshold " << threshold
988  << " signal_above_thr " << signal_in_elec - threshold << " temp conversion "
989  << std::floor((signal_in_elec - threshold) / theElectronPerADC_) + 1 << " signal after slope correction "
990  << temp_signal << " signal_in_adc " << signal_in_adc;
991  }
992  return signal_in_adc;
993 }

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

Referenced by digitize().

◆ digitize()

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

Definition at line 893 of file Phase2TrackerDigitizerAlgorithm.cc.

895  {
896  uint32_t detID = pixdet->geographicalId().rawId();
897  auto it = _signal.find(detID);
898  if (it == _signal.end())
899  return;
900 
901  const signal_map_type& theSignal = _signal[detID];
902 
903  uint32_t Sub_detid = DetId(detID).subdetId();
904 
905  float theThresholdInE = 0.;
906  float theHIPThresholdInE = 0.;
907  // Define Threshold
908  if (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == StripSubdetector::TOB) { // Barrel modules
909  theThresholdInE = addThresholdSmearing_ ? smearedThreshold_Barrel_->fire() // gaussian smearing
910  : theThresholdInE_Barrel_; // no smearing
911  theHIPThresholdInE = theHIPThresholdInE_Barrel_;
912  } else { // Forward disks modules
913  theThresholdInE = addThresholdSmearing_ ? smearedThreshold_Endcap_->fire() // gaussian smearing
914  : theThresholdInE_Endcap_; // no smearing
915  theHIPThresholdInE = theHIPThresholdInE_Endcap_;
916  }
917 
918  // if (addNoise) add_noise(pixdet, theThresholdInE/theNoiseInElectrons_); // generate noise
919  if (addNoise_)
920  add_noise(pixdet); // generate noise
921  if (addXtalk_)
922  add_cross_talk(pixdet);
923  if (addNoisyPixels_)
924  add_noisy_cells(pixdet, theHIPThresholdInE / theElectronPerADC_);
925 
926  // Do only if needed
927  if (addPixelInefficiency_ && !theSignal.empty()) {
928  if (use_ineff_from_db_)
929  pixel_inefficiency_db(detID);
930  else
931  pixel_inefficiency(subdetEfficiencies_, pixdet, tTopo);
932  }
933  if (use_module_killing_) {
934  if (use_deadmodule_DB_) // remove dead modules using DB
935  module_killing_DB(pixdet);
936  else // remove dead modules using the list in cfg file
937  module_killing_conf(detID);
938  }
939 
940  // Digitize if the signal is greater than threshold
941  for (auto const& s : theSignal) {
942  const DigitizerUtility::Amplitude& sig_data = s.second;
943  float signalInElectrons = sig_data.ampl();
944 
945  const auto& info_list = sig_data.simInfoList();
946  const DigitizerUtility::SimHitInfo* hitInfo = nullptr;
947  if (!info_list.empty())
948  hitInfo = std::max_element(info_list.begin(), info_list.end())->second.get();
949 
950  if (isAboveThreshold(hitInfo, signalInElectrons, theThresholdInE)) { // check threshold
951  DigitizerUtility::DigiSimInfo info;
952  info.sig_tot = convertSignalToAdc(detID, signalInElectrons, theThresholdInE); // adc
953  info.ot_bit = signalInElectrons > theHIPThresholdInE ? true : false;
954  if (makeDigiSimLinks_) {
955  for (auto const& l : sig_data.simInfoList()) {
956  float charge_frac = l.first / signalInElectrons;
957  if (l.first > -5.0)
958  info.simInfoList.push_back({charge_frac, l.second.get()});
959  }
960  }
961  digi_map.insert({s.first, info});
962  }
963  }
964 }

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

◆ drift()

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

Definition at line 293 of file Phase2TrackerDigitizerAlgorithm.cc.

297  {
298  LogDebug("Phase2TrackerDigitizerAlgorithm") << "enter drift ";
299 
300  collection_points.reserve(ionization_points.size()); // set size
301  LocalVector driftDir = DriftDirection(pixdet, bfield, hit.detUnitId()); // get the charge drift direction
302  if (driftDir.z() == 0.) {
303  LogWarning("Phase2TrackerDigitizerAlgorithm") << " pxlx: drift in z is zero ";
304  return;
305  }
306 
307  float TanLorenzAngleX = driftDir.x(); // tangent of Lorentz angle
308  float TanLorenzAngleY = 0.; // force to 0, driftDir.y()/driftDir.z();
309  float dir_z = driftDir.z(); // The z drift direction
310  float CosLorenzAngleX = 1. / std::sqrt(1. + std::pow(TanLorenzAngleX, 2)); // cosine to estimate the path length
311  float CosLorenzAngleY = 1.;
312  if (alpha2Order_) {
313  TanLorenzAngleY = driftDir.y();
314  CosLorenzAngleY = 1. / std::sqrt(1. + std::pow(TanLorenzAngleY, 2)); // cosine
315  }
316 
317  float moduleThickness = pixdet->specificSurface().bounds().thickness();
318  float stripPitch = pixdet->specificTopology().pitch().first;
319 
320  LogDebug("Phase2TrackerDigitizerAlgorithm")
321  << " Lorentz Tan " << TanLorenzAngleX << " " << TanLorenzAngleY << " " << CosLorenzAngleX << " "
322  << CosLorenzAngleY << " " << moduleThickness * TanLorenzAngleX << " " << driftDir;
323 
324  for (auto const& val : ionization_points) {
325  // position
326  float SegX = val.x(), SegY = val.y(), SegZ = val.z();
327 
328  // Distance from the collection plane
329  // DriftDistance = (moduleThickness/2. + SegZ); // Drift to -z
330  // Include explixitely the E drift direction (for CMS dir_z=-1)
331 
332  // Distance between charge generation and collection
333  float driftDistance = moduleThickness / 2. - (dir_z * SegZ); // Drift to -z
334 
335  if (driftDistance < 0.)
336  driftDistance = 0.;
337  else if (driftDistance > moduleThickness)
338  driftDistance = moduleThickness;
339 
340  // Assume full depletion now, partial depletion will come later.
341  float XDriftDueToMagField = driftDistance * TanLorenzAngleX;
342  float YDriftDueToMagField = driftDistance * TanLorenzAngleY;
343 
344  // Shift cloud center
345  float CloudCenterX = SegX + XDriftDueToMagField;
346  float CloudCenterY = SegY + YDriftDueToMagField;
347 
348  // Calculate how long is the charge drift path
349  // Actual Drift Lentgh
350  float driftLength =
351  std::sqrt(std::pow(driftDistance, 2) + std::pow(XDriftDueToMagField, 2) + std::pow(YDriftDueToMagField, 2));
352 
353  // What is the charge diffusion after this path
354  // Sigma0=0.00037 is for 300um thickness (make sure moduleThickness is in [cm])
355  float Sigma = std::sqrt(driftLength / moduleThickness) * Sigma0_ * moduleThickness / 0.0300;
356  // D.B.: sigmaCoeff=0 means no modulation
357  if (SigmaCoeff_)
358  Sigma *= (SigmaCoeff_ * std::pow(cos(SegX * M_PI / stripPitch), 2) + 1);
359  // NB: divided by 4 to get a periodicity of stripPitch
360 
361  // Project the diffusion sigma on the collection plane
362  float Sigma_x = Sigma / CosLorenzAngleX;
363  float Sigma_y = Sigma / CosLorenzAngleY;
364 
365  // Insert a charge loss due to Rad Damage here
366  float energyOnCollector = val.energy(); // The energy that reaches the collector
367 
368  // pseudoRadDamage
369  if (pseudoRadDamage_) {
370  float moduleRadius = pixdet->surface().position().perp();
371  if (moduleRadius <= pseudoRadDamageRadius_) {
372  float kValue = pseudoRadDamage_ / std::pow(moduleRadius, 2);
373  energyOnCollector *= exp(-1 * kValue * driftDistance / moduleThickness);
374  }
375  }
376  LogDebug("Phase2TrackerDigitizerAlgorithm")
377  << "Dift DistanceZ = " << driftDistance << " module thickness = " << moduleThickness
378  << " Start Energy = " << val.energy() << " Energy after loss= " << energyOnCollector;
379  DigitizerUtility::SignalPoint sp(CloudCenterX, CloudCenterY, Sigma_x, Sigma_y, hit.tof(), energyOnCollector);
380 
381  // Load the Charge distribution parameters
382  collection_points.push_back(sp);
383  }
384 }

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 SSDigitizerAlgorithm::accumulateSimHits(), PSPDigitizerAlgorithm::accumulateSimHits(), PSSDigitizerAlgorithm::accumulateSimHits(), and PixelDigitizerAlgorithm::accumulateSimHits().

◆ DriftDirection()

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

Definition at line 714 of file Phase2TrackerDigitizerAlgorithm.cc.

716  {
717  Frame detFrame(pixdet->surface().position(), pixdet->surface().rotation());
718  LocalVector Bfield = detFrame.toLocal(bfield);
719 
720  float dir_x = 0.0;
721  float dir_y = 0.0;
722  float dir_z = 0.0;
723  float scale = 1.0;
724 
725  uint32_t detID = pixdet->geographicalId().rawId();
726  uint32_t Sub_detid = DetId(detID).subdetId();
727 
728  // Read Lorentz angle from DB:
729  if (use_LorentzAngle_DB_) {
730  float lorentzAngle = SiPixelLorentzAngle_->getLorentzAngle(detId);
731  float alpha2 = std::pow(lorentzAngle, 2);
732 
733  dir_x = -(lorentzAngle * Bfield.y() + alpha2 * Bfield.z() * Bfield.x());
734  dir_y = +(lorentzAngle * Bfield.x() - alpha2 * Bfield.z() * Bfield.y());
735  dir_z = -(1 + alpha2 * std::pow(Bfield.z(), 2));
736  scale = (1 + alpha2 * std::pow(Bfield.z(), 2));
737  } else {
738  // Read Lorentz angle from cfg file:
739  float alpha2_Endcap = 0.0;
740  float alpha2_Barrel = 0.0;
741  if (alpha2Order_) {
742  alpha2_Endcap = std::pow(tanLorentzAnglePerTesla_Endcap_, 2);
743  alpha2_Barrel = std::pow(tanLorentzAnglePerTesla_Barrel_, 2);
744  }
745 
746  if (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == StripSubdetector::TOB) { // barrel layers
747  dir_x = -(tanLorentzAnglePerTesla_Barrel_ * Bfield.y() + alpha2_Barrel * Bfield.z() * Bfield.x());
748  dir_y = +(tanLorentzAnglePerTesla_Barrel_ * Bfield.x() - alpha2_Barrel * Bfield.z() * Bfield.y());
749  dir_z = -(1 + alpha2_Barrel * std::pow(Bfield.z(), 2));
750  scale = (1 + alpha2_Barrel * std::pow(Bfield.z(), 2));
751 
752  } else { // forward disks
753  dir_x = -(tanLorentzAnglePerTesla_Endcap_ * Bfield.y() + alpha2_Endcap * Bfield.z() * Bfield.x());
754  dir_y = +(tanLorentzAnglePerTesla_Endcap_ * Bfield.x() - alpha2_Endcap * Bfield.z() * Bfield.y());
755  dir_z = -(1 + alpha2_Endcap * std::pow(Bfield.z(), 2));
756  scale = (1 + alpha2_Endcap * std::pow(Bfield.z(), 2));
757  }
758  }
759 
760  LocalVector theDriftDirection = LocalVector(dir_x / scale, dir_y / scale, dir_z / scale);
761  LogDebug("Phase2TrackerDigitizerAlgorithm") << " The drift direction in local coordinate is " << theDriftDirection;
762  return theDriftDirection;
763 }

References alpha2Order_, GeomDet::geographicalId(), SiPixelLorentzAngle::getLorentzAngle(), LogDebug, PixelSubdetector::PixelBarrel, GloballyPositioned< T >::position(), funct::pow(), DetId::rawId(), GloballyPositioned< T >::rotation(), Scenarios_cff::scale, SiPixelLorentzAngle_, DetId::subdetId(), GeomDet::surface(), tanLorentzAnglePerTesla_Barrel_, tanLorentzAnglePerTesla_Endcap_, StripSubdetector::TOB, and use_LorentzAngle_DB_.

Referenced by drift().

◆ fluctuateEloss()

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

Definition at line 228 of file Phase2TrackerDigitizerAlgorithm.cc.

233  {
234  // Get dedx for this track
235  //float dedx;
236  //if( length > 0.) dedx = eloss/length;
237  //else dedx = eloss;
238 
239  double particleMass = ::m_pion; // Mass in MeV, assume pion
240  pid = std::abs(pid);
241  if (pid != 211) { // Mass in MeV
242  if (pid == 11)
243  particleMass = ::m_electron;
244  else if (pid == 13)
245  particleMass = ::m_muon;
246  else if (pid == 321)
247  particleMass = ::m_kaon;
248  else if (pid == 2212)
249  particleMass = ::m_proton;
250  }
251  // What is the track segment length.
252  float segmentLength = length / NumberOfSegs;
253 
254  // Generate charge fluctuations.
255  float sum = 0.;
256  double segmentEloss = (1000. * eloss) / NumberOfSegs; //eloss in MeV
257  for (int i = 0; i < NumberOfSegs; ++i) {
258  // material,*, momentum,energy,*, *, mass
259  //myglandz_(14.,segmentLength,2.,2.,dedx,de,0.14);
260  // The G4 routine needs momentum in MeV, mass in Mev, delta-cut in MeV,
261  // track segment length in mm, segment eloss in MeV
262  // Returns fluctuated eloss in MeV
263  double deltaCutoff = tMax_; // the cutoff is sometimes redefined inside, so fix it.
264  float de = fluctuate_->SampleFluctuations(particleMomentum * 1000.,
265  particleMass,
266  deltaCutoff,
267  segmentLength * 10.,
268  segmentEloss,
269  rengine_) /
270  1000.; //convert to GeV
271  elossVector.push_back(de);
272  sum += de;
273  }
274  if (sum > 0.) { // if fluctuations give eloss>0.
275  // Rescale to the same total eloss
276  float ratio = eloss / sum;
277  std::transform(
278  std::begin(elossVector), std::end(elossVector), std::begin(elossVector), [&ratio](auto const& c) -> float {
279  return c * ratio;
280  }); // use a simple lambda expression
281  } else { // if fluctuations gives 0 eloss
282  float averageEloss = eloss / NumberOfSegs;
283  std::fill(std::begin(elossVector), std::end(elossVector), averageEloss);
284  }
285 }

References funct::abs(), begin, HltBtagPostValidation_cff::c, end, ntuplemaker::fill, fluctuate_, mps_fire::i, particleFlowDisplacedVertex_cfi::ratio, rengine_, tMax_, and HcalDetIdTransform::transform().

Referenced by primary_ionization().

◆ induce_signal()

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

Definition at line 389 of file Phase2TrackerDigitizerAlgorithm.cc.

394  {
395  // X - Rows, Left-Right, 160, (1.6cm) for barrel
396  // Y - Columns, Down-Up, 416, (6.4cm)
397  const Phase2TrackerTopology* topol = &pixdet->specificTopology();
398  uint32_t detID = pixdet->geographicalId().rawId();
399  signal_map_type& theSignal = _signal[detID];
400 
401  LogDebug("Phase2TrackerDigitizerAlgorithm")
402  << " enter induce_signal, " << topol->pitch().first << " " << topol->pitch().second;
403 
404  // local map to store pixels hit by 1 Hit.
405  using hit_map_type = std::map<int, float, std::less<int> >;
406  hit_map_type hit_signal;
407 
408  // Assign signals to readout channels and store sorted by channel number
409  // Iterate over collection points on the collection plane
410  for (auto const& v : collection_points) {
411  float CloudCenterX = v.position().x(); // Charge position in x
412  float CloudCenterY = v.position().y(); // in y
413  float SigmaX = v.sigma_x(); // Charge spread in x
414  float SigmaY = v.sigma_y(); // in y
415  float Charge = v.amplitude(); // Charge amplitude
416 
417  LogDebug("Phase2TrackerDigitizerAlgorithm") << " cloud " << v.position().x() << " " << v.position().y() << " "
418  << v.sigma_x() << " " << v.sigma_y() << " " << v.amplitude();
419 
420  // Find the maximum cloud spread in 2D plane , assume 3*sigma
421  float CloudRight = CloudCenterX + clusterWidth_ * SigmaX;
422  float CloudLeft = CloudCenterX - clusterWidth_ * SigmaX;
423  float CloudUp = CloudCenterY + clusterWidth_ * SigmaY;
424  float CloudDown = CloudCenterY - clusterWidth_ * SigmaY;
425 
426  // Define 2D cloud limit points
427  LocalPoint PointRightUp = LocalPoint(CloudRight, CloudUp);
428  LocalPoint PointLeftDown = LocalPoint(CloudLeft, CloudDown);
429 
430  // This points can be located outside the sensor area.
431  // The conversion to measurement point does not check for that
432  // so the returned pixel index might be wrong (outside range).
433  // We rely on the limits check below to fix this.
434  // But remember whatever we do here THE CHARGE OUTSIDE THE ACTIVE
435  // PIXEL ARE IS LOST, it should not be collected.
436 
437  // Convert the 2D points to pixel indices
438  MeasurementPoint mp = topol->measurementPosition(PointRightUp);
439  int IPixRightUpX = static_cast<int>(std::floor(mp.x())); // cast reqd.
440  int IPixRightUpY = static_cast<int>(std::floor(mp.y()));
441  LogDebug("Phase2TrackerDigitizerAlgorithm")
442  << " right-up " << PointRightUp << " " << mp.x() << " " << mp.y() << " " << IPixRightUpX << " " << IPixRightUpY;
443 
444  mp = topol->measurementPosition(PointLeftDown);
445  int IPixLeftDownX = static_cast<int>(std::floor(mp.x()));
446  int IPixLeftDownY = static_cast<int>(std::floor(mp.y()));
447  LogDebug("Phase2TrackerDigitizerAlgorithm") << " left-down " << PointLeftDown << " " << mp.x() << " " << mp.y()
448  << " " << IPixLeftDownX << " " << IPixLeftDownY;
449 
450  // Check detector limits to correct for pixels outside range.
451  int numColumns = topol->ncolumns(); // det module number of cols&rows
452  int numRows = topol->nrows();
453 
454  IPixRightUpX = numRows > IPixRightUpX ? IPixRightUpX : numRows - 1;
455  IPixRightUpY = numColumns > IPixRightUpY ? IPixRightUpY : numColumns - 1;
456  IPixLeftDownX = 0 < IPixLeftDownX ? IPixLeftDownX : 0;
457  IPixLeftDownY = 0 < IPixLeftDownY ? IPixLeftDownY : 0;
458 
459  // First integrate charge strips in x
460  hit_map_type x;
461  for (int ix = IPixLeftDownX; ix <= IPixRightUpX; ++ix) { // loop over x index
462  float xLB, LowerBound;
463  // Why is set to 0 if ix=0, does it meen that we accept charge
464  // outside the sensor?
465  if (ix == 0 || SigmaX == 0.) { // skip for surface segemnts
466  LowerBound = 0.;
467  } else {
468  mp = MeasurementPoint(ix, 0.0);
469  xLB = topol->localPosition(mp).x();
470  LowerBound = 1 - calcQ((xLB - CloudCenterX) / SigmaX);
471  }
472 
473  float xUB, UpperBound;
474  if (ix == numRows - 1 || SigmaX == 0.) {
475  UpperBound = 1.;
476  } else {
477  mp = MeasurementPoint(ix + 1, 0.0);
478  xUB = topol->localPosition(mp).x();
479  UpperBound = 1. - calcQ((xUB - CloudCenterX) / SigmaX);
480  }
481  float TotalIntegrationRange = UpperBound - LowerBound; // get strip
482  x.emplace(ix, TotalIntegrationRange); // save strip integral
483  }
484 
485  // Now integrate strips in y
486  hit_map_type y;
487  for (int iy = IPixLeftDownY; iy <= IPixRightUpY; ++iy) { // loop over y index
488  float yLB, LowerBound;
489  if (iy == 0 || SigmaY == 0.) {
490  LowerBound = 0.;
491  } else {
492  mp = MeasurementPoint(0.0, iy);
493  yLB = topol->localPosition(mp).y();
494  LowerBound = 1. - calcQ((yLB - CloudCenterY) / SigmaY);
495  }
496 
497  float yUB, UpperBound;
498  if (iy == numColumns - 1 || SigmaY == 0.) {
499  UpperBound = 1.;
500  } else {
501  mp = MeasurementPoint(0.0, iy + 1);
502  yUB = topol->localPosition(mp).y();
503  UpperBound = 1. - calcQ((yUB - CloudCenterY) / SigmaY);
504  }
505 
506  float TotalIntegrationRange = UpperBound - LowerBound;
507  y.emplace(iy, TotalIntegrationRange); // save strip integral
508  }
509 
510  // Get the 2D charge integrals by folding x and y strips
511  for (int ix = IPixLeftDownX; ix <= IPixRightUpX; ++ix) { // loop over x index
512  for (int iy = IPixLeftDownY; iy <= IPixRightUpY; ++iy) { // loop over y index
513  float ChargeFraction = Charge * x[ix] * y[iy];
514  int chanFired = -1;
515  if (ChargeFraction > 0.) {
516  chanFired =
517  pixelFlag_ ? PixelDigi::pixelToChannel(ix, iy) : Phase2TrackerDigi::pixelToChannel(ix, iy); // Get index
518  // Load the amplitude
519  hit_signal[chanFired] += ChargeFraction;
520  }
521 
522  mp = MeasurementPoint(ix, iy);
523  LocalPoint lp = topol->localPosition(mp);
524  int chan = topol->channel(lp);
525 
526  LogDebug("Phase2TrackerDigitizerAlgorithm")
527  << " pixel " << ix << " " << iy << " - "
528  << " " << chanFired << " " << ChargeFraction << " " << mp.x() << " " << mp.y() << " " << lp.x() << " "
529  << lp.y() << " " // givex edge position
530  << chan; // edge belongs to previous ?
531  }
532  }
533  }
534  // Fill the global map with all hit pixels from this event
535  float corr_time = hit.tof() - pixdet->surface().toGlobal(hit.localPosition()).mag() * c_inv;
536  for (auto const& hit_s : hit_signal) {
537  int chan = hit_s.first;
538  theSignal[chan] +=
539  (makeDigiSimLinks_ ? DigitizerUtility::Amplitude(hit_s.second, &hit, hit_s.second, corr_time, hitIndex, tofBin)
540  : DigitizerUtility::Amplitude(hit_s.second, nullptr, hit_s.second));
541  }
542 }

References _signal, LaserClient_cfi::Amplitude, c_inv, calcQ(), officialStyle::chan, Topology::channel(), PixelTestBeamValidation_cfi::Charge, clusterWidth_, GeomDet::geographicalId(), Topology::localPosition(), LogDebug, mag(), makeDigiSimLinks_, Topology::measurementPosition(), PixelTopology::ncolumns(), PixelTopology::nrows(), PixelTopology::pitch(), pixelFlag_, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), VtxSmearedParameters_cfi::SigmaX, VtxSmearedParameters_cfi::SigmaY, PixelGeomDetUnit::specificTopology(), GeomDet::surface(), Surface::toGlobal(), 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 SSDigitizerAlgorithm::accumulateSimHits(), PSPDigitizerAlgorithm::accumulateSimHits(), PSSDigitizerAlgorithm::accumulateSimHits(), and PixelDigitizerAlgorithm::accumulateSimHits().

◆ init()

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

Implemented in PixelDigitizerAlgorithm, Pixel3DDigitizerAlgorithm, PSPDigitizerAlgorithm, PSSDigitizerAlgorithm, and SSDigitizerAlgorithm.

◆ initializeEvent()

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

Definition at line 691 of file Phase2TrackerDigitizerAlgorithm.cc.

691  {
692  if (addNoise_ || addPixelInefficiency_ || fluctuateCharge_ || addThresholdSmearing_) {
693  gaussDistribution_ = std::make_unique<CLHEP::RandGaussQ>(eng, 0., theReadoutNoise_);
694  }
695  // Threshold smearing with gaussian distribution:
696  if (addThresholdSmearing_) {
697  smearedThreshold_Endcap_ =
698  std::make_unique<CLHEP::RandGaussQ>(eng, theThresholdInE_Endcap_, theThresholdSmearing_Endcap_);
699  smearedThreshold_Barrel_ =
700  std::make_unique<CLHEP::RandGaussQ>(eng, theThresholdInE_Barrel_, theThresholdSmearing_Barrel_);
701  }
702  rengine_ = &eng;
703  _signal.clear();
704 }

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

◆ isAboveThreshold()

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

Reimplemented in PixelDigitizerAlgorithm, PSPDigitizerAlgorithm, PSSDigitizerAlgorithm, and SSDigitizerAlgorithm.

Definition at line 78 of file Phase2TrackerDigitizerAlgorithm.h.

78 { return true; }

Referenced by digitize().

◆ loadAccumulator()

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

Definition at line 881 of file Phase2TrackerDigitizerAlgorithm.cc.

881  {
882  auto& theSignal = _signal[detId];
883  // the input channel is always with PixelDigi definition
884  // if needed, that has to be converted to Phase2TrackerDigi convention
885  for (const auto& elem : accumulator) {
886  auto inserted = theSignal.emplace(elem.first, DigitizerUtility::Amplitude(elem.second, nullptr));
887  if (!inserted.second) {
888  throw cms::Exception("LogicError") << "Signal was already set for DetId " << detId;
889  }
890  }
891 }

References _signal, mixOne_premix_on_sim_cfi::accumulator, and Exception.

◆ module_killing_conf()

void Phase2TrackerDigitizerAlgorithm::module_killing_conf ( uint32_t  detID)
protectedvirtual

Definition at line 788 of file Phase2TrackerDigitizerAlgorithm.cc.

788  {
789  bool isbad = false;
790  int detid = detID;
791  std::string Module;
792  for (auto const& det_m : deadModules_) {
793  int Dead_detID = det_m.getParameter<int>("Dead_detID");
794  Module = det_m.getParameter<std::string>("Module");
795  if (detid == Dead_detID) {
796  isbad = true;
797  break;
798  }
799  }
800 
801  if (!isbad)
802  return;
803 
804  signal_map_type& theSignal = _signal[detID]; // check validity
805  for (auto& s : theSignal) {
806  std::pair<int, int> ip;
807  if (pixelFlag_)
808  ip = PixelDigi::channelToPixel(s.first);
809  else
810  ip = Phase2TrackerDigi::channelToPixel(s.first); //get pixel pos
811 
812  if (Module == "whole" || (Module == "tbmA" && ip.first >= 80 && ip.first <= 159) ||
813  (Module == "tbmB" && ip.first <= 79))
814  s.second.set(0.);
815  }
816 }

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

Referenced by digitize().

◆ module_killing_DB()

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

Definition at line 818 of file Phase2TrackerDigitizerAlgorithm.cc.

818  {
819  bool isbad = false;
820  uint32_t detID = pixdet->geographicalId().rawId();
821  int ncol = pixdet->specificTopology().ncolumns();
822  if (ncol < 0)
823  return;
824  std::vector<SiPixelQuality::disabledModuleType> disabledModules = SiPixelBadModule_->getBadComponentList();
825 
826  SiPixelQuality::disabledModuleType badmodule;
827  for (size_t id = 0; id < disabledModules.size(); id++) {
828  if (detID == disabledModules[id].DetID) {
829  isbad = true;
830  badmodule = disabledModules[id];
831  break;
832  }
833  }
834 
835  if (!isbad)
836  return;
837 
838  signal_map_type& theSignal = _signal[detID]; // check validity
839  if (badmodule.errorType == 0) { // this is a whole dead module.
840  for (auto& s : theSignal)
841  s.second.set(0.); // reset amplitude
842  } else { // all other module types: half-modules and single ROCs.
843  // Get Bad ROC position:
844  // follow the example of getBadRocPositions in CondFormats/SiPixelObjects/src/SiPixelQuality.cc
845  std::vector<GlobalPixel> badrocpositions;
846  for (size_t j = 0; j < static_cast<size_t>(ncol); j++) {
847  if (SiPixelBadModule_->IsRocBad(detID, j)) {
848  std::vector<CablingPathToDetUnit> path = fedCablingMap_.product()->pathToDetUnit(detID);
849  for (auto const& p : path) {
850  const PixelROC* myroc = fedCablingMap_.product()->findItem(p);
851  if (myroc->idInDetUnit() == j) {
852  LocalPixel::RocRowCol local = {39, 25}; //corresponding to center of ROC row, col
853  GlobalPixel global = myroc->toGlobal(LocalPixel(local));
854  badrocpositions.push_back(global);
855  break;
856  }
857  }
858  }
859  }
860 
861  for (auto& s : theSignal) {
862  std::pair<int, int> ip;
863  if (pixelFlag_)
864  ip = PixelDigi::channelToPixel(s.first);
865  else
866  ip = Phase2TrackerDigi::channelToPixel(s.first);
867 
868  for (auto const& p : badrocpositions) {
869  for (auto& k : badPixels_) {
870  if (p.row == k.getParameter<int>("row") && ip.first == k.getParameter<int>("row") &&
871  std::abs(ip.second - p.col) < k.getParameter<int>("col")) {
872  s.second.set(0.);
873  }
874  }
875  }
876  }
877  }
878 }

References _signal, funct::abs(), badPixels_, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), SiPixelQuality::disabledModuleType::errorType, fedCablingMap_, SiPixelFedCablingMap::findItem(), GeomDet::geographicalId(), SiPixelQuality::getBadComponentList(), triggerObjects_cff::id, sipixelobjects::PixelROC::idInDetUnit(), SiPixelQuality::IsRocBad(), dqmiolumiharvest::j, dqmdumpme::k, DTRecHitClients_cfi::local, PixelTopology::ncolumns(), AlCaHLTBitMon_ParallelJobs::p, castor_dqm_sourceclient_file_cfg::path, SiPixelFedCablingMap::pathToDetUnit(), pixelFlag_, edm::ESHandle< T >::product(), DetId::rawId(), alignCSCRings::s, SiPixelBadModule_, PixelGeomDetUnit::specificTopology(), and sipixelobjects::PixelROC::toGlobal().

Referenced by digitize().

◆ pixel_inefficiency()

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

Definition at line 658 of file Phase2TrackerDigitizerAlgorithm.cc.

660  {
661  uint32_t detID = pixdet->geographicalId().rawId();
662  signal_map_type& theSignal = _signal[detID]; // check validity
663 
664  // Predefined efficiencies
665  float subdetEfficiency = 1.0;
666 
667  // setup the chip indices conversion
668  uint32_t Subid = DetId(detID).subdetId();
669  if (Subid == PixelSubdetector::PixelBarrel || Subid == StripSubdetector::TOB) { // barrel layers
670  uint32_t layerIndex = tTopo->pxbLayer(detID);
671  if (layerIndex - 1 < eff.barrel_efficiencies.size())
672  subdetEfficiency = eff.barrel_efficiencies[layerIndex - 1];
673  } else { // forward disks
674  uint32_t diskIndex = 2 * tTopo->pxfDisk(detID) - tTopo->pxfSide(detID);
675  if (diskIndex - 1 < eff.endcap_efficiencies.size())
676  subdetEfficiency = eff.endcap_efficiencies[diskIndex - 1];
677  }
678 
679  LogDebug("Phase2TrackerDigitizerAlgorithm") << " enter pixel_inefficiency " << subdetEfficiency;
680 
681  // Now loop again over pixels to kill some of them.
682  // Loop over hits, amplitude in electrons, channel = coded row,col
683  for (auto& s : theSignal) {
684  float rand = rengine_->flat();
685  if (rand > subdetEfficiency) {
686  // make amplitude =0
687  s.second.set(0.); // reset amplitude
688  }
689  }
690 }

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

Referenced by digitize().

◆ pixel_inefficiency_db()

void Phase2TrackerDigitizerAlgorithm::pixel_inefficiency_db ( uint32_t  detID)
protectedvirtual

Definition at line 767 of file Phase2TrackerDigitizerAlgorithm.cc.

767  {
768  signal_map_type& theSignal = _signal[detID]; // check validity
769 
770  // Loop over hit pixels, amplitude in electrons, channel = coded row,col
771  for (auto& s : theSignal) {
772  std::pair<int, int> ip;
773  if (pixelFlag_)
774  ip = PixelDigi::channelToPixel(s.first); //get pixel pos
775  else
776  ip = Phase2TrackerDigi::channelToPixel(s.first); //get pixel pos
777 
778  int row = ip.first; // X in row
779  int col = ip.second; // Y is in col
780  // transform to ROC index coordinates
781  if (theSiPixelGainCalibrationService_->isDead(detID, col, row))
782  s.second.set(0.); // reset amplitude
783  }
784 }

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

Referenced by digitize().

◆ primary_ionization()

void Phase2TrackerDigitizerAlgorithm::primary_ionization ( const PSimHit &  hit,
std::vector< DigitizerUtility::EnergyDepositUnit > &  ionization_points 
) const
protected

Definition at line 183 of file Phase2TrackerDigitizerAlgorithm.cc.

184  {
185  // Straight line approximation for trajectory inside active media
186  constexpr float SegmentLength = 0.0010; // in cm (10 microns)
187  // Get the 3D segment direction vector
188  LocalVector direction = hit.exitPoint() - hit.entryPoint();
189 
190  float eLoss = hit.energyLoss(); // Eloss in GeV
191  float length = direction.mag(); // Track length in Silicon
192 
193  int NumberOfSegments = static_cast<int>(length / SegmentLength); // Number of segments
194  if (NumberOfSegments < 1)
195  NumberOfSegments = 1;
196  LogDebug("Phase2TrackerDigitizerAlgorithm")
197  << "enter primary_ionzation " << NumberOfSegments << " shift = " << hit.exitPoint().x() - hit.entryPoint().x()
198  << " " << hit.exitPoint().y() - hit.entryPoint().y() << " " << hit.exitPoint().z() - hit.entryPoint().z() << " "
199  << hit.particleType() << " " << hit.pabs();
200 
201  std::vector<float> elossVector; // Eloss vector
202  elossVector.reserve(NumberOfSegments);
203  if (fluctuateCharge_) {
204  // Generate fluctuated charge points
205  fluctuateEloss(hit.particleType(), hit.pabs(), eLoss, length, NumberOfSegments, elossVector);
206  }
207  ionization_points.reserve(NumberOfSegments); // set size
208 
209  // loop over segments
210  for (size_t i = 0; i < elossVector.size(); ++i) {
211  // Divide the segment into equal length subsegments
212  Local3DPoint point = hit.entryPoint() + ((i + 0.5) / NumberOfSegments) * direction;
213  float energy = fluctuateCharge_ ? elossVector[i] / GeVperElectron_ // Convert charge to elec.
214  : eLoss / GeVperElectron_ / NumberOfSegments;
215 
216  DigitizerUtility::EnergyDepositUnit edu(energy, point); // define position,energy point
217  ionization_points.push_back(edu); // save
218  LogDebug("Phase2TrackerDigitizerAlgorithm")
219  << i << " " << edu.x() << " " << edu.y() << " " << edu.z() << " " << edu.energy();
220  }
221 }

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

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

◆ select_hit()

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

Reimplemented in PixelDigitizerAlgorithm, PSPDigitizerAlgorithm, PSSDigitizerAlgorithm, and SSDigitizerAlgorithm.

Definition at line 77 of file Phase2TrackerDigitizerAlgorithm.h.

77 { return true; }

Member Data Documentation

◆ _signal

signalMaps Phase2TrackerDigitizerAlgorithm::_signal
protected

Definition at line 106 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(), module_killing_DB(), pixel_inefficiency(), and pixel_inefficiency_db().

◆ addNoise_

const bool Phase2TrackerDigitizerAlgorithm::addNoise_
protected

Definition at line 155 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ addNoisyPixels_

const bool Phase2TrackerDigitizerAlgorithm::addNoisyPixels_
protected

Definition at line 156 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ addPixelInefficiency_

const bool Phase2TrackerDigitizerAlgorithm::addPixelInefficiency_
protected

Definition at line 160 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 162 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ addXtalk_

const bool Phase2TrackerDigitizerAlgorithm::addXtalk_
protected

Definition at line 124 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ alpha2Order_

const bool Phase2TrackerDigitizerAlgorithm::alpha2Order_
protected

Definition at line 123 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift(), and DriftDirection().

◆ badPixels_

Parameters Phase2TrackerDigitizerAlgorithm::badPixels_
protected

Definition at line 176 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_DB().

◆ clusterWidth_

const float Phase2TrackerDigitizerAlgorithm::clusterWidth_
protected

Definition at line 130 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by induce_signal().

◆ deadModules_

const Parameters Phase2TrackerDigitizerAlgorithm::deadModules_
protected

Definition at line 115 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_conf().

◆ fedCablingMap_

edm::ESHandle<SiPixelFedCablingMap> Phase2TrackerDigitizerAlgorithm::fedCablingMap_
protected

Definition at line 91 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_DB().

◆ fluctuate_

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

Definition at line 179 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by fluctuateEloss().

◆ fluctuateCharge_

const bool Phase2TrackerDigitizerAlgorithm::fluctuateCharge_
protected

Definition at line 157 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent(), and primary_ionization().

◆ gaussDistribution_

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

Definition at line 225 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise(), and initializeEvent().

◆ geom_

edm::ESHandle<TrackerGeometry> Phase2TrackerDigitizerAlgorithm::geom_
protected

Definition at line 92 of file Phase2TrackerDigitizerAlgorithm.h.

◆ GeVperElectron_

const float Phase2TrackerDigitizerAlgorithm::GeVperElectron_
protected

Definition at line 120 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 125 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_cross_talk().

◆ makeDigiSimLinks_

const bool Phase2TrackerDigitizerAlgorithm::makeDigiSimLinks_
protected

Definition at line 108 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ pixelFlag_

bool Phase2TrackerDigitizerAlgorithm::pixelFlag_
protected

Definition at line 241 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ pseudoRadDamage_

const double Phase2TrackerDigitizerAlgorithm::pseudoRadDamage_
protected

Definition at line 165 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ pseudoRadDamageRadius_

const double Phase2TrackerDigitizerAlgorithm::pseudoRadDamageRadius_
protected

Definition at line 166 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ rengine_

CLHEP::HepRandomEngine* Phase2TrackerDigitizerAlgorithm::rengine_
protected

Definition at line 232 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ Sigma0_

const float Phase2TrackerDigitizerAlgorithm::Sigma0_
protected

Definition at line 126 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

◆ SigmaCoeff_

const float Phase2TrackerDigitizerAlgorithm::SigmaCoeff_
protected

Definition at line 127 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

◆ SiPixelBadModule_

edm::ESHandle<SiPixelQuality> Phase2TrackerDigitizerAlgorithm::SiPixelBadModule_
protected

Definition at line 88 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_DB().

◆ SiPixelLorentzAngle_

edm::ESHandle<SiPixelLorentzAngle> Phase2TrackerDigitizerAlgorithm::SiPixelLorentzAngle_
protected

Definition at line 85 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ smearedThreshold_Barrel_

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

Definition at line 229 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ smearedThreshold_Endcap_

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

Definition at line 228 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and initializeEvent().

◆ subdetEfficiencies_

const SubdetEfficiencies Phase2TrackerDigitizerAlgorithm::subdetEfficiencies_
protected

Definition at line 222 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ tanLorentzAnglePerTesla_Barrel_

const float Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Barrel_
protected

Definition at line 152 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ tanLorentzAnglePerTesla_Endcap_

const float Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Endcap_
protected

Definition at line 151 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ theAdcFullScale_

const int Phase2TrackerDigitizerAlgorithm::theAdcFullScale_
protected

Definition at line 135 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 134 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ theHIPThresholdInE_Barrel_

const double Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Barrel_
protected

Definition at line 147 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ theHIPThresholdInE_Endcap_

const double Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Endcap_
protected

Definition at line 146 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ theNoiseInElectrons_

const float Phase2TrackerDigitizerAlgorithm::theNoiseInElectrons_
protected

Definition at line 136 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells().

◆ theNoiser_

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

Definition at line 180 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noisy_cells().

◆ thePhase2ReadoutMode_

const int Phase2TrackerDigitizerAlgorithm::thePhase2ReadoutMode_
protected

Definition at line 133 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by convertSignalToAdc().

◆ theReadoutNoise_

const float Phase2TrackerDigitizerAlgorithm::theReadoutNoise_
protected

Definition at line 137 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent().

◆ theSiPixelGainCalibrationService_

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

Definition at line 212 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by pixel_inefficiency_db().

◆ theThresholdInE_Barrel_

const float Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_
protected

Definition at line 141 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 140 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 144 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent().

◆ theThresholdSmearing_Endcap_

const double Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Endcap_
protected

Definition at line 143 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by initializeEvent().

◆ theTofLowerCut_

const float Phase2TrackerDigitizerAlgorithm::theTofLowerCut_
protected

Definition at line 149 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ theTofUpperCut_

const float Phase2TrackerDigitizerAlgorithm::theTofUpperCut_
protected

Definition at line 150 of file Phase2TrackerDigitizerAlgorithm.h.

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

◆ tMax_

const double Phase2TrackerDigitizerAlgorithm::tMax_
protected

Definition at line 173 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 112 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ use_ineff_from_db_

const bool Phase2TrackerDigitizerAlgorithm::use_ineff_from_db_
protected

Definition at line 110 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

◆ use_LorentzAngle_DB_

const bool Phase2TrackerDigitizerAlgorithm::use_LorentzAngle_DB_
protected

Definition at line 113 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ use_module_killing_

const bool Phase2TrackerDigitizerAlgorithm::use_module_killing_
protected

Definition at line 111 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

Vector3DBase< float, LocalTag >
Phase2TrackerDigitizerAlgorithm::addXtalk_
const bool addXtalk_
Definition: Phase2TrackerDigitizerAlgorithm.h:124
Phase2TrackerDigitizerAlgorithm::theNoiser_
const std::unique_ptr< GaussianTailNoiseGenerator > theNoiser_
Definition: Phase2TrackerDigitizerAlgorithm.h:180
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:100
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
Point2DBase
Definition: Point2DBase.h:9
Phase2TrackerDigitizerAlgorithm::calcQ
double calcQ(float x) const
Definition: Phase2TrackerDigitizerAlgorithm.h:237
Phase2TrackerDigitizerAlgorithm::makeDigiSimLinks_
const bool makeDigiSimLinks_
Definition: Phase2TrackerDigitizerAlgorithm.h:108
DDAxes::y
Phase2TrackerDigitizerAlgorithm::addNoisyPixels_
const bool addNoisyPixels_
Definition: Phase2TrackerDigitizerAlgorithm.h:156
Phase2TrackerDigitizerAlgorithm::add_noise
virtual void add_noise(const Phase2TrackerGeomDetUnit *pixdet)
Definition: Phase2TrackerDigitizerAlgorithm.cc:548
Phase2TrackerDigitizerAlgorithm::fluctuateCharge_
const bool fluctuateCharge_
Definition: Phase2TrackerDigitizerAlgorithm.h:157
Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_
const float theThresholdInE_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:141
mps_fire.i
i
Definition: mps_fire.py:355
Phase2TrackerDigitizerAlgorithm::pseudoRadDamage_
const double pseudoRadDamage_
Definition: Phase2TrackerDigitizerAlgorithm.h:165
Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Barrel_
const double theThresholdSmearing_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:144
Phase2TrackerDigitizerAlgorithm::subdetEfficiencies_
const SubdetEfficiencies subdetEfficiencies_
Definition: Phase2TrackerDigitizerAlgorithm.h:222
PixelSubdetector::PixelBarrel
Definition: PixelSubdetector.h:11
hit::y
double y
Definition: SiStripHitEffFromCalibTree.cc:90
Phase2TrackerDigitizerAlgorithm::pixel_inefficiency_db
virtual void pixel_inefficiency_db(uint32_t detID)
Definition: Phase2TrackerDigitizerAlgorithm.cc:767
Module
#define Module(md)
Definition: vmac.h:203
Phase2TrackerDigitizerAlgorithm::theTofUpperCut_
const float theTofUpperCut_
Definition: Phase2TrackerDigitizerAlgorithm.h:150
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
TrackerTopology::pxfSide
unsigned int pxfSide(const DetId &id) const
Definition: TrackerTopology.h:192
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
VtxSmearedParameters_cfi.SigmaX
SigmaX
Definition: VtxSmearedParameters_cfi.py:22
DigitizerUtility
Definition: DigitizerUtility.h:12
min
T min(T a, T b)
Definition: MathUtil.h:58
Phase2TrackerDigitizerAlgorithm::theNoiseInElectrons_
const float theNoiseInElectrons_
Definition: Phase2TrackerDigitizerAlgorithm.h:136
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
Phase2TrackerDigitizerAlgorithm::addThresholdSmearing_
const bool addThresholdSmearing_
Definition: Phase2TrackerDigitizerAlgorithm.h:162
cuy.col
col
Definition: cuy.py:1010
GaussianTailNoiseGenerator
Definition: GaussianTailNoiseGenerator.h:24
Phase2TrackerDigitizerAlgorithm::use_module_killing_
const bool use_module_killing_
Definition: Phase2TrackerDigitizerAlgorithm.h:111
SiPixelQuality::disabledModuleType
Definition: SiPixelQuality.h:29
PixelTopology::pitch
virtual std::pair< float, float > pitch() const =0
Phase2TrackerDigitizerAlgorithm::Sigma0_
const float Sigma0_
Definition: Phase2TrackerDigitizerAlgorithm.h:126
Phase2TrackerDigitizerAlgorithm::DriftDirection
LocalVector DriftDirection(const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield, const DetId &detId) const
Definition: Phase2TrackerDigitizerAlgorithm.cc:714
Phase2TrackerDigitizerAlgorithm::fedCablingMap_
edm::ESHandle< SiPixelFedCablingMap > fedCablingMap_
Definition: Phase2TrackerDigitizerAlgorithm.h:91
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:215
Phase2TrackerDigitizerAlgorithm::use_LorentzAngle_DB_
const bool use_LorentzAngle_DB_
Definition: Phase2TrackerDigitizerAlgorithm.h:113
info
static const TGPicture * info(bool iBackgroundIsBlack)
Definition: FWCollectionSummaryWidget.cc:152
SiPixelQuality::disabledModuleType::errorType
int errorType
Definition: SiPixelQuality.h:31
Topology::localPosition
virtual LocalPoint localPosition(const MeasurementPoint &) const =0
Phase2TrackerDigitizerAlgorithm::module_killing_conf
virtual void module_killing_conf(uint32_t detID)
Definition: Phase2TrackerDigitizerAlgorithm.cc:788
Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Endcap_
const double theThresholdSmearing_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:143
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
DDAxes::x
DigitizerUtility::Amplitude::simInfoList
const std::vector< std::pair< float, std::unique_ptr< SimHitInfo > > > & simInfoList() const
Definition: DigitizerUtility.h:49
align::LocalPoint
Point3DBase< Scalar, LocalTag > LocalPoint
Definition: Definitions.h:30
findQualityFiles.v
v
Definition: findQualityFiles.py:179
simKBmtfDigis_cfi.eLoss
eLoss
Definition: simKBmtfDigis_cfi.py:9
dqmdumpme.first
first
Definition: dqmdumpme.py:55
end
#define end
Definition: vmac.h:39
sipixelobjects::LocalPixel
identify pixel inside single ROC
Definition: LocalPixel.h:7
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
hit::x
double x
Definition: SiStripHitEffFromCalibTree.cc:89
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
Phase2TrackerDigitizerAlgorithm::alpha2Order_
const bool alpha2Order_
Definition: Phase2TrackerDigitizerAlgorithm.h:123
SiPixelLorentzAngle::getLorentzAngle
float getLorentzAngle(const uint32_t &) const
Definition: SiPixelLorentzAngle.cc:14
DigitizerUtility::EnergyDepositUnit
Definition: DigitizerUtility.h:75
Phase2TrackerDigitizerAlgorithm::theTofLowerCut_
const float theTofLowerCut_
Definition: Phase2TrackerDigitizerAlgorithm.h:149
DetId
Definition: DetId.h:17
Phase2TrackerDigitizerAlgorithm::module_killing_DB
virtual void module_killing_DB(const Phase2TrackerGeomDetUnit *pixdet)
Definition: Phase2TrackerDigitizerAlgorithm.cc:818
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
alignCSCRings.s
s
Definition: alignCSCRings.py:92
Phase2TrackerDigitizerAlgorithm::fluctuateEloss
void fluctuateEloss(int particleId, float momentum, float eloss, float length, int NumberOfSegments, std::vector< float > &elossVector) const
Definition: Phase2TrackerDigitizerAlgorithm.cc:228
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
sipixelobjects::GlobalPixel
global coordinates (row and column in DetUnit, as in PixelDigi)
Definition: GlobalPixel.h:6
Phase2TrackerDigitizerAlgorithm::theAdcFullScale_
const int theAdcFullScale_
Definition: Phase2TrackerDigitizerAlgorithm.h:135
Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Endcap_
const float tanLorentzAnglePerTesla_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:151
Phase2TrackerDigitizerAlgorithm::pseudoRadDamageRadius_
const double pseudoRadDamageRadius_
Definition: Phase2TrackerDigitizerAlgorithm.h:166
DigitizerUtility::Amplitude
Definition: DigitizerUtility.h:33
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
Topology::channel
virtual int channel(const LocalPoint &p) const =0
Surface::bounds
const Bounds & bounds() const
Definition: Surface.h:87
Surface::toGlobal
GlobalPoint toGlobal(const Point2DBase< Scalar, LocalTag > lp) const
Definition: Surface.h:79
Phase2TrackerDigitizerAlgorithm::addNoise_
const bool addNoise_
Definition: Phase2TrackerDigitizerAlgorithm.h:155
SiPixelFedCablingMap::pathToDetUnit
std::vector< sipixelobjects::CablingPathToDetUnit > pathToDetUnit(uint32_t rawDetId) const final
Definition: SiPixelFedCablingMap.cc:150
PixelTopology::ncolumns
virtual int ncolumns() const =0
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5
HcalDetIdTransform::transform
unsigned transform(const HcalDetId &id, unsigned transformCode)
Definition: HcalDetIdTransform.cc:7
Phase2TrackerDigitizerAlgorithm::smearedThreshold_Barrel_
std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:229
SiPixelGainCalibrationOfflineSimService
Definition: SiPixelGainCalibrationOfflineSimService.h:22
Phase2TrackerDigitizerAlgorithm::SiPixelBadModule_
edm::ESHandle< SiPixelQuality > SiPixelBadModule_
Definition: Phase2TrackerDigitizerAlgorithm.h:88
dqmdumpme.k
k
Definition: dqmdumpme.py:60
PixelDigi::pixelToChannel
static int pixelToChannel(int row, int col)
Definition: PixelDigi.h:71
Point3DBase< float, LocalTag >
PixelTopology
Definition: PixelTopology.h:10
particleFlowDisplacedVertex_cfi.ratio
ratio
Definition: particleFlowDisplacedVertex_cfi.py:93
hit::z
double z
Definition: SiStripHitEffFromCalibTree.cc:91
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::LogWarning
Definition: MessageLogger.h:141
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:674
MeasurementPoint
Measurement2DPoint MeasurementPoint
Measurement points are two-dimensional by default.
Definition: MeasurementPoint.h:12
funct::true
true
Definition: Factorize.h:173
ntuplemaker.fill
fill
Definition: ntuplemaker.py:304
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:64
Scenarios_cff.scale
scale
Definition: Scenarios_cff.py:2186
Bounds::thickness
virtual float thickness() const =0
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
Phase2TrackerDigitizerAlgorithm::pixelFlag_
bool pixelFlag_
Definition: Phase2TrackerDigitizerAlgorithm.h:241
Phase2TrackerDigitizerAlgorithm::tMax_
const double tMax_
Definition: Phase2TrackerDigitizerAlgorithm.h:173
PV2DBase::y
T y() const
Definition: PV2DBase.h:44
PixelGeomDetUnit::specificTopology
virtual const PixelTopology & specificTopology() const
Returns a reference to the pixel proxy topology.
Definition: PixelGeomDetUnit.cc:17
PV2DBase::x
T x() const
Definition: PV2DBase.h:43
hgcalDigitizer_cfi.noise
noise
Definition: hgcalDigitizer_cfi.py:150
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
LocalVector
Local3DVector LocalVector
Definition: LocalVector.h:12
Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Endcap_
const double theHIPThresholdInE_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:146
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:446
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
Phase2TrackerDigitizerAlgorithm::gaussDistribution_
std::unique_ptr< CLHEP::RandGaussQ > gaussDistribution_
Definition: Phase2TrackerDigitizerAlgorithm.h:225
Phase2TrackerDigi::channelToPixel
static std::pair< unsigned int, unsigned int > channelToPixel(unsigned int ch)
Definition: Phase2TrackerDigi.h:39
Phase2TrackerDigitizerAlgorithm::SiPixelLorentzAngle_
edm::ESHandle< SiPixelLorentzAngle > SiPixelLorentzAngle_
Definition: Phase2TrackerDigitizerAlgorithm.h:85
Phase2TrackerDigitizerAlgorithm::Frame
GloballyPositioned< double > Frame
Definition: Phase2TrackerDigitizerAlgorithm.h:102
Phase2TrackerDigitizerAlgorithm::theElectronPerADC_
const float theElectronPerADC_
Definition: Phase2TrackerDigitizerAlgorithm.h:134
Phase2TrackerDigitizerAlgorithm::GeVperElectron_
const float GeVperElectron_
Definition: Phase2TrackerDigitizerAlgorithm.h:120
rand
Signal rand(Signal arg)
Definition: vlib.cc:379
Topology::measurementPosition
virtual MeasurementPoint measurementPosition(const LocalPoint &) const =0
Phase2TrackerDigitizerAlgorithm::convertSignalToAdc
int convertSignalToAdc(uint32_t detID, float signal_in_elec, float threshold)
Definition: Phase2TrackerDigitizerAlgorithm.cc:968
sipixelobjects::PixelROC::toGlobal
GlobalPixel toGlobal(const LocalPixel &loc) const
Definition: PixelROC.h:55
GeomDet::specificSurface
const Plane & specificSurface() const
Same as surface(), kept for backward compatibility.
Definition: GeomDet.h:40
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap_
const float theThresholdInE_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:140
Phase2TrackerDigitizerAlgorithm::deadModules_
const Parameters deadModules_
Definition: Phase2TrackerDigitizerAlgorithm.h:115
cmsLHEtoEOSManager.l
l
Definition: cmsLHEtoEOSManager.py:193
SiPixelQuality::getBadComponentList
const std::vector< disabledModuleType > getBadComponentList() const
Definition: SiPixelQuality.h:100
DigitizerUtility::SimHitInfo
Definition: DigitizerUtility.h:14
Phase2TrackerDigitizerAlgorithm::use_deadmodule_DB_
const bool use_deadmodule_DB_
Definition: Phase2TrackerDigitizerAlgorithm.h:112
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:64
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Phase2TrackerDigitizerAlgorithm::isAboveThreshold
virtual bool isAboveThreshold(const DigitizerUtility::SimHitInfo *hitInfo, float charge, float thr)
Definition: Phase2TrackerDigitizerAlgorithm.h:78
Phase2TrackerDigitizerAlgorithm::_signal
signalMaps _signal
Definition: Phase2TrackerDigitizerAlgorithm.h:106
Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Barrel_
const float tanLorentzAnglePerTesla_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:152
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:36
mixOne_premix_on_sim_cfi.accumulator
accumulator
Definition: mixOne_premix_on_sim_cfi.py:167
mag
T mag() const
The vector magnitude. Equivalent to sqrt(vec.mag2())
Definition: Basic3DVectorLD.h:127
Phase2TrackerDigi
Definition: Phase2TrackerDigi.h:12
sipixelobjects::PixelROC
Definition: PixelROC.h:23
LaserClient_cfi.Amplitude
Amplitude
Definition: LaserClient_cfi.py:39
Phase2TrackerDigitizerAlgorithm::badPixels_
Parameters badPixels_
Definition: Phase2TrackerDigitizerAlgorithm.h:176
Phase2TrackerDigitizerAlgorithm::add_noisy_cells
virtual void add_noisy_cells(const Phase2TrackerGeomDetUnit *pixdet, float thePixelThreshold)
Definition: Phase2TrackerDigitizerAlgorithm.cc:613
heppy_batch.val
val
Definition: heppy_batch.py:351
Phase2TrackerDigitizerAlgorithm::add_cross_talk
virtual void add_cross_talk(const Phase2TrackerGeomDetUnit *pixdet)
Definition: Phase2TrackerDigitizerAlgorithm.cc:564
std
Definition: JetResolutionObject.h:76
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
VtxSmearedParameters_cfi.SigmaY
SigmaY
Definition: VtxSmearedParameters_cfi.py:21
sipixelobjects::LocalPixel::RocRowCol
row and collumn in ROC representation
Definition: LocalPixel.h:13
c_inv
constexpr double c_inv
Definition: Phase2TrackerDigitizerAlgorithm.h:56
Phase2TrackerDigitizerAlgorithm::clusterWidth_
const float clusterWidth_
Definition: Phase2TrackerDigitizerAlgorithm.h:130
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
officialStyle.chan
chan
lumi = TPaveText(lowX+0.38, lowY+0.061, lowX+0.45, lowY+0.161, "NDC") lumi.SetBorderSize( 0 ) lumi....
Definition: officialStyle.py:106
DigitizerUtility::SignalPoint
Definition: DigitizerUtility.h:96
Exception
Definition: hltDiff.cc:246
DigitizerUtility::DigiSimInfo
Definition: DigitizerUtility.h:127
Phase2TrackerDigitizerAlgorithm::theReadoutNoise_
const float theReadoutNoise_
Definition: Phase2TrackerDigitizerAlgorithm.h:137
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
PixelTestBeamValidation_cfi.Charge
Charge
Definition: PixelTestBeamValidation_cfi.py:78
Phase2TrackerDigitizerAlgorithm::interstripCoupling_
const float interstripCoupling_
Definition: Phase2TrackerDigitizerAlgorithm.h:125
Phase2TrackerDigitizerAlgorithm::fluctuate_
const std::unique_ptr< SiG4UniversalFluctuation > fluctuate_
Definition: Phase2TrackerDigitizerAlgorithm.h:179
Phase2TrackerDigitizerAlgorithm::theSiPixelGainCalibrationService_
const std::unique_ptr< SiPixelGainCalibrationOfflineSimService > theSiPixelGainCalibrationService_
Definition: Phase2TrackerDigitizerAlgorithm.h:212
Phase2TrackerDigitizerAlgorithm::thePhase2ReadoutMode_
const int thePhase2ReadoutMode_
Definition: Phase2TrackerDigitizerAlgorithm.h:133
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
Phase2TrackerDigitizerAlgorithm::use_ineff_from_db_
const bool use_ineff_from_db_
Definition: Phase2TrackerDigitizerAlgorithm.h:110
castor_dqm_sourceclient_file_cfg.path
path
Definition: castor_dqm_sourceclient_file_cfg.py:37
DTRecHitClients_cfi.local
local
Definition: DTRecHitClients_cfi.py:10
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
DigitizerUtility::Amplitude::ampl
float ampl() const
Definition: DigitizerUtility.h:48
SiPixelQuality::IsRocBad
bool IsRocBad(const uint32_t &detid, const short &rocNb) const
Definition: SiPixelQuality.cc:111
GloballyPositioned::rotation
const RotationType & rotation() const
Definition: GloballyPositioned.h:38
Phase2TrackerDigitizerAlgorithm::addPixelInefficiency_
const bool addPixelInefficiency_
Definition: Phase2TrackerDigitizerAlgorithm.h:160
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Barrel_
const double theHIPThresholdInE_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:147
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
remoteMonitoring_LED_IterMethod_cfg.threshold
threshold
Definition: remoteMonitoring_LED_IterMethod_cfg.py:426
PixelTopology::nrows
virtual int nrows() const =0
Parameters
vector< ParameterSet > Parameters
Definition: HLTMuonPlotter.cc:25
Phase2TrackerDigitizerAlgorithm::SigmaCoeff_
const float SigmaCoeff_
Definition: Phase2TrackerDigitizerAlgorithm.h:127
SiPixelFedCablingMap::findItem
const sipixelobjects::PixelROC * findItem(const sipixelobjects::CablingPathToDetUnit &path) const final
Definition: SiPixelFedCablingMap.cc:124
Phase2TrackerDigitizerAlgorithm::smearedThreshold_Endcap_
std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:228
Phase2TrackerDigitizerAlgorithm::rengine_
CLHEP::HepRandomEngine * rengine_
Definition: Phase2TrackerDigitizerAlgorithm.h:232
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
begin
#define begin
Definition: vmac.h:32
geometryCSVtoXML.xx
xx
Definition: geometryCSVtoXML.py:19
Phase2TrackerDigitizerAlgorithm::Parameters
std::vector< edm::ParameterSet > Parameters
Definition: Phase2TrackerDigitizerAlgorithm.h:103
hit
Definition: SiStripHitEffFromCalibTree.cc:88
Phase2TrackerDigitizerAlgorithm::pixel_inefficiency
virtual void pixel_inefficiency(const SubdetEfficiencies &eff, const Phase2TrackerGeomDetUnit *pixdet, const TrackerTopology *tTopo)
Definition: Phase2TrackerDigitizerAlgorithm.cc:658
sipixelobjects::PixelROC::idInDetUnit
unsigned int idInDetUnit() const
id of this ROC in DetUnit etermined by token path
Definition: PixelROC.h:37
PixelDigi::channelToPixel
static std::pair< int, int > channelToPixel(int ch)
Definition: PixelDigi.h:65
Generated for CMSSW Reference Manual by doxygen 1.8.16