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:
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 unsigned int 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 ()
 
 Phase2TrackerDigitizerAlgorithm (const edm::ParameterSet &conf_common, const edm::ParameterSet &conf_specific, CLHEP::HepRandomEngine &)
 
virtual ~Phase2TrackerDigitizerAlgorithm ()
 

Protected Types

using Frame = GloballyPositioned< double >
 
using Parameters = std::vector< edm::ParameterSet >
 
using signal_map_const_iterator = signal_map_type::const_iterator
 
using signal_map_iterator = signal_map_type::iterator
 
using signal_map_type = std::map< int, DigitizerUtility::Amplitude, std::less< int > >
 
using signalMaps = std::map< uint32_t, signal_map_type >
 
using simlink_map = std::map< unsigned int, std::vector< float >, std::less< unsigned int > >
 

Protected Member Functions

virtual void add_noise (const Phase2TrackerGeomDetUnit *pixdet, float thePixelThreshold)
 
double calcQ (float x) const
 
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 unsigned int tofBin, const Phase2TrackerGeomDetUnit *pixdet, const std::vector< DigitizerUtility::SignalPoint > &collection_points)
 
virtual void module_killing_conf (uint32_t detID)
 
virtual void module_killing_DB (uint32_t detID)
 
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
 
std::vector< edm::ParameterSet > badPixels
 
const float ClusterWidth
 
const Parameters DeadModules
 
const bool doDigitalReadout
 
const std::unique_ptr< CLHEP::RandFlat > flatDistribution_
 
const std::unique_ptr< SiG4UniversalFluctuation > fluctuate
 
const bool fluctuateCharge
 
const std::unique_ptr< CLHEP::RandGaussQ > gaussDistribution_
 
edm::ESHandle< TrackerGeometry > geom_
 
const float GeVperElectron
 
const float interstripCoupling
 
const bool makeDigiSimLinks_
 
edm::ESHandle< SiPixelFedCablingMap > map_
 
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_
 
const std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Barrel_
 
const 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 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 45 of file Phase2TrackerDigitizerAlgorithm.h.

Member Typedef Documentation

using Phase2TrackerDigitizerAlgorithm::Frame = GloballyPositioned<double>
protected

Definition at line 88 of file Phase2TrackerDigitizerAlgorithm.h.

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

Definition at line 89 of file Phase2TrackerDigitizerAlgorithm.h.

using Phase2TrackerDigitizerAlgorithm::signal_map_const_iterator = signal_map_type::const_iterator
protected

Definition at line 85 of file Phase2TrackerDigitizerAlgorithm.h.

using Phase2TrackerDigitizerAlgorithm::signal_map_iterator = signal_map_type::iterator
protected

Definition at line 84 of file Phase2TrackerDigitizerAlgorithm.h.

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

Definition at line 83 of file Phase2TrackerDigitizerAlgorithm.h.

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

Definition at line 87 of file Phase2TrackerDigitizerAlgorithm.h.

using Phase2TrackerDigitizerAlgorithm::simlink_map = std::map<unsigned int, std::vector<float>,std::less<unsigned int> >
protected

Definition at line 86 of file Phase2TrackerDigitizerAlgorithm.h.

Constructor & Destructor Documentation

Phase2TrackerDigitizerAlgorithm::Phase2TrackerDigitizerAlgorithm ( const edm::ParameterSet &  conf_common,
const edm::ParameterSet &  conf_specific,
CLHEP::HepRandomEngine &  eng 
)

Definition at line 59 of file Phase2TrackerDigitizerAlgorithm.cc.

References AddPixelInefficiency, theAdcFullScale, theElectronPerADC, theThresholdInE_Barrel, theThresholdInE_Endcap, and tMax.

61  :
62  _signal(),
63  makeDigiSimLinks_(conf_specific.getUntrackedParameter<bool>("makeDigiSimLinks", true)),
64  use_ineff_from_db_(conf_specific.getParameter<bool>("Inefficiency_DB")),
65  use_module_killing_(conf_specific.getParameter<bool>("KillModules")), // boolean to kill or not modules
66  use_deadmodule_DB_(conf_specific.getParameter<bool>("DeadModules_DB")), // boolean to access dead modules from DB
67  use_LorentzAngle_DB_(conf_specific.getParameter<bool>("LorentzAngle_DB")), // boolean to access Lorentz angle from DB
68 
69  DeadModules(use_deadmodule_DB_ ? Parameters() : conf_specific.getParameter<Parameters>("DeadModules")), // get dead module from cfg file
70 
71  // Common pixel parameters
72  // These are parameters which are not likely to be changed
73  GeVperElectron(3.61E-09), // 1 electron(3.61eV, 1keV(277e, mod 9/06 d.k.
74  alpha2Order(conf_specific.getParameter<bool>("Alpha2Order")), // switch on/off of E.B effect
75  addXtalk(conf_specific.getParameter<bool>("AddXTalk")),
76  interstripCoupling(conf_specific.getParameter<double>("InterstripCoupling")), // Interstrip Coupling
77 
78  Sigma0(conf_specific.getParameter<double>("SigmaZero")), // Charge diffusion constant 7->3.7
79  SigmaCoeff(conf_specific.getParameter<double>("SigmaCoeff")), // delta in the diffusion across the strip pitch
80  // (set between 0 to 0.9, 0-->flat Sigma0, 1-->Sigma_min=0 & Sigma_max=2*Sigma0
81  // D.B.: Dist300 replaced by moduleThickness, may not work with partially depleted sensors but works otherwise
82  // Dist300(0.0300), // normalized to 300micron Silicon
83 
84  ClusterWidth(conf_specific.getParameter<double>("ClusterWidth")), // Charge integration spread on the collection plane
85 
86  doDigitalReadout(conf_specific.getParameter<bool>("DigitalReadout")), // Flag to decide analog or digital readout
87 
88  // ADC calibration 1adc count(135e.
89  // Corresponds to 2adc/kev, 270[e/kev]/135[e/adc](2[adc/kev]
90  // Be careful, this parameter is also used in SiPixelDet.cc to
91  // calculate the noise in adc counts from noise in electrons.
92  // Both defaults should be the same.
93  theElectronPerADC(conf_specific.getParameter<double>("ElectronPerAdc")),
94 
95  // ADC saturation value, 255(8bit adc.
96  theAdcFullScale(conf_specific.getParameter<int>("AdcFullScale")),
97 
98  // Noise in electrons:
99  // Pixel cell noise, relevant for generating noisy pixels
100  theNoiseInElectrons(conf_specific.getParameter<double>("NoiseInElectrons")),
101 
102  // Fill readout noise, including all readout chain, relevant for smearing
103  theReadoutNoise(conf_specific.getParameter<double>("ReadoutNoiseInElec")),
104 
105  // Threshold in units of noise:
106  // thePixelThreshold(conf.getParameter<double>("ThresholdInNoiseUnits")),
107  // Pixel threshold in electron units.
108  theThresholdInE_Endcap(conf_specific.getParameter<double>("ThresholdInElectrons_Endcap")),
109  theThresholdInE_Barrel(conf_specific.getParameter<double>("ThresholdInElectrons_Barrel")),
110 
111  // Add threshold gaussian smearing:
112  theThresholdSmearing_Endcap(conf_specific.getParameter<double>("ThresholdSmearing_Endcap")),
113  theThresholdSmearing_Barrel(conf_specific.getParameter<double>("ThresholdSmearing_Barrel")),
114 
115  // Add HIP Threshold in electron units.
116  theHIPThresholdInE_Endcap(conf_specific.getParameter<double>("HIPThresholdInElectrons_Endcap")),
117  theHIPThresholdInE_Barrel(conf_specific.getParameter<double>("HIPThresholdInElectrons_Barrel")),
118 
119  // theTofCut 12.5, cut in particle TOD +/- 12.5ns
120  theTofLowerCut(conf_specific.getParameter<double>("TofLowerCut")),
121  theTofUpperCut(conf_specific.getParameter<double>("TofUpperCut")),
122 
123  // Get the Lorentz angle from the cfg file:
124  tanLorentzAnglePerTesla_Endcap(use_LorentzAngle_DB_ ? 0.0 : conf_specific.getParameter<double>("TanLorentzAnglePerTesla_Endcap")),
125  tanLorentzAnglePerTesla_Barrel(use_LorentzAngle_DB_ ? 0.0 : conf_specific.getParameter<double>("TanLorentzAnglePerTesla_Barrel")),
126 
127  // Add noise
128  addNoise(conf_specific.getParameter<bool>("AddNoise")),
129 
130  // Add noisy pixels
131  addNoisyPixels(conf_specific.getParameter<bool>("AddNoisyPixels")),
132 
133  // Fluctuate charge in track subsegments
134  fluctuateCharge(conf_specific.getUntrackedParameter<bool>("FluctuateCharge",true)),
135 
136  // Control the pixel inefficiency
137  AddPixelInefficiency(conf_specific.getParameter<bool>("AddInefficiency")),
138 
139  // Add threshold gaussian smearing:
140  addThresholdSmearing(conf_specific.getParameter<bool>("AddThresholdSmearing")),
141 
142  // Add some pseudo-red damage
143  pseudoRadDamage(conf_specific.exists("PseudoRadDamage")?conf_specific.getParameter<double>("PseudoRadDamage"):double(0.0)),
144  pseudoRadDamageRadius(conf_specific.exists("PseudoRadDamageRadius")?conf_specific.getParameter<double>("PseudoRadDamageRadius"):double(0.0)),
145 
146  // delta cutoff in MeV, has to be same as in OSCAR(0.030/cmsim=1.0 MeV
147  // tMax(0.030), // In MeV.
148  // tMax(conf.getUntrackedParameter<double>("DeltaProductionCut",0.030)),
149  tMax(conf_common.getParameter<double>("DeltaProductionCut")),
150 
151  badPixels(conf_specific.getParameter<std::vector<edm::ParameterSet> >("CellsToKill")),
152  fluctuate(fluctuateCharge ? new SiG4UniversalFluctuation() : nullptr),
153  theNoiser(addNoise ? new GaussianTailNoiseGenerator() : nullptr),
154  theSiPixelGainCalibrationService_(use_ineff_from_db_ ? new SiPixelGainCalibrationOfflineSimService(conf_specific) : nullptr),
155  subdetEfficiencies_(conf_specific),
156  flatDistribution_((addNoise || AddPixelInefficiency || fluctuateCharge || addThresholdSmearing) ? new CLHEP::RandFlat(eng, 0., 1.) : nullptr),
157  gaussDistribution_((addNoise || AddPixelInefficiency || fluctuateCharge || addThresholdSmearing) ? new CLHEP::RandGaussQ(eng, 0., theReadoutNoise) : nullptr),
158  // Threshold smearing with gaussian distribution:
159  smearedThreshold_Endcap_(addThresholdSmearing ? new CLHEP::RandGaussQ(eng, theThresholdInE_Endcap , theThresholdSmearing_Endcap) : nullptr),
160  smearedThreshold_Barrel_(addThresholdSmearing ? new CLHEP::RandGaussQ(eng, theThresholdInE_Barrel , theThresholdSmearing_Barrel) : nullptr),
161  rengine_(&eng)
162 {
163  LogInfo("Phase2TrackerDigitizerAlgorithm") << "Phase2TrackerDigitizerAlgorithm constructed\n"
164  << "Configuration parameters:\n"
165  << "Threshold/Gain = "
166  << "threshold in electron Endcap = "
167  << theThresholdInE_Endcap
168  << "\nthreshold in electron Barrel = "
169  << theThresholdInE_Barrel
170  << " " << theElectronPerADC << " " << theAdcFullScale
171  << " The delta cut-off is set to " << tMax
172  << " pix-inefficiency " << AddPixelInefficiency;
173 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
Phase2TrackerDigitizerAlgorithm::fluctuate
const std::unique_ptr< SiG4UniversalFluctuation > fluctuate
Definition: Phase2TrackerDigitizerAlgorithm.h:165
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:760
nullptr
#define nullptr
Phase2TrackerDigitizerAlgorithm::theSiPixelGainCalibrationService_
const std::unique_ptr< SiPixelGainCalibrationOfflineSimService > theSiPixelGainCalibrationService_
Definition: Phase2TrackerDigitizerAlgorithm.h:192
Parameters
vector< ParameterSet > Parameters
Definition: HLTMuonPlotter.cc:31
Phase2TrackerDigitizerAlgorithm::badPixels
std::vector< edm::ParameterSet > badPixels
Definition: Phase2TrackerDigitizerAlgorithm.h:162
Phase2TrackerDigitizerAlgorithm::smearedThreshold_Barrel_
const std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:208
Phase2TrackerDigitizerAlgorithm::smearedThreshold_Endcap_
const std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:207
Phase2TrackerDigitizerAlgorithm::Parameters
std::vector< edm::ParameterSet > Parameters
Definition: Phase2TrackerDigitizerAlgorithm.h:89
Phase2TrackerDigitizerAlgorithm::flatDistribution_
const std::unique_ptr< CLHEP::RandFlat > flatDistribution_
Definition: Phase2TrackerDigitizerAlgorithm.h:203
Phase2TrackerDigitizerAlgorithm::gaussDistribution_
const std::unique_ptr< CLHEP::RandGaussQ > gaussDistribution_
Definition: Phase2TrackerDigitizerAlgorithm.h:204
Phase2TrackerDigitizerAlgorithm::theNoiser
const std::unique_ptr< GaussianTailNoiseGenerator > theNoiser
Definition: Phase2TrackerDigitizerAlgorithm.h:166
Phase2TrackerDigitizerAlgorithm::~Phase2TrackerDigitizerAlgorithm ( )
virtual

Definition at line 175 of file Phase2TrackerDigitizerAlgorithm.cc.

References LogDebug.

175  {
176  LogDebug("Phase2TrackerDigitizerAlgorithm") << "Phase2TrackerDigitizerAlgorithm deleted";
177 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503

Member Function Documentation

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

Implemented in PSPDigitizerAlgorithm, PixelDigitizerAlgorithm, PSSDigitizerAlgorithm, and SSDigitizerAlgorithm.

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

Definition at line 596 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, addNoisyPixels, addXtalk, officialStyle::chan, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), gaussDistribution_, GeomDet::geographicalId(), createfilelist::int, interstripCoupling, checklumidiff::l, LogDebug, PixelTopology::ncolumns(), PixelTopology::nrows(), pixelFlag, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), rengine_, alignCSCRings::s, PixelGeomDetUnit::specificTopology(), theNoiseInElectrons, theNoiser, theThresholdInE_Barrel, and theThresholdInE_Endcap.

Referenced by digitize().

597  {
598  LogDebug("Phase2TrackerDigitizerAlgorithm") << " enter add_noise " << theNoiseInElectrons;
599  uint32_t detID = pixdet->geographicalId().rawId();
600  signal_map_type& theSignal = _signal[detID];
601  const Phase2TrackerTopology* topol = &pixdet->specificTopology();
602  int numColumns = topol->ncolumns(); // det module number of cols&rows
603  int numRows = topol->nrows();
604 
605  // First add Readout noise to hit cells
606  for (auto & s : theSignal) {
607  float noise = gaussDistribution_->fire();
608  if ((s.second.ampl() + noise) < 0.)
609  s.second.set(0);
610  else
611  s.second += noise;
612  }
613 
614  if (addXtalk) {
615  signal_map_type signalNew;
616  for (auto const & s : theSignal) {
617  float signalInElectrons = s.second.ampl(); // signal in electrons
618  std::pair<int,int> hitChan;
619  if (pixelFlag) hitChan = PixelDigi::channelToPixel(s.first);
620  else hitChan = Phase2TrackerDigi::channelToPixel(s.first);
621 
622  float signalInElectrons_Xtalk = signalInElectrons * interstripCoupling;
623 
624  if (hitChan.first != 0) {
625  std::pair<int,int> XtalkPrev = std::pair<int,int>(hitChan.first-1, hitChan.second);
626  int chanXtalkPrev = (pixelFlag) ? PixelDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second)
627  : Phase2TrackerDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second);
628  signalNew.insert(std::pair<int,DigitizerUtility::Amplitude>(chanXtalkPrev, DigitizerUtility::Amplitude(signalInElectrons_Xtalk, nullptr, -1.0)));
629  }
630  if (hitChan.first < (numRows-1)) {
631  std::pair<int,int> XtalkNext = std::pair<int,int>(hitChan.first+1, hitChan.second);
632  int chanXtalkNext = (pixelFlag) ? PixelDigi::pixelToChannel(XtalkNext.first, XtalkNext.second)
633  : Phase2TrackerDigi::pixelToChannel(XtalkNext.first, XtalkNext.second);
634  signalNew.insert(std::pair<int,DigitizerUtility::Amplitude>(chanXtalkNext, DigitizerUtility::Amplitude(signalInElectrons_Xtalk, nullptr, -1.0)));
635  }
636  }
637  for (auto const & l : signalNew) {
638  int chan = l.first;
639  auto iter = theSignal.find(chan);
640  if (iter != theSignal.end()) {
641  theSignal[chan] += l.second.ampl();
642  } else {
643  theSignal.insert(std::pair<int,DigitizerUtility::Amplitude>(chan, DigitizerUtility::Amplitude(l.second.ampl(), nullptr, -1.0)));
644  }
645  }
646  }
647  if (!addNoisyPixels) // Option to skip noise in non-hit pixels
648  return;
649 
650  // Add noise on non-hit pixels
651  // Use here the pixel noise
652  int numberOfPixels = numRows * numColumns;
653  std::map<int,float, std::less<int> > otherPixels;
654  std::map<int,float, std::less<int> >::iterator mapI;
655 
656  theNoiser->generate(numberOfPixels,
657  thePixelThreshold, //thr. in un. of nois
658  theNoiseInElectrons, // noise in elec.
659  otherPixels,
660  rengine_ );
661 
662  LogDebug("Phase2TrackerDigitizerAlgorithm")
663  << " Add noisy pixels " << numRows << " "
664  << numColumns << " " << theNoiseInElectrons << " "
665  << theThresholdInE_Endcap << " " << theThresholdInE_Barrel << " " << numberOfPixels << " "
666  << otherPixels.size() ;
667 
668  // Add noisy pixels
669  for (mapI = otherPixels.begin(); mapI!= otherPixels.end(); mapI++) {
670  int iy = ((*mapI).first) / numRows;
671  int ix = ((*mapI).first) - (iy*numRows);
672  // Keep for a while for testing.
673  if( iy < 0 || iy > (numColumns-1) )
674  LogWarning("Phase2TrackerDigitizerAlgorithm") << " error in iy " << iy;
675  if( ix < 0 || ix > (numRows-1) )
676  LogWarning("Phase2TrackerDigitizerAlgorithm") << " error in ix " << ix;
677 
678  int chan;
679  chan = (pixelFlag) ? PixelDigi::pixelToChannel(ix, iy) : Phase2TrackerDigi::pixelToChannel(ix, iy);
680 
681  LogDebug ("Phase2TrackerDigitizerAlgorithm")
682  <<" Storing noise = " << (*mapI).first << " " << (*mapI).second
683  << " " << ix << " " << iy << " " << chan ;
684 
685  if (theSignal[chan] == 0) {
686  int noise = int((*mapI).second);
687  theSignal[chan] = DigitizerUtility::Amplitude (noise, nullptr, -1.);
688  }
689  }
690 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
PixelTopology::nrows
virtual int nrows() const =0
PixelDigi::pixelToChannel
static int pixelToChannel(int row, int col)
Definition: PixelDigi.h:68
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
Phase2TrackerDigi::pixelToChannel
static PackedDigiType pixelToChannel(unsigned int row, unsigned int col)
Definition: Phase2TrackerDigi.h:45
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:79
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
PixelDigi::channelToPixel
static std::pair< int, int > channelToPixel(int ch)
Definition: PixelDigi.h:62
PixelGeomDetUnit::specificTopology
virtual const PixelTopology & specificTopology() const
Returns a reference to the pixel proxy topology.
Definition: PixelGeomDetUnit.cc:18
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
PixelTopology::ncolumns
virtual int ncolumns() const =0
Phase2TrackerDigitizerAlgorithm::gaussDistribution_
const std::unique_ptr< CLHEP::RandGaussQ > gaussDistribution_
Definition: Phase2TrackerDigitizerAlgorithm.h:204
Phase2TrackerDigitizerAlgorithm::theNoiser
const std::unique_ptr< GaussianTailNoiseGenerator > theNoiser
Definition: Phase2TrackerDigitizerAlgorithm.h:166
Phase2TrackerDigi::channelToPixel
static std::pair< unsigned int, unsigned int > channelToPixel(unsigned int ch)
Definition: Phase2TrackerDigi.h:41
double Phase2TrackerDigitizerAlgorithm::calcQ ( float  x) const
inlineprotected

Definition at line 213 of file Phase2TrackerDigitizerAlgorithm.h.

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

Referenced by induce_signal().

213  {
214  auto xx = std::min(0.5f * x * x,12.5f);
215  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));
216  }
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
min
T min(T a, T b)
Definition: MathUtil.h:58
void Phase2TrackerDigitizerAlgorithm::digitize ( const Phase2TrackerGeomDetUnit *  pixdet,
std::map< int, DigitizerUtility::DigiSimInfo > &  digi_map,
const TrackerTopology *  tTopo 
)
virtual

Definition at line 906 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, ecalMGPA::adc(), add_noise(), addNoise, AddPixelInefficiency, addThresholdSmearing, DigitizerUtility::Amplitude::ampl(), doDigitalReadout, GeomDet::geographicalId(), info(), checklumidiff::l, makeDigiSimLinks_, min(), module_killing_conf(), module_killing_DB(), DigitizerUtility::DigiSimInfo::ot_bit, pixel_inefficiency(), pixel_inefficiency_db(), PixelSubdetector::PixelBarrel, DetId::rawId(), alignCSCRings::s, DigitizerUtility::DigiSimInfo::sig_tot, DigitizerUtility::Amplitude::simInfoList(), DigitizerUtility::DigiSimInfo::simInfoList, smearedThreshold_Barrel_, smearedThreshold_Endcap_, subdetEfficiencies_, DetId::subdetId(), theAdcFullScale, theElectronPerADC, theHIPThresholdInE_Barrel, theHIPThresholdInE_Endcap, theNoiseInElectrons, theThresholdInE_Barrel, theThresholdInE_Endcap, StripSubdetector::TOB, use_deadmodule_DB_, use_ineff_from_db_, and use_module_killing_.

909 {
910  uint32_t detID = pixdet->geographicalId().rawId();
911  auto it = _signal.find(detID);
912  if (it == _signal.end()) return;
913 
914  const signal_map_type& theSignal = _signal[detID];
915 
916 
917  unsigned int Sub_detid = DetId(detID).subdetId();
918 
919  float theThresholdInE = 0.;
920  float theHIPThresholdInE = 0.;
921  // Define Threshold
922  if (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == StripSubdetector::TOB) { // Barrel modules
923  if (addThresholdSmearing) theThresholdInE = smearedThreshold_Barrel_->fire(); // gaussian smearing
924  else theThresholdInE = theThresholdInE_Barrel; // no smearing
925  theHIPThresholdInE = theHIPThresholdInE_Barrel;
926  } else { // Forward disks modules
927  if (addThresholdSmearing) theThresholdInE = smearedThreshold_Endcap_->fire(); // gaussian smearing
928  else theThresholdInE = theThresholdInE_Endcap; // no smearing
929  theHIPThresholdInE = theHIPThresholdInE_Endcap;
930  }
931 
932  if (addNoise) add_noise(pixdet, theThresholdInE/theNoiseInElectrons); // generate noise
933 
934  // Do only if needed
935  if (AddPixelInefficiency && !theSignal.empty()) {
936  if (use_ineff_from_db_)
937  pixel_inefficiency_db(detID);
938  else
939  pixel_inefficiency(subdetEfficiencies_, pixdet, tTopo);
940  }
941  if (use_module_killing_) {
942  if (use_deadmodule_DB_) // remove dead modules using DB
943  module_killing_DB(detID);
944  else // remove dead modules using the list in cfg file
945  module_killing_conf(detID);
946  }
947 
948  // Digitize if the signal is greater than threshold
949  for (auto const & s : theSignal) {
950  // DigitizerUtility::Amplitude sig_data = s.second;
951  const DigitizerUtility::Amplitude& sig_data = s.second;
952  float signalInElectrons = sig_data.ampl();
953  int adc;
954  if (signalInElectrons >= theThresholdInE) { // check threshold
955  if (doDigitalReadout) adc = theAdcFullScale;
956  else adc = std::min( int(signalInElectrons / theElectronPerADC), theAdcFullScale );
957  DigitizerUtility::DigiSimInfo info;
958  info.sig_tot = adc;
959  info.ot_bit = ( signalInElectrons > theHIPThresholdInE ? true : false);
960  if (makeDigiSimLinks_ ) {
961  for (auto const & l : sig_data.simInfoList()) {
962  float charge_frac = l.first/signalInElectrons;
963  if (l.first > -5.0) info.simInfoList.push_back({charge_frac, l.second.get()});
964  }
965  }
966  digi_map.insert({s.first, info});
967  }
968  }
969 }
ecalMGPA::adc
int adc(sample_type sample)
get the ADC sample (12 bits)
Definition: EcalMGPASample.h:11
info
static const TGPicture * info(bool iBackgroundIsBlack)
Definition: FWCollectionSummaryWidget.cc:170
Phase2TrackerDigitizerAlgorithm::add_noise
virtual void add_noise(const Phase2TrackerGeomDetUnit *pixdet, float thePixelThreshold)
Definition: Phase2TrackerDigitizerAlgorithm.cc:596
Phase2TrackerDigitizerAlgorithm::module_killing_conf
virtual void module_killing_conf(uint32_t detID)
Definition: Phase2TrackerDigitizerAlgorithm.cc:817
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:79
Phase2TrackerDigitizerAlgorithm::pixel_inefficiency_db
virtual void pixel_inefficiency_db(uint32_t detID)
Definition: Phase2TrackerDigitizerAlgorithm.cc:798
Phase2TrackerDigitizerAlgorithm::smearedThreshold_Barrel_
const std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Barrel_
Definition: Phase2TrackerDigitizerAlgorithm.h:208
min
T min(T a, T b)
Definition: MathUtil.h:58
DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
Phase2TrackerDigitizerAlgorithm::smearedThreshold_Endcap_
const std::unique_ptr< CLHEP::RandGaussQ > smearedThreshold_Endcap_
Definition: Phase2TrackerDigitizerAlgorithm.h:207
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
DetId
Definition: DetId.h:18
DigitizerUtility::DigiSimInfo::simInfoList
std::vector< std::pair< float, SimHitInfoForLinks * > > simInfoList
Definition: DigitizerUtility.h:109
Phase2TrackerDigitizerAlgorithm::pixel_inefficiency
virtual void pixel_inefficiency(const SubdetEfficiencies &eff, const Phase2TrackerGeomDetUnit *pixdet, const TrackerTopology *tTopo)
Definition: Phase2TrackerDigitizerAlgorithm.cc:696
DigitizerUtility::Amplitude::simInfoList
const std::vector< std::pair< float, std::unique_ptr< SimHitInfoForLinks > > > & simInfoList() const
Definition: DigitizerUtility.h:28
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 308 of file Phase2TrackerDigitizerAlgorithm.cc.

References alpha2Order, Surface::bounds(), funct::cos(), PSimHit::detUnitId(), DriftDirection(), JetChargeProducer_cfi::exp, mps_fire::i, LogDebug, M_PI, PV3DBase< T, PVType, FrameType >::perp(), PixelTopology::pitch(), GloballyPositioned< T >::position(), pseudoRadDamage, pseudoRadDamageRadius, Sigma0, SigmaCoeff, GeomDet::specificSurface(), PixelGeomDetUnit::specificTopology(), mathSSE::sqrt(), GeomDet::surface(), Bounds::thickness(), PSimHit::tof(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

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

312  {
313  LogDebug("Phase2TrackerDigitizerAlgorithm") << "enter drift ";
314 
315  collection_points.resize(ionization_points.size()); // set size
316  LocalVector driftDir = DriftDirection(pixdet, bfield, hit.detUnitId()); // get the charge drift direction
317  if (driftDir.z() == 0.) {
318  LogWarning("Phase2TrackerDigitizerAlgorithm") << " pxlx: drift in z is zero ";
319  return;
320  }
321 
322  float TanLorenzAngleX,
323  TanLorenzAngleY,
324  dir_z,
325  CosLorenzAngleX,
326  CosLorenzAngleY;
327  if (alpha2Order) {
328  TanLorenzAngleX = driftDir.x(); // tangen of Lorentz angle
329  TanLorenzAngleY = driftDir.y();
330  dir_z = driftDir.z(); // The z drift direction
331  CosLorenzAngleX = 1./std::sqrt(1. + TanLorenzAngleX * TanLorenzAngleX); // cosine
332  CosLorenzAngleY = 1./std::sqrt(1. + TanLorenzAngleY * TanLorenzAngleY); // cosine;
333  }
334  else {
335  TanLorenzAngleX = driftDir.x();
336  TanLorenzAngleY = 0.; // force to 0, driftDir.y()/driftDir.z();
337  dir_z = driftDir.z(); // The z drift direction
338  CosLorenzAngleX = 1./std::sqrt(1. + TanLorenzAngleX * TanLorenzAngleX); // cosine to estimate the path length
339  CosLorenzAngleY = 1.;
340  }
341 
342  float moduleThickness = pixdet->specificSurface().bounds().thickness();
343  float stripPitch = pixdet->specificTopology().pitch().first;
344 
345  LogDebug("Phase2TrackerDigitizerAlgorithm")
346  << " Lorentz Tan " << TanLorenzAngleX << " " << TanLorenzAngleY <<" "
347  << CosLorenzAngleX << " " << CosLorenzAngleY << " "
348  << moduleThickness*TanLorenzAngleX << " " << driftDir;
349 
350  float Sigma_x = 1.; // Charge spread
351  float Sigma_y = 1.;
352  float DriftDistance; // Distance between charge generation and collection
353  float DriftLength; // Actual Drift Lentgh
354  float Sigma;
355 
356  for (unsigned int i = 0; i != ionization_points.size(); ++i) {
357  float SegX, SegY, SegZ; // position
358  SegX = ionization_points[i].x();
359  SegY = ionization_points[i].y();
360  SegZ = ionization_points[i].z();
361 
362  // Distance from the collection plane
363  // DriftDistance = (moduleThickness/2. + SegZ); // Drift to -z
364  // Include explixitely the E drift direction (for CMS dir_z=-1)
365  DriftDistance = moduleThickness/2. - (dir_z * SegZ); // Drift to -z
366 
367  if (DriftDistance < 0.)
368  DriftDistance = 0.;
369  else if (DriftDistance > moduleThickness)
370  DriftDistance = moduleThickness;
371 
372  // Assume full depletion now, partial depletion will come later.
373  float XDriftDueToMagField = DriftDistance * TanLorenzAngleX;
374  float YDriftDueToMagField = DriftDistance * TanLorenzAngleY;
375 
376  // Shift cloud center
377  float CloudCenterX = SegX + XDriftDueToMagField;
378  float CloudCenterY = SegY + YDriftDueToMagField;
379 
380  // Calculate how long is the charge drift path
381  DriftLength = std::sqrt(DriftDistance*DriftDistance +
382  XDriftDueToMagField*XDriftDueToMagField +
383  YDriftDueToMagField*YDriftDueToMagField);
384 
385  // What is the charge diffusion after this path
386  // Sigma0=0.00037 is for 300um thickness (make sure moduleThickness is in [cm])
387  Sigma = std::sqrt(DriftLength/moduleThickness) * (Sigma0 * moduleThickness/0.0300);
388  // D.B.: sigmaCoeff=0 means no modulation
389  if (SigmaCoeff) Sigma *= (SigmaCoeff * cos(SegX*M_PI/stripPitch) * cos(SegX*M_PI/stripPitch) + 1);
390  // NB: divided by 4 to get a periodicity of stripPitch
391 
392  // Project the diffusion sigma on the collection plane
393  Sigma_x = Sigma / CosLorenzAngleX;
394  Sigma_y = Sigma / CosLorenzAngleY;
395 
396  // Insert a charge loss due to Rad Damage here
397  float energyOnCollector = ionization_points[i].energy(); // The energy that reaches the collector
398 
399  // pseudoRadDamage
400  if (pseudoRadDamage >= 0.001) {
401  float moduleRadius = pixdet->surface().position().perp();
402  if (moduleRadius <= pseudoRadDamageRadius) {
403  float kValue = pseudoRadDamage/(moduleRadius * moduleRadius);
404  energyOnCollector = energyOnCollector * exp(-1 * kValue * DriftDistance/moduleThickness);
405  }
406  }
407  LogDebug("Phase2TrackerDigitizerAlgorithm")
408  << "Dift DistanceZ = " << DriftDistance << " module thickness = " << moduleThickness
409  << " Start Energy = " << ionization_points[i].energy() << " Energy after loss= " << energyOnCollector;
410  DigitizerUtility::SignalPoint sp(CloudCenterX, CloudCenterY, Sigma_x, Sigma_y, hit.tof(), energyOnCollector);
411  // Load the Charge distribution parameters
412  collection_points[i] = sp;
413  }
414 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
Phase2TrackerDigitizerAlgorithm::DriftDirection
LocalVector DriftDirection(const Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield, const DetId &detId) const
Definition: Phase2TrackerDigitizerAlgorithm.cc:737
PSimHit::tof
float tof() const
deprecated name for timeOfFlight()
Definition: PSimHit.h:72
mps_fire.i
i
Definition: mps_fire.py:269
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:72
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
PixelTopology::pitch
virtual std::pair< float, float > pitch() const =0
Surface::bounds
const Bounds & bounds() const
Definition: Surface.h:120
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:42
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:51
Bounds::thickness
virtual float thickness() const =0
PixelGeomDetUnit::specificTopology
virtual const PixelTopology & specificTopology() const
Returns a reference to the pixel proxy topology.
Definition: PixelGeomDetUnit.cc:18
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:42
PSimHit::detUnitId
unsigned int detUnitId() const
Definition: PSimHit.h:93
GeomDet::specificSurface
const Plane & specificSurface() const
Same as surface(), kept for backward compatibility.
Definition: GeomDet.h:45
LocalVector Phase2TrackerDigitizerAlgorithm::DriftDirection ( const Phase2TrackerGeomDetUnit *  pixdet,
const GlobalVector &  bfield,
const DetId &  detId 
) const
protected

Definition at line 737 of file Phase2TrackerDigitizerAlgorithm.cc.

References alpha2Order, GeomDet::geographicalId(), SiPixelLorentzAngle::getLorentzAngle(), LogDebug, PixelSubdetector::PixelBarrel, GloballyPositioned< T >::position(), 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().

739  {
740  Frame detFrame(pixdet->surface().position(),pixdet->surface().rotation());
741  LocalVector Bfield = detFrame.toLocal(bfield);
742  float alpha2_Endcap;
743  float alpha2_Barrel;
744  float alpha2;
745 
746  float dir_x = 0.0;
747  float dir_y = 0.0;
748  float dir_z = 0.0;
749  float scale = 0.0;
750 
751  uint32_t detID = pixdet->geographicalId().rawId();
752  unsigned int Sub_detid = DetId(detID).subdetId();
753 
754  // Read Lorentz angle from cfg file:
755  if (!use_LorentzAngle_DB_) {
756  if (alpha2Order) {
757  alpha2_Endcap = tanLorentzAnglePerTesla_Endcap*tanLorentzAnglePerTesla_Endcap;
758  alpha2_Barrel = tanLorentzAnglePerTesla_Barrel*tanLorentzAnglePerTesla_Barrel;
759  } else {
760  alpha2_Endcap = 0.0;
761  alpha2_Barrel = 0.0;
762  }
763 
764  if (Sub_detid == PixelSubdetector::PixelBarrel || Sub_detid == StripSubdetector::TOB) { // barrel layers
765  dir_x = -( tanLorentzAnglePerTesla_Barrel * Bfield.y() + alpha2_Barrel* Bfield.z()* Bfield.x() );
766  dir_y = +( tanLorentzAnglePerTesla_Barrel * Bfield.x() - alpha2_Barrel* Bfield.z()* Bfield.y() );
767  dir_z = -(1 + alpha2_Barrel* Bfield.z()*Bfield.z() );
768  scale = (1 + alpha2_Barrel* Bfield.z()*Bfield.z() );
769 
770  } else { // forward disks
771  dir_x = -( tanLorentzAnglePerTesla_Endcap * Bfield.y() + alpha2_Endcap* Bfield.z()* Bfield.x() );
772  dir_y = +( tanLorentzAnglePerTesla_Endcap * Bfield.x() - alpha2_Endcap* Bfield.z()* Bfield.y() );
773  dir_z = -(1 + alpha2_Endcap* Bfield.z()*Bfield.z() );
774  scale = (1 + alpha2_Endcap* Bfield.z()*Bfield.z() );
775  }
776  }
777 
778  // Read Lorentz angle from DB:
779  if (use_LorentzAngle_DB_) {
780  float lorentzAngle = SiPixelLorentzAngle_->getLorentzAngle(detId);
781  alpha2 = lorentzAngle * lorentzAngle;
782 
783  dir_x = -( lorentzAngle * Bfield.y() + alpha2 * Bfield.z()* Bfield.x() );
784  dir_y = +( lorentzAngle * Bfield.x() - alpha2 * Bfield.z()* Bfield.y() );
785  dir_z = -(1 + alpha2 * Bfield.z()*Bfield.z() );
786  scale = (1 + alpha2 * Bfield.z()*Bfield.z() );
787  }
788 
789  LocalVector theDriftDirection = LocalVector(dir_x/scale, dir_y/scale, dir_z/scale );
790 
791  LogDebug ("Phase2TrackerDigitizerAlgorithm") << " The drift direction in local coordinate is "
792  << theDriftDirection ;
793  return theDriftDirection;
794 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
LocalVector
Local3DVector LocalVector
Definition: LocalVector.h:12
Scenarios_cff.scale
scale
Definition: Scenarios_cff.py:2190
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:42
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
Phase2TrackerDigitizerAlgorithm::SiPixelLorentzAngle_
edm::ESHandle< SiPixelLorentzAngle > SiPixelLorentzAngle_
Definition: Phase2TrackerDigitizerAlgorithm.h:68
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:79
DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
DetId
Definition: DetId.h:18
SiPixelLorentzAngle::getLorentzAngle
float getLorentzAngle(const uint32_t &) const
Definition: SiPixelLorentzAngle.cc:13
GloballyPositioned::rotation
const RotationType & rotation() const
Definition: GloballyPositioned.h:44
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:42
void Phase2TrackerDigitizerAlgorithm::fluctuateEloss ( int  particleId,
float  momentum,
float  eloss,
float  length,
int  NumberOfSegments,
std::vector< float > &  elossVector 
) const
protected

Definition at line 248 of file Phase2TrackerDigitizerAlgorithm.cc.

References funct::abs(), fluctuate, mps_fire::i, cuy::ii, particleFlowDisplacedVertex_cfi::ratio, rengine_, and tMax.

Referenced by primary_ionization().

253  {
254 
255  // Get dedx for this track
256  //float dedx;
257  //if( length > 0.) dedx = eloss/length;
258  //else dedx = eloss;
259 
260  double particleMass = 139.6; // Mass in MeV, Assume pion
261  pid = std::abs(pid);
262  if (pid != 211) { // Mass in MeV
263  if (pid == 11) particleMass = 0.511;
264  else if (pid == 13) particleMass = 105.7;
265  else if (pid == 321) particleMass = 493.7;
266  else if (pid == 2212) particleMass = 938.3;
267  }
268  // What is the track segment length.
269  float segmentLength = length/NumberOfSegs;
270 
271  // Generate charge fluctuations.
272  float de = 0.;
273  float sum = 0.;
274  double segmentEloss = (1000. * eloss)/NumberOfSegs; //eloss in MeV
275  for (int i = 0; i < NumberOfSegs; ++i) {
276  // material,*, momentum,energy,*, *, mass
277  //myglandz_(14.,segmentLength,2.,2.,dedx,de,0.14);
278  // The G4 routine needs momentum in MeV, mass in Mev, delta-cut in MeV,
279  // track segment length in mm, segment eloss in MeV
280  // Returns fluctuated eloss in MeV
281  double deltaCutoff = tMax; // the cutoff is sometimes redefined inside, so fix it.
282  de = fluctuate->SampleFluctuations(static_cast<double>(particleMomentum*1000.),
283  particleMass, deltaCutoff,
284  static_cast<double>(segmentLength*10.),
285  segmentEloss,
286  rengine_ )/1000.; //convert to GeV
287  elossVector.push_back(de);
288  sum += de;
289  }
290  if (sum > 0.) { // If fluctuations give eloss>0.
291  // Rescale to the same total eloss
292  float ratio = eloss/sum;
293  for (int ii = 0; ii < NumberOfSegs; ++ii) elossVector[ii] = ratio*elossVector[ii];
294  }
295  else { // If fluctuations gives 0 eloss
296  float averageEloss = eloss/NumberOfSegs;
297  for (int ii = 0; ii < NumberOfSegs; ++ii) elossVector[ii] = averageEloss;
298  }
299 
300 }
mps_fire.i
i
Definition: mps_fire.py:269
particleFlowDisplacedVertex_cfi.ratio
ratio
Definition: particleFlowDisplacedVertex_cfi.py:93
Phase2TrackerDigitizerAlgorithm::fluctuate
const std::unique_ptr< SiG4UniversalFluctuation > fluctuate
Definition: Phase2TrackerDigitizerAlgorithm.h:165
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
cuy.ii
ii
Definition: cuy.py:588
void Phase2TrackerDigitizerAlgorithm::induce_signal ( const PSimHit &  hit,
const size_t  hitIndex,
const unsigned int  tofBin,
const Phase2TrackerGeomDetUnit *  pixdet,
const std::vector< DigitizerUtility::SignalPoint > &  collection_points 
)
protected

Definition at line 419 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, calcQ(), officialStyle::chan, Topology::channel(), ClusterWidth, GeomDet::geographicalId(), createfilelist::int, Topology::localPosition(), LogDebug, makeDigiSimLinks_, Topology::measurementPosition(), PixelTopology::ncolumns(), PixelTopology::nrows(), PixelTopology::pitch(), pixelFlag, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), gun_cff::SigmaX, gun_cff::SigmaY, PixelGeomDetUnit::specificTopology(), 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 PixelDigitizerAlgorithm::accumulateSimHits(), SSDigitizerAlgorithm::accumulateSimHits(), PSSDigitizerAlgorithm::accumulateSimHits(), and PSPDigitizerAlgorithm::accumulateSimHits().

423  {
424 
425  // X - Rows, Left-Right, 160, (1.6cm) for barrel
426  // Y - Columns, Down-Up, 416, (6.4cm)
427  const Phase2TrackerTopology* topol = &pixdet->specificTopology();
428  uint32_t detID = pixdet->geographicalId().rawId();
429  signal_map_type& theSignal = _signal[detID];
430 
431  LogDebug("Phase2TrackerDigitizerAlgorithm")
432  << " enter induce_signal, "
433  << topol->pitch().first << " " << topol->pitch().second; //OK
434 
435  // local map to store pixels hit by 1 Hit.
436  using hit_map_type = std::map<int, float, std::less<int> >;
437  hit_map_type hit_signal;
438 
439  // map to store pixel integrals in the x and in the y directions
440  std::map<int, float, std::less<int> > x,y;
441 
442  // Assign signals to readout channels and store sorted by channel number
443  int iseg = 0;
444  float ESum = 0.0;
445 
446  // Iterate over collection points on the collection plane
447  for (auto const & v : collection_points) {
448  iseg++;
449  float CloudCenterX = v.position().x(); // Charge position in x
450  float CloudCenterY = v.position().y(); // in y
451  float SigmaX = v.sigma_x(); // Charge spread in x
452  float SigmaY = v.sigma_y(); // in y
453  float Charge = v.amplitude(); // Charge amplitude
454 
455  LogDebug("Phase2TrackerDigitizerAlgorithm")
456  << " cloud " << v.position().x() << " " << v.position().y() << " "
457  << v.sigma_x() << " " << v.sigma_y() << " " << v.amplitude();
458 
459  // Find the maximum cloud spread in 2D plane , assume 3*sigma
460  float CloudRight = CloudCenterX + ClusterWidth * SigmaX;
461  float CloudLeft = CloudCenterX - ClusterWidth * SigmaX;
462  float CloudUp = CloudCenterY + ClusterWidth * SigmaY;
463  float CloudDown = CloudCenterY - ClusterWidth * SigmaY;
464 
465  // Define 2D cloud limit points
466  LocalPoint PointRightUp = LocalPoint(CloudRight,CloudUp);
467  LocalPoint PointLeftDown = LocalPoint(CloudLeft,CloudDown);
468 
469  // This points can be located outside the sensor area.
470  // The conversion to measurement point does not check for that
471  // so the returned pixel index might be wrong (outside range).
472  // We rely on the limits check below to fix this.
473  // But remember whatever we do here THE CHARGE OUTSIDE THE ACTIVE
474  // PIXEL ARE IS LOST, it should not be collected.
475 
476  // Convert the 2D points to pixel indices
477  MeasurementPoint mp = topol->measurementPosition(PointRightUp ); //OK
478 
479  int IPixRightUpX = int(floor( mp.x()));
480  int IPixRightUpY = int(floor( mp.y()));
481 
482  LogDebug("Phase2TrackerDigitizerAlgorithm") << " right-up " << PointRightUp << " "
483  << mp.x() << " " << mp.y() << " "
484  << IPixRightUpX << " " << IPixRightUpY ;
485 
486  mp = topol->measurementPosition(PointLeftDown); // OK
487 
488  int IPixLeftDownX = int(floor( mp.x()));
489  int IPixLeftDownY = int(floor( mp.y()));
490 
491  LogDebug("Phase2TrackerDigitizerAlgorithm") << " left-down " << PointLeftDown << " "
492  << mp.x() << " " << mp.y() << " "
493  << IPixLeftDownX << " " << IPixLeftDownY ;
494 
495  // Check detector limits to correct for pixels outside range.
496  int numColumns = topol->ncolumns(); // det module number of cols&rows
497  int numRows = topol->nrows();
498 
499  IPixRightUpX = numRows > IPixRightUpX ? IPixRightUpX : numRows-1;
500  IPixRightUpY = numColumns > IPixRightUpY ? IPixRightUpY : numColumns-1;
501  IPixLeftDownX = 0 < IPixLeftDownX ? IPixLeftDownX : 0;
502  IPixLeftDownY = 0 < IPixLeftDownY ? IPixLeftDownY : 0;
503 
504  x.clear(); // clear temporary integration array
505  y.clear();
506 
507  // First integrate cahrge strips in x
508  int ix; // TT for compatibility
509  for (ix = IPixLeftDownX; ix <= IPixRightUpX; ix++) { // loop over x index
510  float xUB, xLB, UpperBound, LowerBound;
511 
512  // Why is set to 0 if ix=0, does it meen that we accept charge
513  // outside the sensor?
514  if (ix == 0 || SigmaX==0.) // skip for surface segemnts
515  LowerBound = 0.;
516  else {
517  mp = MeasurementPoint( float(ix), 0.0);
518  xLB = topol->localPosition(mp).x();
519  LowerBound = 1-calcQ((xLB-CloudCenterX)/SigmaX);
520  }
521 
522  if (ix == numRows-1 || SigmaX == 0.)
523  UpperBound = 1.;
524  else {
525  mp = MeasurementPoint(float(ix+1), 0.0);
526  xUB = topol->localPosition(mp).x();
527  UpperBound = 1. - calcQ((xUB-CloudCenterX)/SigmaX);
528  }
529  float TotalIntegrationRange = UpperBound - LowerBound; // get strip
530  x[ix] = TotalIntegrationRange; // save strip integral
531  }
532 
533  // Now integarte strips in y
534  int iy; // TT for compatibility
535  for (iy = IPixLeftDownY; iy <= IPixRightUpY; iy++) { //loope over y ind
536  float yUB, yLB, UpperBound, LowerBound;
537 
538  if (iy == 0 || SigmaY==0.)
539  LowerBound = 0.;
540  else {
541  mp = MeasurementPoint(0.0, float(iy));
542  yLB = topol->localPosition(mp).y();
543  LowerBound = 1. - calcQ((yLB-CloudCenterY)/SigmaY);
544  }
545 
546  if (iy == numColumns-1 || SigmaY==0. )
547  UpperBound = 1.;
548  else {
549  mp = MeasurementPoint(0.0, float(iy+1));
550  yUB = topol->localPosition(mp).y();
551  UpperBound = 1. - calcQ((yUB-CloudCenterY)/SigmaY);
552  }
553 
554  float TotalIntegrationRange = UpperBound - LowerBound;
555  y[iy] = TotalIntegrationRange; // save strip integral
556  }
557 
558  // Get the 2D charge integrals by folding x and y strips
559  int chan;
560  for (ix = IPixLeftDownX; ix <= IPixRightUpX; ix++) { // loop over x index
561  for (iy = IPixLeftDownY; iy <= IPixRightUpY; iy++) { //loope over y ind
562  float ChargeFraction = Charge*x[ix]*y[iy];
563  if (ChargeFraction > 0.) {
564  chan = (pixelFlag) ? PixelDigi::pixelToChannel(ix, iy)
565  : Phase2TrackerDigi::pixelToChannel(ix, iy); // Get index
566  // Load the amplitude
567  hit_signal[chan] += ChargeFraction;
568  }
569 
570  mp = MeasurementPoint(float(ix), float(iy));
571  LocalPoint lp = topol->localPosition(mp);
572  chan = topol->channel(lp);
573 
574  LogDebug("Phase2TrackerDigitizerAlgorithm")
575  << " pixel " << ix << " " << iy << " - "<<" "
576  << chan << " " << ChargeFraction<<" "
577  << mp.x() << " " << mp.y() <<" "
578  << lp.x() << " " << lp.y() << " " // givex edge position
579  << chan; // edge belongs to previous ?
580  ESum += ChargeFraction;
581  }
582  }
583  }
584  // Fill the global map with all hit pixels from this event
585  for (auto const & hit_s : hit_signal) {
586  int chan = hit_s.first;
587  theSignal[chan] += (makeDigiSimLinks_ ? DigitizerUtility::Amplitude( hit_s.second, &hit, hit_s.second, hitIndex, tofBin)
588  : DigitizerUtility::Amplitude( hit_s.second, nullptr, hit_s.second) ) ;
589  }
590 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
PixelTopology::nrows
virtual int nrows() const =0
align::LocalPoint
Point3DBase< Scalar, LocalTag > LocalPoint
Definition: Definitions.h:32
PV2DBase::y
T y() const
Definition: PV2DBase.h:46
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
PixelTopology::pitch
virtual std::pair< float, float > pitch() const =0
nullptr
#define nullptr
gun_cff.SigmaX
SigmaX
Definition: gun_cff.py:25
PixelDigi::pixelToChannel
static int pixelToChannel(int row, int col)
Definition: PixelDigi.h:68
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
MeasurementPoint
Measurement2DPoint MeasurementPoint
Measurement points are two-dimensional by default.
Definition: MeasurementPoint.h:12
Phase2TrackerDigi::pixelToChannel
static PackedDigiType pixelToChannel(unsigned int row, unsigned int col)
Definition: Phase2TrackerDigi.h:45
Topology::measurementPosition
virtual MeasurementPoint measurementPosition(const LocalPoint &) const =0
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:79
Topology::channel
virtual int channel(const LocalPoint &p) const =0
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
gun_cff.SigmaY
SigmaY
Definition: gun_cff.py:26
PixelGeomDetUnit::specificTopology
virtual const PixelTopology & specificTopology() const
Returns a reference to the pixel proxy topology.
Definition: PixelGeomDetUnit.cc:18
Topology::localPosition
virtual LocalPoint localPosition(const MeasurementPoint &) const =0
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
PixelTopology::ncolumns
virtual int ncolumns() const =0
PV2DBase::x
T x() const
Definition: PV2DBase.h:45
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
virtual void Phase2TrackerDigitizerAlgorithm::init ( const edm::EventSetup &  es)
pure virtual

Implemented in PSPDigitizerAlgorithm, SSDigitizerAlgorithm, PixelDigitizerAlgorithm, and PSSDigitizerAlgorithm.

virtual void Phase2TrackerDigitizerAlgorithm::initializeEvent ( )
inlinevirtual

Definition at line 52 of file Phase2TrackerDigitizerAlgorithm.h.

52  {
53  _signal.clear();
54  }
void Phase2TrackerDigitizerAlgorithm::module_killing_conf ( uint32_t  detID)
protectedvirtual

Definition at line 817 of file Phase2TrackerDigitizerAlgorithm.cc.

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

Referenced by digitize().

817  {
818  bool isbad = false;
819  int detid = detID;
820  std::string Module;
821  for ( auto const & det_m : DeadModules) {
822  int Dead_detID = det_m.getParameter<int>("Dead_detID");
823  Module = det_m.getParameter<std::string>("Module");
824  if (detid == Dead_detID){
825  isbad = true;
826  break;
827  }
828  }
829 
830  if (!isbad) return;
831 
832  signal_map_type& theSignal = _signal[detID]; // check validity
833 
834 
835  for (auto & s : theSignal) {
836  std::pair<int,int> ip;
837  if (pixelFlag) ip = PixelDigi::channelToPixel(s.first);
838  else ip = Phase2TrackerDigi::channelToPixel(s.first);//get pixel pos
839 
840  if (Module == "whole") s.second.set(0.); // reset amplitude
841  else if (Module == "tbmA" && ip.first >= 80 && ip.first <= 159) s.second.set(0.);
842  else if (Module == "tbmB" && ip.first <= 79) s.second.set(0.);
843  }
844 }
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
PixelDigi::channelToPixel
static std::pair< int, int > channelToPixel(int ch)
Definition: PixelDigi.h:62
Module
#define Module(md)
Definition: vmac.h:201
Phase2TrackerDigi::channelToPixel
static std::pair< unsigned int, unsigned int > channelToPixel(unsigned int ch)
Definition: Phase2TrackerDigi.h:41
void Phase2TrackerDigitizerAlgorithm::module_killing_DB ( uint32_t  detID)
protectedvirtual

Definition at line 846 of file Phase2TrackerDigitizerAlgorithm.cc.

References _signal, funct::abs(), badPixels, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), SiPixelQuality::disabledModuleType::errorType, SiPixelFedCablingMap::findItem(), SiPixelQuality::getBadComponentList(), triggerObjects_cff::id, sipixelobjects::PixelROC::idInDetUnit(), SiPixelQuality::IsRocBad(), gen::k, DTRecHitQuality_cfi::local, map_, AlCaHLTBitMon_ParallelJobs::p, callgraph::path, SiPixelFedCablingMap::pathToDetUnit(), pixelFlag, edm::ESHandle< T >::product(), alignCSCRings::s, SiPixelBadModule_, and sipixelobjects::PixelROC::toGlobal().

Referenced by digitize().

846  {
847  bool isbad = false;
848 
849  std::vector<SiPixelQuality::disabledModuleType>disabledModules = SiPixelBadModule_->getBadComponentList();
850 
851  SiPixelQuality::disabledModuleType badmodule;
852  for (size_t id = 0;id < disabledModules.size(); id++) {
853  if (detID == disabledModules[id].DetID) {
854  isbad = true;
855  badmodule = disabledModules[id];
856  break;
857  }
858  }
859 
860  if (!isbad)
861  return;
862 
863 
864  signal_map_type& theSignal = _signal[detID]; // check validity
865 
866  if (badmodule.errorType == 0) { // this is a whole dead module.
867  for (auto & s : theSignal) {
868  s.second.set(0.); // reset amplitude
869  }
870  }
871  else { // all other module types: half-modules and single ROCs.
872  // Get Bad ROC position:
873  // follow the example of getBadRocPositions in CondFormats/SiPixelObjects/src/SiPixelQuality.cc
874  std::vector<GlobalPixel> badrocpositions (0);
875  for (unsigned int j = 0; j < 16; j++) {
876  if (SiPixelBadModule_->IsRocBad(detID, j) == true) {
877  std::vector<CablingPathToDetUnit> path = map_.product()->pathToDetUnit(detID);
878  for (auto const & p : path) {
879  const PixelROC* myroc = map_.product()->findItem(p);
880  if (myroc->idInDetUnit() == j) {
881  LocalPixel::RocRowCol local = {39, 25}; //corresponding to center of ROC row, col
882  GlobalPixel global = myroc->toGlobal(LocalPixel(local));
883  badrocpositions.push_back(global);
884  break;
885  }
886  }
887  }
888  }
889 
890 
891  for (auto & s : theSignal) {
892  std::pair<int,int> ip;
893  if (pixelFlag) ip = PixelDigi::channelToPixel(s.first);
894  else ip = Phase2TrackerDigi::channelToPixel(s.first);
895 
896  for (auto const & p : badrocpositions) {
897  for (auto & k : badPixels ) {
898  if ( p.row == k.getParameter<int>("row") &&
899  ip.first == k.getParameter<int>("row") &&
900  std::abs(ip.second - p.col) < k.getParameter<int>("col")) {s.second.set(0.);}
901  }
902  }
903  }
904  }
905 }
DTRecHitQuality_cfi.local
local
Definition: DTRecHitQuality_cfi.py:15
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
Phase2TrackerDigitizerAlgorithm::map_
edm::ESHandle< SiPixelFedCablingMap > map_
Definition: Phase2TrackerDigitizerAlgorithm.h:74
SiPixelQuality::IsRocBad
bool IsRocBad(const uint32_t &detid, const short &rocNb) const
Definition: SiPixelQuality.cc:117
sipixelobjects::LocalPixel
identify pixel inside single ROC
Definition: LocalPixel.h:7
sipixelobjects::GlobalPixel
global coordinates (row and column in DetUnit, as in PixelDigi)
Definition: GlobalPixel.h:6
Phase2TrackerDigitizerAlgorithm::badPixels
std::vector< edm::ParameterSet > badPixels
Definition: Phase2TrackerDigitizerAlgorithm.h:162
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:28
sipixelobjects::PixelROC::idInDetUnit
unsigned int idInDetUnit() const
id of this ROC in DetUnit etermined by token path
Definition: PixelROC.h:40
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
SiPixelQuality::getBadComponentList
const std::vector< disabledModuleType > getBadComponentList() const
Definition: SiPixelQuality.h:115
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
PixelDigi::channelToPixel
static std::pair< int, int > channelToPixel(int ch)
Definition: PixelDigi.h:62
sipixelobjects::LocalPixel::RocRowCol
row and collumn in ROC representation
Definition: LocalPixel.h:15
SiPixelFedCablingMap::pathToDetUnit
std::vector< sipixelobjects::CablingPathToDetUnit > pathToDetUnit(uint32_t rawDetId) const override
Definition: SiPixelFedCablingMap.cc:150
SiPixelFedCablingMap::findItem
const sipixelobjects::PixelROC * findItem(const sipixelobjects::CablingPathToDetUnit &path) const override
Definition: SiPixelFedCablingMap.cc:122
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
Phase2TrackerDigi::channelToPixel
static std::pair< unsigned int, unsigned int > channelToPixel(unsigned int ch)
Definition: Phase2TrackerDigi.h:41
sipixelobjects::PixelROC::toGlobal
GlobalPixel toGlobal(const LocalPixel &loc) const
Definition: PixelROC.h:59
Phase2TrackerDigitizerAlgorithm::SiPixelBadModule_
edm::ESHandle< SiPixelQuality > SiPixelBadModule_
Definition: Phase2TrackerDigitizerAlgorithm.h:71
void Phase2TrackerDigitizerAlgorithm::pixel_inefficiency ( const SubdetEfficiencies &  eff,
const Phase2TrackerGeomDetUnit *  pixdet,
const TrackerTopology *  tTopo 
)
protectedvirtual

Definition at line 696 of file Phase2TrackerDigitizerAlgorithm.cc.

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

Referenced by digitize().

698  {
699 
700  uint32_t detID = pixdet->geographicalId().rawId();
701 
702  signal_map_type& theSignal = _signal[detID]; // check validity
703 
704  // Predefined efficiencies
705  float subdetEfficiency = 1.0;
706 
707  // setup the chip indices conversion
708  unsigned int Subid=DetId(detID).subdetId();
709  if (Subid == PixelSubdetector::PixelBarrel || Subid == StripSubdetector::TOB) { // barrel layers
710  unsigned int layerIndex = tTopo->pxbLayer(detID);
711  if (layerIndex-1 < eff.barrel_efficiencies.size()) subdetEfficiency = eff.barrel_efficiencies[layerIndex-1];
712  } else { // forward disks
713  unsigned int diskIndex = 2 * tTopo->pxfDisk(detID) - tTopo->pxfSide(detID);
714  if (diskIndex-1 < eff.endcap_efficiencies.size()) subdetEfficiency = eff.endcap_efficiencies[diskIndex-1];
715  }
716 
717  LogDebug ("Phase2TrackerDigitizerAlgorithm") << " enter pixel_inefficiency " << subdetEfficiency;
718 
719  // Now loop again over pixels to kill some of them.
720  // Loop over hits, amplitude in electrons, channel = coded row,col
721  for (auto & s : theSignal) {
722  float rand = flatDistribution_->fire();
723  if( rand>subdetEfficiency ) {
724  // make amplitude =0
725  s.second.set(0.); // reset amplitude,
726  }
727  }
728 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:455
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:79
DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
DetId
Definition: DetId.h:18
rand
Signal rand(Signal arg)
Definition: vlib.cc:442
Phase2TrackerDigitizerAlgorithm::flatDistribution_
const std::unique_ptr< CLHEP::RandFlat > flatDistribution_
Definition: Phase2TrackerDigitizerAlgorithm.h:203
TrackerTopology::pxfSide
unsigned int pxfSide(const DetId &id) const
Definition: TrackerTopology.h:196
void Phase2TrackerDigitizerAlgorithm::pixel_inefficiency_db ( uint32_t  detID)
protectedvirtual

Definition at line 798 of file Phase2TrackerDigitizerAlgorithm.cc.

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

Referenced by digitize().

798  {
799  signal_map_type& theSignal = _signal[detID]; // check validity
800 
801  // Loop over hit pixels, amplitude in electrons, channel = coded row,col
802  for (auto & s : theSignal) {
803  std::pair<int,int> ip;
804  if (pixelFlag) ip = PixelDigi::channelToPixel(s.first);//get pixel pos
805  else ip = Phase2TrackerDigi::channelToPixel(s.first);//get pixel pos
806  int row = ip.first; // X in row
807  int col = ip.second; // Y is in col
808  //transform to ROC index coordinates
809  if (theSiPixelGainCalibrationService_->isDead(detID, col, row)) {
810  s.second.set(0.); // reset amplitude,
811  }
812  }
813 }
Phase2TrackerDigitizerAlgorithm::theSiPixelGainCalibrationService_
const std::unique_ptr< SiPixelGainCalibrationOfflineSimService > theSiPixelGainCalibrationService_
Definition: Phase2TrackerDigitizerAlgorithm.h:192
Phase2TrackerDigitizerAlgorithm::signal_map_type
std::map< int, DigitizerUtility::Amplitude, std::less< int > > signal_map_type
Definition: Phase2TrackerDigitizerAlgorithm.h:83
PixelDigi::channelToPixel
static std::pair< int, int > channelToPixel(int ch)
Definition: PixelDigi.h:62
cuy.col
col
Definition: cuy.py:1008
Phase2TrackerDigi::channelToPixel
static std::pair< unsigned int, unsigned int > channelToPixel(unsigned int ch)
Definition: Phase2TrackerDigi.h:41
void Phase2TrackerDigitizerAlgorithm::primary_ionization ( const PSimHit &  hit,
std::vector< DigitizerUtility::EnergyDepositUnit > &  ionization_points 
) const
protected

Definition at line 189 of file Phase2TrackerDigitizerAlgorithm.cc.

References PSimHit::energyLoss(), PSimHit::entryPoint(), PSimHit::exitPoint(), objects.autophobj::float, fluctuateCharge, fluctuateEloss(), GeVperElectron, mps_fire::i, createfilelist::int, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), PSimHit::pabs(), PSimHit::particleType(), sysUtil::pid, point, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

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

190  {
191  // Straight line approximation for trajectory inside active media
192  const float SegmentLength = 0.0010; // in cm (10 microns)
193  float energy;
194 
195  // Get the 3D segment direction vector
196  LocalVector direction = hit.exitPoint() - hit.entryPoint();
197 
198  float eLoss = hit.energyLoss(); // Eloss in GeV
199  float length = direction.mag(); // Track length in Silicon
200 
201  int NumberOfSegments = int (length / SegmentLength); // Number of segments
202  if (NumberOfSegments < 1) NumberOfSegments = 1;
203  LogDebug("Phase2TrackerDigitizerAlgorithm")
204  << "enter primary_ionzation " << NumberOfSegments
205  << " shift = "
206  << hit.exitPoint().x() - hit.entryPoint().x() << " "
207  << hit.exitPoint().y() - hit.entryPoint().y() << " "
208  << hit.exitPoint().z() - hit.entryPoint().z() << " "
209  << hit.particleType()
210  << " " << hit.pabs();
211 
212  std::vector<float> elossVector; // Eloss vector
213  elossVector.reserve(NumberOfSegments);
214  if (fluctuateCharge) {
215  int pid = hit.particleType();
216  // int pid=211; // assume it is a pion
217 
218  float momentum = hit.pabs();
219  // Generate fluctuated charge points
220  fluctuateEloss(pid, momentum, eLoss, length, NumberOfSegments, elossVector);
221  }
222  ionization_points.reserve(NumberOfSegments); // set size
223 
224  // loop over segments
225  for (int i = 0; i != NumberOfSegments; ++i) {
226  // Divide the segment into equal length subsegments
227  Local3DPoint point = hit.entryPoint() + float((i+0.5)/NumberOfSegments) * direction;
228  if (fluctuateCharge)
229  energy = elossVector[i]/GeVperElectron; // Convert charge to elec.
230  else
231  energy = hit.energyLoss()/GeVperElectron/float(NumberOfSegments);
232 
233  DigitizerUtility::EnergyDepositUnit edu(energy, point); // define position,energy point
234  ionization_points.push_back(edu); // save
235  LogDebug("Phase2TrackerDigitizerAlgorithm")
236  << i << " " << ionization_points[i].x() << " "
237  << ionization_points[i].y() << " "
238  << ionization_points[i].z() << " "
239  << ionization_points[i].energy();
240  }
241 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
mps_fire.i
i
Definition: mps_fire.py:269
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
PSimHit::exitPoint
Local3DPoint exitPoint() const
Exit point in the local Det frame.
Definition: PSimHit.h:38
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:67
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
PSimHit::pabs
float pabs() const
fast and more accurate access to momentumAtEntry().mag()
Definition: PSimHit.h:63
Phase2TrackerDigitizerAlgorithm::fluctuateEloss
void fluctuateEloss(int particleId, float momentum, float eloss, float length, int NumberOfSegments, std::vector< float > &elossVector) const
Definition: Phase2TrackerDigitizerAlgorithm.cc:248
PSimHit::energyLoss
float energyLoss() const
The energy deposit in the PSimHit, in ???.
Definition: PSimHit.h:75
PSimHit::particleType
int particleType() const
Definition: PSimHit.h:85
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
PSimHit::entryPoint
Local3DPoint entryPoint() const
Entry point in the local Det frame.
Definition: PSimHit.h:35
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

Member Data Documentation

signalMaps Phase2TrackerDigitizerAlgorithm::_signal
protected

Definition at line 92 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), induce_signal(), module_killing_conf(), module_killing_DB(), pixel_inefficiency(), and pixel_inefficiency_db().

const bool Phase2TrackerDigitizerAlgorithm::addNoise
protected

Definition at line 141 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const bool Phase2TrackerDigitizerAlgorithm::addNoisyPixels
protected

Definition at line 142 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise().

const bool Phase2TrackerDigitizerAlgorithm::AddPixelInefficiency
protected

Definition at line 146 of file Phase2TrackerDigitizerAlgorithm.h.

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

const bool Phase2TrackerDigitizerAlgorithm::addThresholdSmearing
protected

Definition at line 148 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const bool Phase2TrackerDigitizerAlgorithm::addXtalk
protected

Definition at line 110 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise().

const bool Phase2TrackerDigitizerAlgorithm::alpha2Order
protected

Definition at line 109 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift(), and DriftDirection().

std::vector<edm::ParameterSet> Phase2TrackerDigitizerAlgorithm::badPixels
protected

Definition at line 162 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_DB().

const float Phase2TrackerDigitizerAlgorithm::ClusterWidth
protected

Definition at line 116 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by induce_signal().

const Parameters Phase2TrackerDigitizerAlgorithm::DeadModules
protected

Definition at line 101 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_conf().

const bool Phase2TrackerDigitizerAlgorithm::doDigitalReadout
protected

Definition at line 119 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const std::unique_ptr<CLHEP::RandFlat> Phase2TrackerDigitizerAlgorithm::flatDistribution_
protected

Definition at line 203 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by pixel_inefficiency().

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

Definition at line 165 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by fluctuateEloss().

const bool Phase2TrackerDigitizerAlgorithm::fluctuateCharge
protected

Definition at line 143 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by primary_ionization().

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

Definition at line 204 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise().

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

Definition at line 75 of file Phase2TrackerDigitizerAlgorithm.h.

const float Phase2TrackerDigitizerAlgorithm::GeVperElectron
protected

Definition at line 106 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by primary_ionization().

const float Phase2TrackerDigitizerAlgorithm::interstripCoupling
protected

Definition at line 111 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise().

const bool Phase2TrackerDigitizerAlgorithm::makeDigiSimLinks_
protected

Definition at line 94 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize(), and induce_signal().

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

Definition at line 74 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_DB().

bool Phase2TrackerDigitizerAlgorithm::pixelFlag
protected

Definition at line 217 of file Phase2TrackerDigitizerAlgorithm.h.

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

const double Phase2TrackerDigitizerAlgorithm::pseudoRadDamage
protected

Definition at line 151 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

const double Phase2TrackerDigitizerAlgorithm::pseudoRadDamageRadius
protected

Definition at line 152 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

CLHEP::HepRandomEngine* Phase2TrackerDigitizerAlgorithm::rengine_
protected

Definition at line 211 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise(), and fluctuateEloss().

const float Phase2TrackerDigitizerAlgorithm::Sigma0
protected

Definition at line 112 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

const float Phase2TrackerDigitizerAlgorithm::SigmaCoeff
protected

Definition at line 113 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by drift().

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

Definition at line 71 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by module_killing_DB().

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

Definition at line 68 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

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

Definition at line 208 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

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

Definition at line 207 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const SubdetEfficiencies Phase2TrackerDigitizerAlgorithm::subdetEfficiencies_
protected

Definition at line 200 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const float Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Barrel
protected

Definition at line 138 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

const float Phase2TrackerDigitizerAlgorithm::tanLorentzAnglePerTesla_Endcap
protected

Definition at line 137 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

const int Phase2TrackerDigitizerAlgorithm::theAdcFullScale
protected

Definition at line 121 of file Phase2TrackerDigitizerAlgorithm.h.

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

const float Phase2TrackerDigitizerAlgorithm::theElectronPerADC
protected

Definition at line 120 of file Phase2TrackerDigitizerAlgorithm.h.

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

const double Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Barrel
protected

Definition at line 133 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const double Phase2TrackerDigitizerAlgorithm::theHIPThresholdInE_Endcap
protected

Definition at line 132 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const float Phase2TrackerDigitizerAlgorithm::theNoiseInElectrons
protected

Definition at line 122 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise(), and digitize().

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

Definition at line 166 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by add_noise().

const float Phase2TrackerDigitizerAlgorithm::theReadoutNoise
protected

Definition at line 123 of file Phase2TrackerDigitizerAlgorithm.h.

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

Definition at line 192 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by pixel_inefficiency_db().

const float Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel
protected

Definition at line 127 of file Phase2TrackerDigitizerAlgorithm.h.

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

const float Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap
protected

Definition at line 126 of file Phase2TrackerDigitizerAlgorithm.h.

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

const double Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Barrel
protected

Definition at line 130 of file Phase2TrackerDigitizerAlgorithm.h.

const double Phase2TrackerDigitizerAlgorithm::theThresholdSmearing_Endcap
protected

Definition at line 129 of file Phase2TrackerDigitizerAlgorithm.h.

const float Phase2TrackerDigitizerAlgorithm::theTofLowerCut
protected

Definition at line 135 of file Phase2TrackerDigitizerAlgorithm.h.

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

const float Phase2TrackerDigitizerAlgorithm::theTofUpperCut
protected

Definition at line 136 of file Phase2TrackerDigitizerAlgorithm.h.

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

const double Phase2TrackerDigitizerAlgorithm::tMax
protected

Definition at line 159 of file Phase2TrackerDigitizerAlgorithm.h.

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

const bool Phase2TrackerDigitizerAlgorithm::use_deadmodule_DB_
protected

Definition at line 98 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const bool Phase2TrackerDigitizerAlgorithm::use_ineff_from_db_
protected

Definition at line 96 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

const bool Phase2TrackerDigitizerAlgorithm::use_LorentzAngle_DB_
protected

Definition at line 99 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by DriftDirection().

const bool Phase2TrackerDigitizerAlgorithm::use_module_killing_
protected

Definition at line 97 of file Phase2TrackerDigitizerAlgorithm.h.

Referenced by digitize().

Generated for CMSSW Reference Manual by doxygen 1.8.11