#include <SiPixelDigitizerAlgorithm.h>

Classes
class	CalParameters

class	EnergyDepositUnit

struct	PixelAging

struct	PixelEfficiencies

class	SignalPoint

Public Types
typedef std::unordered_map< std::string, PixelFEDChannelCollection >	PixelFEDChannelCollectionMap

Public Member Functions
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 PixelGeomDetUnit pixdet, const GlobalVector &bfield, const TrackerTopology tTopo, CLHEP::HepRandomEngine *)

void	calculateInstlumiFactor (PileupMixingContent *puInfo)

void	calculateInstlumiFactor (const std::vector< PileupSummaryInfo > &ps, int bunchSpacing)

std::unique_ptr< PixelFEDChannelCollection >	chooseScenario (PileupMixingContent puInfo, CLHEP::HepRandomEngine )

std::unique_ptr< PixelFEDChannelCollection >	chooseScenario (const std::vector< PileupSummaryInfo > &ps, CLHEP::HepRandomEngine *engine)

void	digitize (const PixelGeomDetUnit pixdet, std::vector< PixelDigi > &digis, std::vector< PixelDigiSimLink > &simlinks, std::vector< PixelDigiAddTempInfo > &newClass_Digi_extra, const TrackerTopology tTopo, CLHEP::HepRandomEngine *)

void	fillSimHitMaps (std::vector< PSimHit > simHits, const unsigned int tofBin)

void	init (const edm::EventSetup &es)

void	init_DynIneffDB (const edm::EventSetup &)

void	initializeEvent ()

bool	killBadFEDChannels () const

void	lateSignalReweight (const PixelGeomDetUnit pixdet, std::vector< PixelDigi > &digis, std::vector< PixelSimHitExtraInfo > &newClass_Sim_extra, const TrackerTopology tTopo, CLHEP::HepRandomEngine *engine)

void	resetSimHitMaps ()

void	setSimAccumulator (const std::map< uint32_t, std::map< int, int > > &signalMap)

	SiPixelDigitizerAlgorithm (const edm::ParameterSet &conf, edm::ConsumesCollector iC)

	~SiPixelDigitizerAlgorithm ()

Public Attributes
const PixelFEDChannelCollectionMap *	quality_map

Private Types
typedef boost::multi_array< float, 2 >	array_2d

typedef GloballyPositioned< double >	Frame

typedef std::vector< edm::ParameterSet >	Parameters

typedef signal_map_type::const_iterator	signal_map_const_iterator

typedef signal_map_type::iterator	signal_map_iterator

typedef std::map< int, digitizerUtility::Amplitude, std::less< int > >	signal_map_type

typedef std::map< uint32_t, signal_map_type >	signalMaps

typedef std::map< subDetTofBin, unsigned int >	simhit_collectionMap

typedef std::map< unsigned int, std::vector< PSimHit > >	simhit_map

typedef std::pair< unsigned int, unsigned int >	subDetTofBin

Private Member Functions
void	add_noise (const PixelGeomDetUnit pixdet, float thePixelThreshold, CLHEP::HepRandomEngine )

double	calcQ (float x) const

void	drift (const PSimHit &hit, const PixelGeomDetUnit pixdet, const GlobalVector &bfield, const TrackerTopology tTopo, const std::vector< EnergyDepositUnit > &ionization_points, std::vector< SignalPoint > &collection_points) const

LocalVector	DriftDirection (const PixelGeomDetUnit *pixdet, const GlobalVector &bfield, const DetId &detId) const

void	fluctuateEloss (int particleId, float momentum, float eloss, float length, int NumberOfSegments, float elossVector[], CLHEP::HepRandomEngine *) const

void	induce_signal (std::vector< PSimHit >::const_iterator inputBegin, std::vector< PSimHit >::const_iterator inputEnd, const PSimHit &hit, const size_t hitIndex, const size_t FirstHitIndex, const unsigned int tofBin, const PixelGeomDetUnit *pixdet, const std::vector< SignalPoint > &collection_points)

std::map< int, CalParameters, std::less< int > >	initCal () const

void	make_digis (float thePixelThresholdInE, uint32_t detID, const PixelGeomDetUnit pixdet, std::vector< PixelDigi > &digis, std::vector< PixelDigiSimLink > &simlinks, std::vector< PixelDigiAddTempInfo > &newClass_Digi_extra, const TrackerTopology tTopo) const

float	missCalibrate (uint32_t detID, const TrackerTopology tTopo, const PixelGeomDetUnit pixdet, int col, int row, float amp) const

void	module_killing_conf (uint32_t detID)

void	module_killing_DB (uint32_t detID)

float	pixel_aging (const PixelAging &aging, const PixelGeomDetUnit pixdet, const TrackerTopology tTopo) const

void	pixel_inefficiency (const PixelEfficiencies &eff, const PixelGeomDetUnit pixdet, const TrackerTopology tTopo, CLHEP::HepRandomEngine *)

void	pixel_inefficiency_db (uint32_t detID)

void	primary_ionization (const PSimHit &hit, std::vector< EnergyDepositUnit > &ionization_points, CLHEP::HepRandomEngine *) const

Private Attributes
signalMaps	_signal

const bool	addChargeVCALSmearing

const bool	addNoise

const bool	addNoisyPixels

const bool	AddPixelAging

const bool	AddPixelInefficiency

const bool	addThresholdSmearing

const bool	alpha2Order

const float	BPix_p0

const float	BPix_p1

const float	BPix_p2

const float	BPix_p3

const std::map< int, CalParameters, std::less< int > >	calmap

const float	ClusterWidth

const Parameters	DeadModules

const float	Dist300

const bool	doMissCalibrate

const bool	doMissCalInLateCR

const float	electronsPerVCAL

const float	electronsPerVCAL_L1

const float	electronsPerVCAL_L1_Offset

const float	electronsPerVCAL_Offset

const std::unique_ptr< SiG4UniversalFluctuation >	fluctuate

const bool	fluctuateCharge

const float	FPix_p0

const float	FPix_p1

const float	FPix_p2

const float	FPix_p3

const TrackerGeometry *	geom_ = nullptr

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

const float	GeVperElectron

const bool	KillBadFEDChannels

const bool	makeDigiSimLinks_

const SiPixelFedCablingMap *	map_ = nullptr

const edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	mapToken_

const int	NumberOfBarrelLayers

const int	NumberOfEndcapDisks

const PixelAging	pixelAging_

PixelEfficiencies	pixelEfficiencies_

edm::ESGetToken< PixelFEDChannelCollectionMap, SiPixelFEDChannelContainerESProducerRcd >	PixelFEDChannelCollectionMapToken_

const SiPixelQualityProbabilities *	scenarioProbability_ = nullptr

edm::ESGetToken< SiPixelQualityProbabilities, SiPixelStatusScenarioProbabilityRcd >	scenarioProbabilityToken_

const float	Sigma0

simhit_collectionMap	SimHitCollMap

simhit_map	SimHitMap

const SiPixelQuality *	SiPixelBadModule_ = nullptr

edm::ESGetToken< SiPixelQuality, SiPixelQualityRcd >	SiPixelBadModuleToken_

const SiPixelDynamicInefficiency *	SiPixelDynamicInefficiency_ = nullptr

edm::ESGetToken< SiPixelDynamicInefficiency, SiPixelDynamicInefficiencyRcd >	SiPixelDynamicInefficiencyToken_

const SiPixelLorentzAngle *	SiPixelLorentzAngle_ = nullptr

edm::ESGetToken< SiPixelLorentzAngle, SiPixelLorentzAngleSimRcd >	SiPixelLorentzAngleToken_

const bool	store_SimHitEntryExitPoints_

const float	tanLorentzAnglePerTesla_BPix

const float	tanLorentzAnglePerTesla_FPix

const int	theAdcFullScale

const int	theAdcFullScLateCR

const float	theElectronPerADC

const float	theGainSmearing

std::unique_ptr< SiPixelChargeReweightingAlgorithm >	TheNewSiPixelChargeReweightingAlgorithmClass

const float	theNoiseInElectrons

const std::unique_ptr< GaussianTailNoiseGenerator >	theNoiser

const float	theOffsetSmearing

const float	theReadoutNoise

const std::unique_ptr< SiPixelGainCalibrationOfflineSimService >	theSiPixelGainCalibrationService_

const float	theThresholdInE_BPix

const float	theThresholdInE_BPix_L1

const float	theThresholdInE_BPix_L2

const float	theThresholdInE_FPix

const double	theThresholdSmearing_BPix

const double	theThresholdSmearing_BPix_L1

const double	theThresholdSmearing_BPix_L2

const double	theThresholdSmearing_FPix

const float	theTofLowerCut

const float	theTofUpperCut

const double	tMax

const bool	use_deadmodule_DB_

const bool	use_ineff_from_db_

const bool	use_LorentzAngle_DB_

const bool	use_module_killing_

const bool	UseReweighting

Detailed Description

Definition at line 58 of file SiPixelDigitizerAlgorithm.h.

Member Typedef Documentation

◆ array_2d

typedef boost::multi_array<float, 2> SiPixelDigitizerAlgorithm::array_2d

private

Definition at line 267 of file SiPixelDigitizerAlgorithm.h.

◆ Frame

typedef GloballyPositioned<double> SiPixelDigitizerAlgorithm::Frame

private

Definition at line 265 of file SiPixelDigitizerAlgorithm.h.

◆ Parameters

typedef std::vector<edm::ParameterSet> SiPixelDigitizerAlgorithm::Parameters

private

Definition at line 266 of file SiPixelDigitizerAlgorithm.h.

◆ PixelFEDChannelCollectionMap

typedef std::unordered_map<std::string, PixelFEDChannelCollection> SiPixelDigitizerAlgorithm::PixelFEDChannelCollectionMap

Definition at line 103 of file SiPixelDigitizerAlgorithm.h.

◆ signal_map_const_iterator

typedef signal_map_type::const_iterator SiPixelDigitizerAlgorithm::signal_map_const_iterator

private

Definition at line 263 of file SiPixelDigitizerAlgorithm.h.

◆ signal_map_iterator

typedef signal_map_type::iterator SiPixelDigitizerAlgorithm::signal_map_iterator

private

Definition at line 262 of file SiPixelDigitizerAlgorithm.h.

◆ signal_map_type

typedef std::map<int, digitizerUtility::Amplitude, std::less<int> > SiPixelDigitizerAlgorithm::signal_map_type

private

Definition at line 261 of file SiPixelDigitizerAlgorithm.h.

◆ signalMaps

typedef std::map<uint32_t, signal_map_type> SiPixelDigitizerAlgorithm::signalMaps

private

Definition at line 264 of file SiPixelDigitizerAlgorithm.h.

◆ simhit_collectionMap

typedef std::map<subDetTofBin, unsigned int> SiPixelDigitizerAlgorithm::simhit_collectionMap

private

Definition at line 272 of file SiPixelDigitizerAlgorithm.h.

◆ simhit_map

typedef std::map<unsigned int, std::vector<PSimHit> > SiPixelDigitizerAlgorithm::simhit_map

private

Definition at line 270 of file SiPixelDigitizerAlgorithm.h.

◆ subDetTofBin

typedef std::pair<unsigned int, unsigned int> SiPixelDigitizerAlgorithm::subDetTofBin

private

Definition at line 269 of file SiPixelDigitizerAlgorithm.h.

Constructor & Destructor Documentation

◆ SiPixelDigitizerAlgorithm()

SiPixelDigitizerAlgorithm::SiPixelDigitizerAlgorithm	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector	iC
	)

Definition at line 179 of file SiPixelDigitizerAlgorithm.cc.

References AddPixelInefficiency, edm::ConsumesCollector::esConsumes(), SiPixelDigitizerAlgorithm::PixelEfficiencies::FromConfig, edm::ParameterSet::getParameter(), KillBadFEDChannels, pixelEfficiencies_, PixelFEDChannelCollectionMapToken_, scenarioProbabilityToken_, SiPixelBadModuleToken_, SiPixelDynamicInefficiencyToken_, SiPixelLorentzAngleToken_, store_SimHitEntryExitPoints_, AlCaHLTBitMon_QueryRunRegistry::string, theAdcFullScale, theElectronPerADC, TheNewSiPixelChargeReweightingAlgorithmClass, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, theThresholdInE_FPix, tMax, use_deadmodule_DB_, use_LorentzAngle_DB_, and UseReweighting.

     : mapToken_(iC.esConsumes()),
       geomToken_(iC.esConsumes()),
 
       _signal(),
       makeDigiSimLinks_(conf.getUntrackedParameter<bool>("makeDigiSimLinks", true)),
       store_SimHitEntryExitPoints_(
           conf.exists("store_SimHitEntryExitPoints") ? conf.getParameter<bool>("store_SimHitEntryExitPoints") : false),
       use_ineff_from_db_(conf.getParameter<bool>("useDB")),
       use_module_killing_(conf.getParameter<bool>("killModules")),       // boolean to kill or not modules
       use_deadmodule_DB_(conf.getParameter<bool>("DeadModules_DB")),     // boolean to access dead modules from DB
       use_LorentzAngle_DB_(conf.getParameter<bool>("LorentzAngle_DB")),  // boolean to access Lorentz angle from DB
 
       DeadModules(use_deadmodule_DB_ ? Parameters()
                                      : conf.getParameter<Parameters>("DeadModules")),  // get dead module from cfg file
 
       TheNewSiPixelChargeReweightingAlgorithmClass(),
 
       // Common pixel parameters
       // These are parameters which are not likely to be changed
       GeVperElectron(3.61E-09),                             // 1 electron(3.61eV, 1keV(277e, mod 9/06 d.k.
       Sigma0(0.00037),                                      // Charge diffusion constant 7->3.7
       Dist300(0.0300),                                      //   normalized to 300micron Silicon
       alpha2Order(conf.getParameter<bool>("Alpha2Order")),  // switch on/off of E.B effect
       ClusterWidth(3.),                                     // Charge integration spread on the collection plane
 
       // get external parameters:
       // To account for upgrade geometries do not assume the number
       // of layers or disks.
       NumberOfBarrelLayers(conf.exists("NumPixelBarrel") ? conf.getParameter<int>("NumPixelBarrel") : 3),
       NumberOfEndcapDisks(conf.exists("NumPixelEndcap") ? conf.getParameter<int>("NumPixelEndcap") : 2),
 
       // ADC calibration 1adc count(135e.
       // Corresponds to 2adc/kev, 270[e/kev]/135[e/adc](2[adc/kev]
       // Be carefull, this parameter is also used in SiPixelDet.cc to
       // calculate the noise in adc counts from noise in electrons.
       // Both defaults should be the same.
       theElectronPerADC(conf.getParameter<double>("ElectronPerAdc")),
 
       // ADC saturation value, 255(8bit adc.
       //theAdcFullScale(conf.getUntrackedParameter<int>("AdcFullScale",255)),
       theAdcFullScale(conf.getParameter<int>("AdcFullScale")),
       theAdcFullScLateCR(conf.getParameter<int>("AdcFullScLateCR")),
 
       // Noise in electrons:
       // Pixel cell noise, relevant for generating noisy pixels
       theNoiseInElectrons(conf.getParameter<double>("NoiseInElectrons")),
 
       // Fill readout noise, including all readout chain, relevant for smearing
       //theReadoutNoise(conf.getUntrackedParameter<double>("ReadoutNoiseInElec",500.)),
       theReadoutNoise(conf.getParameter<double>("ReadoutNoiseInElec")),
 
       // Pixel threshold in units of noise:
       // thePixelThreshold(conf.getParameter<double>("ThresholdInNoiseUnits")),
       // Pixel threshold in electron units.
       theThresholdInE_FPix(conf.getParameter<double>("ThresholdInElectrons_FPix")),
       theThresholdInE_BPix(conf.getParameter<double>("ThresholdInElectrons_BPix")),
       theThresholdInE_BPix_L1(conf.exists("ThresholdInElectrons_BPix_L1")
                                   ? conf.getParameter<double>("ThresholdInElectrons_BPix_L1")
                                   : theThresholdInE_BPix),
       theThresholdInE_BPix_L2(conf.exists("ThresholdInElectrons_BPix_L2")
                                   ? conf.getParameter<double>("ThresholdInElectrons_BPix_L2")
                                   : theThresholdInE_BPix),
 
       // Add threshold gaussian smearing:
       theThresholdSmearing_FPix(conf.getParameter<double>("ThresholdSmearing_FPix")),
       theThresholdSmearing_BPix(conf.getParameter<double>("ThresholdSmearing_BPix")),
       theThresholdSmearing_BPix_L1(conf.exists("ThresholdSmearing_BPix_L1")
                                        ? conf.getParameter<double>("ThresholdSmearing_BPix_L1")
                                        : theThresholdSmearing_BPix),
       theThresholdSmearing_BPix_L2(conf.exists("ThresholdSmearing_BPix_L2")
                                        ? conf.getParameter<double>("ThresholdSmearing_BPix_L2")
                                        : theThresholdSmearing_BPix),
 
       // electrons to VCAL conversion needed in misscalibrate()
       electronsPerVCAL(conf.getParameter<double>("ElectronsPerVcal")),
       electronsPerVCAL_Offset(conf.getParameter<double>("ElectronsPerVcal_Offset")),
       electronsPerVCAL_L1(conf.exists("ElectronsPerVcal_L1") ? conf.getParameter<double>("ElectronsPerVcal_L1")
                                                              : electronsPerVCAL),
       electronsPerVCAL_L1_Offset(conf.exists("ElectronsPerVcal_L1_Offset")
                                      ? conf.getParameter<double>("ElectronsPerVcal_L1_Offset")
                                      : electronsPerVCAL_Offset),
 
       //theTofCut 12.5, cut in particle TOD +/- 12.5ns
       //theTofCut(conf.getUntrackedParameter<double>("TofCut",12.5)),
       theTofLowerCut(conf.getParameter<double>("TofLowerCut")),
       theTofUpperCut(conf.getParameter<double>("TofUpperCut")),
 
       // Get the Lorentz angle from the cfg file:
       tanLorentzAnglePerTesla_FPix(use_LorentzAngle_DB_ ? 0.0
                                                         : conf.getParameter<double>("TanLorentzAnglePerTesla_FPix")),
       tanLorentzAnglePerTesla_BPix(use_LorentzAngle_DB_ ? 0.0
                                                         : conf.getParameter<double>("TanLorentzAnglePerTesla_BPix")),
 
       // signal response new parameterization: split Fpix and BPix
       FPix_p0(conf.getParameter<double>("FPix_SignalResponse_p0")),
       FPix_p1(conf.getParameter<double>("FPix_SignalResponse_p1")),
       FPix_p2(conf.getParameter<double>("FPix_SignalResponse_p2")),
       FPix_p3(conf.getParameter<double>("FPix_SignalResponse_p3")),
 
       BPix_p0(conf.getParameter<double>("BPix_SignalResponse_p0")),
       BPix_p1(conf.getParameter<double>("BPix_SignalResponse_p1")),
       BPix_p2(conf.getParameter<double>("BPix_SignalResponse_p2")),
       BPix_p3(conf.getParameter<double>("BPix_SignalResponse_p3")),
 
       // Add noise
       addNoise(conf.getParameter<bool>("AddNoise")),
 
       // Smear the pixel charge with a gaussian which RMS is a function of the
       // pixel charge (Danek's study)
       addChargeVCALSmearing(conf.getParameter<bool>("ChargeVCALSmearing")),
 
       // Add noisy pixels
       addNoisyPixels(conf.getParameter<bool>("AddNoisyPixels")),
 
       // Fluctuate charge in track subsegments
       fluctuateCharge(conf.getUntrackedParameter<bool>("FluctuateCharge", true)),
 
       // Control the pixel inefficiency
       AddPixelInefficiency(conf.getParameter<bool>("AddPixelInefficiency")),
       KillBadFEDChannels(conf.getParameter<bool>("KillBadFEDChannels")),
 
       // Add threshold gaussian smearing:
       addThresholdSmearing(conf.getParameter<bool>("AddThresholdSmearing")),
 
       // Get the constants for the miss-calibration studies
       doMissCalibrate(conf.getParameter<bool>("MissCalibrate")),       // Enable miss-calibration
       doMissCalInLateCR(conf.getParameter<bool>("MissCalInLateCR")),   // Enable miss-calibration
       theGainSmearing(conf.getParameter<double>("GainSmearing")),      // sigma of the gain smearing
       theOffsetSmearing(conf.getParameter<double>("OffsetSmearing")),  //sigma of the offset smearing
 
       // Add pixel radiation damage for upgrade studies
       AddPixelAging(conf.getParameter<bool>("DoPixelAging")),
       UseReweighting(conf.getParameter<bool>("UseReweighting")),
 
       // delta cutoff in MeV, has to be same as in OSCAR(0.030/cmsim=1.0 MeV
       //tMax(0.030), // In MeV.
       //tMax(conf.getUntrackedParameter<double>("deltaProductionCut",0.030)),
       tMax(conf.getParameter<double>("deltaProductionCut")),
 
       fluctuate(fluctuateCharge ? new SiG4UniversalFluctuation() : nullptr),
       theNoiser(addNoise ? new GaussianTailNoiseGenerator() : nullptr),
       calmap((doMissCalibrate || doMissCalInLateCR) ? initCal() : std::map<int, CalParameters, std::less<int> >()),
       theSiPixelGainCalibrationService_(use_ineff_from_db_ ? new SiPixelGainCalibrationOfflineSimService(conf, iC)
                                                            : nullptr),
       pixelEfficiencies_(conf, AddPixelInefficiency, NumberOfBarrelLayers, NumberOfEndcapDisks),
       pixelAging_(conf, AddPixelAging, NumberOfBarrelLayers, NumberOfEndcapDisks) {
   if (use_deadmodule_DB_) {
     //string to specify SiPixelQuality label
     SiPixelBadModuleToken_ = iC.esConsumes(edm::ESInputTag("", conf.getParameter<std::string>("SiPixelQualityLabel")));
   }
   if (use_LorentzAngle_DB_) {
     SiPixelLorentzAngleToken_ = iC.esConsumes();
   }
   if (AddPixelInefficiency && !pixelEfficiencies_.FromConfig) {
     // TODO: in practice the bunchspacing is known at MixingModule
     // construction time, and thus we could declare the consumption of
     // the actual product. In principle, however, MixingModule is
     // capable of updating (parts of) its configuration from the
     // EventSetup, so if that capability is really needed we'd need to
     // invent something new (similar to mayConsume in the ESProducer
     // side). So for now, let's consume both payloads.
     SiPixelDynamicInefficiencyToken_ = iC.esConsumes();
   }
   if (KillBadFEDChannels) {
     scenarioProbabilityToken_ = iC.esConsumes();
     PixelFEDChannelCollectionMapToken_ = iC.esConsumes();
   }
 
   LogInfo("PixelDigitizer ") << "SiPixelDigitizerAlgorithm constructed"
                              << "Configuration parameters:"
                              << "Threshold/Gain = "
                              << "threshold in electron FPix = " << theThresholdInE_FPix
                              << "threshold in electron BPix = " << theThresholdInE_BPix
                              << "threshold in electron BPix Layer1 = " << theThresholdInE_BPix_L1
                              << "threshold in electron BPix Layer2 = " << theThresholdInE_BPix_L2 << " "
                              << theElectronPerADC << " " << theAdcFullScale << " The delta cut-off is set to " << tMax
                              << " pix-inefficiency " << AddPixelInefficiency;
 
   LogInfo("PixelDigitizer ") << " SiPixelDigitizerAlgorithm constructed  with  UseReweighting " << UseReweighting
                              << " and store_SimHitEntryExitPoints_ " << store_SimHitEntryExitPoints_ << " \n";
 
   TheNewSiPixelChargeReweightingAlgorithmClass = std::make_unique<SiPixelChargeReweightingAlgorithm>(conf, iC);
 }

◆ ~SiPixelDigitizerAlgorithm()

SiPixelDigitizerAlgorithm::~SiPixelDigitizerAlgorithm ( )

Definition at line 454 of file SiPixelDigitizerAlgorithm.cc.

References LogDebug.

                                                       {
   LogDebug("PixelDigitizer") << "SiPixelDigitizerAlgorithm deleted";
 }

Member Function Documentation

◆ accumulateSimHits()

void SiPixelDigitizerAlgorithm::accumulateSimHits	(	const std::vector< PSimHit >::const_iterator	inputBegin,
		const std::vector< PSimHit >::const_iterator	inputEnd,
		const size_t	inputBeginGlobalIndex,
		const unsigned int	tofBin,
		const PixelGeomDetUnit *	pixdet,
		const GlobalVector &	bfield,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 807 of file SiPixelDigitizerAlgorithm.cc.

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

                                                                                 {
   // produce SignalPoint's for all SimHit's in detector
   // Loop over hits
 
   uint32_t detId = pixdet->geographicalId().rawId();
   size_t simHitGlobalIndex = inputBeginGlobalIndex;  // This needs to stored to create the digi-sim link later
   for (std::vector<PSimHit>::const_iterator ssbegin = inputBegin; ssbegin != inputEnd; ++ssbegin, ++simHitGlobalIndex) {
     // skip hits not in this detector.
     if ((*ssbegin).detUnitId() != detId) {
       continue;
     }
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << (*ssbegin).particleType() << " " << (*ssbegin).pabs() << " "
                                 << (*ssbegin).energyLoss() << " " << (*ssbegin).tof() << " " << (*ssbegin).trackId()
                                 << " " << (*ssbegin).processType() << " " << (*ssbegin).detUnitId()
                                 << (*ssbegin).entryPoint() << " " << (*ssbegin).exitPoint();
 #endif
 
     std::vector<EnergyDepositUnit> ionization_points;
     std::vector<SignalPoint> collection_points;
 
     // fill collection_points for this SimHit, indpendent of topology
     // Check the TOF cut
     if (((*ssbegin).tof() - pixdet->surface().toGlobal((*ssbegin).localPosition()).mag() / 30.) >= theTofLowerCut &&
         ((*ssbegin).tof() - pixdet->surface().toGlobal((*ssbegin).localPosition()).mag() / 30.) <= theTofUpperCut) {
       primary_ionization(*ssbegin, ionization_points, engine);  // fills _ionization_points
       drift(*ssbegin,
             pixdet,
             bfield,
             tTopo,
             ionization_points,
             collection_points);  // transforms _ionization_points to collection_points
       // compute induced signal on readout elements and add to _signal
       induce_signal(inputBegin,
                     inputEnd,
                     *ssbegin,
                     simHitGlobalIndex,
                     inputBeginGlobalIndex,
                     tofBin,
                     pixdet,
                     collection_points);  // 1st 3 args needed only for SimHit<-->Digi link
     }                                    //  end if
   }                                      // end for
 }

◆ add_noise()

void SiPixelDigitizerAlgorithm::add_noise	(	const PixelGeomDetUnit *	pixdet,
		float	thePixelThreshold,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 1798 of file SiPixelDigitizerAlgorithm.cc.

References _signal, addChargeVCALSmearing, addNoisyPixels, LaserClient_cfi::Amplitude, officialStyle::chan, GeomDet::geographicalId(), mps_fire::i, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::ix(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy(), LogDebug, PixelTopology::ncolumns(), hgchebackDigitizer_cfi::noise, PixelTopology::nrows(), PixelDigi::pixelToChannel(), DetId::rawId(), PixelGeomDetUnit::specificTopology(), theNoiseInElectrons, theNoiser, theReadoutNoise, theThresholdInE_BPix, and theThresholdInE_FPix.

Referenced by digitize().

                                                                         {
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " enter add_noise " << theNoiseInElectrons;
 #endif
 
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
 
   // First add noise to hit pixels
   float theSmearedChargeRMS = 0.0;
 
   for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); i++) {
     if (addChargeVCALSmearing) {
       if ((*i).second < 3000) {
         theSmearedChargeRMS = 543.6 - (*i).second * 0.093;
       } else if ((*i).second < 6000) {
         theSmearedChargeRMS = 307.6 - (*i).second * 0.01;
       } else {
         theSmearedChargeRMS = -432.4 + (*i).second * 0.123;
       }
 
       // Noise from Vcal smearing:
       float noise_ChargeVCALSmearing = theSmearedChargeRMS * CLHEP::RandGaussQ::shoot(engine, 0., 1.);
       // Noise from full readout:
       float noise = CLHEP::RandGaussQ::shoot(engine, 0., theReadoutNoise);
 
       if (((*i).second + digitizerUtility::Amplitude(noise + noise_ChargeVCALSmearing, -1.)) < 0.) {
         (*i).second.set(0);
       } else {
         (*i).second += digitizerUtility::Amplitude(noise + noise_ChargeVCALSmearing, -1.);
       }
 
     }  // End if addChargeVCalSmearing
     else {
       // Noise: ONLY full READOUT Noise.
       // Use here the FULL readout noise, including TBM,ALT,AOH,OPT-REC.
       float noise = CLHEP::RandGaussQ::shoot(engine, 0., theReadoutNoise);
 
       if (((*i).second + digitizerUtility::Amplitude(noise, -1.)) < 0.) {
         (*i).second.set(0);
       } else {
         (*i).second += digitizerUtility::Amplitude(noise, -1.);
       }
     }  // end if only Noise from full readout
   }
 
   if (!addNoisyPixels)  // Option to skip noise in non-hit pixels
     return;
 
   const PixelTopology* topol = &pixdet->specificTopology();
   int numColumns = topol->ncolumns();  // det module number of cols&rows
   int numRows = topol->nrows();
 
   // Add noise on non-hit pixels
   // Use here the pixel noise
   int numberOfPixels = (numRows * numColumns);
   std::map<int, float, std::less<int> > otherPixels;
   std::map<int, float, std::less<int> >::iterator mapI;
 
   theNoiser->generate(numberOfPixels,
                       thePixelThreshold,    //thr. in un. of nois
                       theNoiseInElectrons,  // noise in elec.
                       otherPixels,
                       engine);
 
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " Add noisy pixels " << numRows << " " << numColumns << " " << theNoiseInElectrons
                               << " " << theThresholdInE_FPix << theThresholdInE_BPix << " " << numberOfPixels << " "
                               << otherPixels.size();
 #endif
 
   // Add noisy pixels
   for (mapI = otherPixels.begin(); mapI != otherPixels.end(); mapI++) {
     int iy = ((*mapI).first) / numRows;
     int ix = ((*mapI).first) - (iy * numRows);
 
     // Keep for a while for testing.
     if (iy < 0 || iy > (numColumns - 1))
       LogWarning("Pixel Geometry") << " error in iy " << iy;
     if (ix < 0 || ix > (numRows - 1))
       LogWarning("Pixel Geometry") << " error in ix " << ix;
 
     int chan = PixelDigi::pixelToChannel(ix, iy);
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << " Storing noise = " << (*mapI).first << " " << (*mapI).second << " " << ix << " "
                                 << iy << " " << chan;
 #endif
 
     if (theSignal[chan] == 0) {
       //      float noise = float( (*mapI).second );
       int noise = int((*mapI).second);
       theSignal[chan] = digitizerUtility::Amplitude(noise, -1.);
     }
   }
 }

◆ calcQ()

double SiPixelDigitizerAlgorithm::calcQ ( float x ) const

inlineprivate

Definition at line 437 of file SiPixelDigitizerAlgorithm.h.

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

Referenced by induce_signal().

                               {
     // need erf(x/sqrt2)
     //float x2=0.5*x*x;
     //float a=0.147;
     //double erf=sqrt(1.0f-exp( -1.0f*x2*( (4/M_PI)+a*x2)/(1.0+a*x2)));
     //if (x<0.) erf*=-1.0;
     //return 0.5*(1.0-erf);
 
     auto xx = std::min(0.5f * x * x, 12.5f);
     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));
   }

◆ calculateInstlumiFactor() [1/2]

void SiPixelDigitizerAlgorithm::calculateInstlumiFactor ( PileupMixingContent * puInfo )

Definition at line 861 of file SiPixelDigitizerAlgorithm.cc.

References PileupMixingContent::getMix_bunchCrossing(), PileupMixingContent::getMix_TrueInteractions(), mps_fire::i, dqmiolumiharvest::j, dqmiodumpmetadata::n, AlCaHLTBitMon_ParallelJobs::p, pixelEfficiencies_, displacedMuons_cfi::pu, SiPixelDigitizerAlgorithm::PixelEfficiencies::pu_scale, SiPixelDigitizerAlgorithm::PixelEfficiencies::theInstLumiScaleFactor, and SiPixelDigitizerAlgorithm::PixelEfficiencies::thePUEfficiency.

Referenced by PreMixingSiPixelWorker::put().

                                                                                    {
   //Instlumi scalefactor calculating for dynamic inefficiency
 
   if (puInfo) {
     const std::vector<int>& bunchCrossing = puInfo->getMix_bunchCrossing();
     const std::vector<float>& TrueInteractionList = puInfo->getMix_TrueInteractions();
     //const int bunchSpacing = puInfo->getMix_bunchSpacing();
 
     int pui = 0, p = 0;
     std::vector<int>::const_iterator pu;
     std::vector<int>::const_iterator pu0 = bunchCrossing.end();
 
     for (pu = bunchCrossing.begin(); pu != bunchCrossing.end(); ++pu) {
       if (*pu == 0) {
         pu0 = pu;
         p = pui;
       }
       pui++;
     }
     if (pu0 != bunchCrossing.end()) {
       for (size_t i = 0, n = pixelEfficiencies_.thePUEfficiency.size(); i < n; i++) {
         double instlumi = TrueInteractionList.at(p) * pixelEfficiencies_.theInstLumiScaleFactor;
         double instlumi_pow = 1.;
         pixelEfficiencies_.pu_scale[i] = 0;
         for (size_t j = 0; j < pixelEfficiencies_.thePUEfficiency[i].size(); j++) {
           pixelEfficiencies_.pu_scale[i] += instlumi_pow * pixelEfficiencies_.thePUEfficiency[i][j];
           instlumi_pow *= instlumi;
         }
       }
     }
   } else {
     for (int i = 0, n = pixelEfficiencies_.thePUEfficiency.size(); i < n; i++) {
       pixelEfficiencies_.pu_scale[i] = 1.;
     }
   }
 }

◆ calculateInstlumiFactor() [2/2]

void SiPixelDigitizerAlgorithm::calculateInstlumiFactor	(	const std::vector< PileupSummaryInfo > &	ps,
		int	bunchSpacing
	)

Definition at line 899 of file SiPixelDigitizerAlgorithm.cc.

References mps_fire::i, dqmiolumiharvest::j, dqmiodumpmetadata::n, AlCaHLTBitMon_ParallelJobs::p, pixelEfficiencies_, SiPixelDigitizerAlgorithm::PixelEfficiencies::pu_scale, SiPixelDigitizerAlgorithm::PixelEfficiencies::theInstLumiScaleFactor, and SiPixelDigitizerAlgorithm::PixelEfficiencies::thePUEfficiency.

                                                                                                                 {
   int p = -1;
   for (unsigned int i = 0; i < ps.size(); i++)
     if (ps[i].getBunchCrossing() == 0)
       p = i;
 
   if (p >= 0) {
     for (size_t i = 0, n = pixelEfficiencies_.thePUEfficiency.size(); i < n; i++) {
       double instlumi = ps[p].getTrueNumInteractions() * pixelEfficiencies_.theInstLumiScaleFactor;
       double instlumi_pow = 1.;
       pixelEfficiencies_.pu_scale[i] = 0;
       for (size_t j = 0; j < pixelEfficiencies_.thePUEfficiency[i].size(); j++) {
         pixelEfficiencies_.pu_scale[i] += instlumi_pow * pixelEfficiencies_.thePUEfficiency[i][j];
         instlumi_pow *= instlumi;
       }
     }
   } else {
     for (int i = 0, n = pixelEfficiencies_.thePUEfficiency.size(); i < n; i++) {
       pixelEfficiencies_.pu_scale[i] = 1.;
     }
   }
 }

◆ chooseScenario() [1/2]

std::unique_ptr< PixelFEDChannelCollection > SiPixelDigitizerAlgorithm::chooseScenario	(	PileupMixingContent *	puInfo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 973 of file SiPixelDigitizerAlgorithm.cc.

References PileupMixingContent::getMix_bunchCrossing(), PileupMixingContent::getMix_TrueInteractions(), SiPixelQualityProbabilities::getProbabilities(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, AlCaHLTBitMon_ParallelJobs::p, pixelEfficiencies_, SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelFEDChannelCollection_, displacedMuons_cfi::pu, quality_map, scenarioProbability_, AlCaHLTBitMon_QueryRunRegistry::string, and x.

Referenced by PreMixingSiPixelWorker::put().

                                                                                                                    {
   //Determine scenario to use for the current event based on pileup information
 
   std::unique_ptr<PixelFEDChannelCollection> PixelFEDChannelCollection_ = nullptr;
   pixelEfficiencies_.PixelFEDChannelCollection_ = nullptr;
   if (puInfo) {
     const std::vector<int>& bunchCrossing = puInfo->getMix_bunchCrossing();
     const std::vector<float>& TrueInteractionList = puInfo->getMix_TrueInteractions();
 
     int pui = 0, p = 0;
     std::vector<int>::const_iterator pu;
     std::vector<int>::const_iterator pu0 = bunchCrossing.end();
 
     for (pu = bunchCrossing.begin(); pu != bunchCrossing.end(); ++pu) {
       if (*pu == 0) {
         pu0 = pu;
         p = pui;
       }
       pui++;
     }
 
     if (pu0 != bunchCrossing.end()) {
       unsigned int PUBin = TrueInteractionList.at(p);  // case delta PU=1, fix me
       const auto& theProbabilitiesPerScenario = scenarioProbability_->getProbabilities(PUBin);
       std::vector<double> probabilities;
       probabilities.reserve(theProbabilitiesPerScenario.size());
       for (auto it = theProbabilitiesPerScenario.begin(); it != theProbabilitiesPerScenario.end(); it++) {
         probabilities.push_back(it->second);
       }
 
       CLHEP::RandGeneral randGeneral(*engine, &(probabilities.front()), probabilities.size());
       double x = randGeneral.shoot();
       unsigned int index = x * probabilities.size() - 1;
       const std::string& scenario = theProbabilitiesPerScenario.at(index).first;
 
       PixelFEDChannelCollection_ = std::make_unique<PixelFEDChannelCollection>(quality_map->at(scenario));
       pixelEfficiencies_.PixelFEDChannelCollection_ =
           std::make_unique<PixelFEDChannelCollection>(quality_map->at(scenario));
     }
   }
   return PixelFEDChannelCollection_;
 }

◆ chooseScenario() [2/2]

std::unique_ptr< PixelFEDChannelCollection > SiPixelDigitizerAlgorithm::chooseScenario	(	const std::vector< PileupSummaryInfo > &	ps,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 926 of file SiPixelDigitizerAlgorithm.cc.

References SiPixelQualityProbabilities::getProbabilities(), mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, AlCaHLTBitMon_ParallelJobs::p, pixelEfficiencies_, SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelFEDChannelCollection_, displacedMuons_cfi::pu, quality_map, scenarioProbability_, AlCaHLTBitMon_QueryRunRegistry::string, and x.

                                                                           {
   std::unique_ptr<PixelFEDChannelCollection> PixelFEDChannelCollection_ = nullptr;
   pixelEfficiencies_.PixelFEDChannelCollection_ = nullptr;
 
   std::vector<int> bunchCrossing;
   std::vector<float> TrueInteractionList;
 
   for (unsigned int i = 0; i < ps.size(); i++) {
     bunchCrossing.push_back(ps[i].getBunchCrossing());
     TrueInteractionList.push_back(ps[i].getTrueNumInteractions());
   }
 
   int pui = 0, p = 0;
   std::vector<int>::const_iterator pu;
   std::vector<int>::const_iterator pu0 = bunchCrossing.end();
 
   for (pu = bunchCrossing.begin(); pu != bunchCrossing.end(); ++pu) {
     if (*pu == 0) {
       pu0 = pu;
       p = pui;
     }
     pui++;
   }
 
   if (pu0 != bunchCrossing.end()) {
     unsigned int PUBin = TrueInteractionList.at(p);  // case delta PU=1, fix me
     const auto& theProbabilitiesPerScenario = scenarioProbability_->getProbabilities(PUBin);
     std::vector<double> probabilities;
     probabilities.reserve(theProbabilitiesPerScenario.size());
     for (auto it = theProbabilitiesPerScenario.begin(); it != theProbabilitiesPerScenario.end(); it++) {
       probabilities.push_back(it->second);
     }
 
     CLHEP::RandGeneral randGeneral(*engine, &(probabilities.front()), probabilities.size());
     double x = randGeneral.shoot();
     unsigned int index = x * probabilities.size() - 1;
     const std::string& scenario = theProbabilitiesPerScenario.at(index).first;
 
     PixelFEDChannelCollection_ = std::make_unique<PixelFEDChannelCollection>(quality_map->at(scenario));
     pixelEfficiencies_.PixelFEDChannelCollection_ =
         std::make_unique<PixelFEDChannelCollection>(quality_map->at(scenario));
   }
 
   return PixelFEDChannelCollection_;
 }

◆ digitize()

void SiPixelDigitizerAlgorithm::digitize	(	const PixelGeomDetUnit *	pixdet,
		std::vector< PixelDigi > &	digis,
		std::vector< PixelDigiSimLink > &	simlinks,
		std::vector< PixelDigiAddTempInfo > &	newClass_Digi_extra,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 1029 of file SiPixelDigitizerAlgorithm.cc.

References _signal, add_noise(), addNoise, AddPixelInefficiency, addThresholdSmearing, Surface::bounds(), Exception, GeomDet::geographicalId(), GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), TrackerTopology::layer(), LogDebug, make_digis(), module_killing_conf(), module_killing_DB(), PixelTopology::ncolumns(), PixelTopology::nrows(), GeomDetEnumerators::P1PXB, pixel_inefficiency(), pixel_inefficiency_db(), GeomDetEnumerators::PixelBarrel, pixelEfficiencies_, DetId::rawId(), GeomDet::specificSurface(), PixelGeomDetUnit::specificTopology(), GeomDet::subDetector(), theNoiseInElectrons, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, theThresholdInE_FPix, theThresholdSmearing_BPix, theThresholdSmearing_BPix_L1, theThresholdSmearing_BPix_L2, theThresholdSmearing_FPix, Bounds::thickness(), PixelGeomDetUnit::type(), use_deadmodule_DB_, use_ineff_from_db_, and use_module_killing_.

Referenced by PreMixingSiPixelWorker::put().

                                                                        {
   // Pixel Efficiency moved from the constructor to this method because
   // the information of the det are not available in the constructor
   // Efficiency parameters. 0 - no inefficiency, 1-low lumi, 10-high lumi
 
   uint32_t detID = pixdet->geographicalId().rawId();
   const signal_map_type& theSignal = _signal[detID];
 
   // Noise already defined in electrons
   // thePixelThresholdInE = thePixelThreshold * theNoiseInElectrons ;
   // Find the threshold in noise units, needed for the noiser.
 
   float thePixelThresholdInE = 0.;
 
   if (theNoiseInElectrons > 0.) {
     if (pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()) {  // Barrel modules
       int lay = tTopo->layer(detID);
       if (addThresholdSmearing) {
         if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelBarrel ||
             pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB) {
           if (lay == 1) {
             thePixelThresholdInE = CLHEP::RandGaussQ::shoot(
                 engine, theThresholdInE_BPix_L1, theThresholdSmearing_BPix_L1);  // gaussian smearing
           } else if (lay == 2) {
             thePixelThresholdInE = CLHEP::RandGaussQ::shoot(
                 engine, theThresholdInE_BPix_L2, theThresholdSmearing_BPix_L2);  // gaussian smearing
           } else {
             thePixelThresholdInE =
                 CLHEP::RandGaussQ::shoot(engine, theThresholdInE_BPix, theThresholdSmearing_BPix);  // gaussian smearing
           }
         }
       } else {
         if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelBarrel ||
             pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB) {
           if (lay == 1) {
             thePixelThresholdInE = theThresholdInE_BPix_L1;
           } else if (lay == 2) {
             thePixelThresholdInE = theThresholdInE_BPix_L2;
           } else {
             thePixelThresholdInE = theThresholdInE_BPix;  // no smearing
           }
         }
       }
     } else if (pixdet->type().isTrackerPixel()) {  // Forward disks modules
       if (addThresholdSmearing) {
         thePixelThresholdInE =
             CLHEP::RandGaussQ::shoot(engine, theThresholdInE_FPix, theThresholdSmearing_FPix);  // gaussian smearing
       } else {
         thePixelThresholdInE = theThresholdInE_FPix;  // no smearing
       }
     } else {
       throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;
     }
   }
 
 #ifdef TP_DEBUG
   const PixelTopology* topol = &pixdet->specificTopology();
   int numColumns = topol->ncolumns();  // det module number of cols&rows
   int numRows = topol->nrows();
   // full detector thickness
   float moduleThickness = pixdet->specificSurface().bounds().thickness();
   LogDebug("PixelDigitizer") << " PixelDigitizer " << numColumns << " " << numRows << " " << moduleThickness;
 #endif
 
   if (addNoise)
     add_noise(pixdet, thePixelThresholdInE / theNoiseInElectrons, engine);  // generate noise
 
   // Do only if needed
 
   if ((AddPixelInefficiency) && (!theSignal.empty()))
     pixel_inefficiency(pixelEfficiencies_, pixdet, tTopo, engine);  // Kill some pixels
 
   if (use_ineff_from_db_ && (!theSignal.empty()))
     pixel_inefficiency_db(detID);
 
   if (use_module_killing_) {
     if (use_deadmodule_DB_) {  // remove dead modules using DB
       module_killing_DB(detID);
     } else {  // remove dead modules using the list in cfg file
       module_killing_conf(detID);
     }
   }
 
   make_digis(thePixelThresholdInE, detID, pixdet, digis, simlinks, newClass_Digi_extra, tTopo);
 
 #ifdef TP_DEBUG
   LogDebug("PixelDigitizer") << "[SiPixelDigitizerAlgorithm] converted " << digis.size() << " PixelDigis in DetUnit"
                              << detID;
 #endif
 }

◆ drift()

void SiPixelDigitizerAlgorithm::drift	(	const PSimHit &	hit,
		const PixelGeomDetUnit *	pixdet,
		const GlobalVector &	bfield,
		const TrackerTopology *	tTopo,
		const std::vector< EnergyDepositUnit > &	ionization_points,
		std::vector< SignalPoint > &	collection_points
	)		const

private

Definition at line 1260 of file SiPixelDigitizerAlgorithm.cc.

References AddPixelAging, alpha2Order, Surface::bounds(), Dist300, DriftDirection(), hcalRecHitTable_cff::energy, JetChargeProducer_cfi::exp, mps_fire::i, LogDebug, pixel_aging(), pixelAging_, Sigma0, GeomDet::specificSurface(), mathSSE::sqrt(), Bounds::thickness(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by accumulateSimHits().

                                                                                        {
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " enter drift ";
 #endif
 
   collection_points.resize(ionization_points.size());  // set size
 
   LocalVector driftDir = DriftDirection(pixdet, bfield, hit.detUnitId());  // get the charge drift direction
   if (driftDir.z() == 0.) {
     LogWarning("Magnetic field") << " pxlx: drift in z is zero ";
     return;
   }
 
   // tangent of Lorentz angle
   //float TanLorenzAngleX = driftDir.x()/driftDir.z();
   //float TanLorenzAngleY = 0.; // force to 0, driftDir.y()/driftDir.z();
 
   float TanLorenzAngleX, TanLorenzAngleY, dir_z, CosLorenzAngleX, CosLorenzAngleY;
   if (alpha2Order) {
     TanLorenzAngleX = driftDir.x();  // tangen of Lorentz angle
     TanLorenzAngleY = driftDir.y();
     dir_z = driftDir.z();                                                 // The z drift direction
     CosLorenzAngleX = 1. / sqrt(1. + TanLorenzAngleX * TanLorenzAngleX);  //cosine
     CosLorenzAngleY = 1. / sqrt(1. + TanLorenzAngleY * TanLorenzAngleY);  //cosine;
 
   } else {
     TanLorenzAngleX = driftDir.x();
     TanLorenzAngleY = 0.;                                                 // force to 0, driftDir.y()/driftDir.z();
     dir_z = driftDir.z();                                                 // The z drift direction
     CosLorenzAngleX = 1. / sqrt(1. + TanLorenzAngleX * TanLorenzAngleX);  //cosine to estimate the path length
     CosLorenzAngleY = 1.;
   }
 
   float moduleThickness = pixdet->specificSurface().bounds().thickness();
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " Lorentz Tan " << TanLorenzAngleX << " " << TanLorenzAngleY << " " << CosLorenzAngleX
                               << " " << CosLorenzAngleY << " " << moduleThickness * TanLorenzAngleX << " " << driftDir;
 #endif
 
   float Sigma_x = 1.;  // Charge spread
   float Sigma_y = 1.;
   float DriftDistance;  // Distance between charge generation and collection
   float DriftLength;    // Actual Drift Lentgh
   float Sigma;
 
   for (unsigned int i = 0; i != ionization_points.size(); i++) {
     float SegX, SegY, SegZ;  // position
     SegX = ionization_points[i].x();
     SegY = ionization_points[i].y();
     SegZ = ionization_points[i].z();
 
     // Distance from the collection plane
     //DriftDistance = (moduleThickness/2. + SegZ); // Drift to -z
     // Include explixitely the E drift direction (for CMS dir_z=-1)
     DriftDistance = moduleThickness / 2. - (dir_z * SegZ);  // Drift to -z
 
     if (DriftDistance <= 0.)
       LogDebug("PixelDigitizer ") << " <=0 " << DriftDistance << " " << i << " " << SegZ << " " << dir_z << " " << SegX
                                   << " " << SegY << " " << (moduleThickness / 2) << " " << ionization_points[i].energy()
                                   << " " << hit.particleType() << " " << hit.pabs() << " " << hit.energyLoss() << " "
                                   << hit.entryPoint() << " " << hit.exitPoint() << "\n";
 
     if (DriftDistance < 0.) {
       DriftDistance = 0.;
     } else if (DriftDistance > moduleThickness)
       DriftDistance = moduleThickness;
 
     // Assume full depletion now, partial depletion will come later.
     float XDriftDueToMagField = DriftDistance * TanLorenzAngleX;
     float YDriftDueToMagField = DriftDistance * TanLorenzAngleY;
 
     // Shift cloud center
     float CloudCenterX = SegX + XDriftDueToMagField;
     float CloudCenterY = SegY + YDriftDueToMagField;
 
     // Calculate how long is the charge drift path
     DriftLength = sqrt(DriftDistance * DriftDistance + XDriftDueToMagField * XDriftDueToMagField +
                        YDriftDueToMagField * YDriftDueToMagField);
 
     // What is the charge diffusion after this path
     Sigma = sqrt(DriftLength / Dist300) * Sigma0;
 
     // Project the diffusion sigma on the collection plane
     Sigma_x = Sigma / CosLorenzAngleX;
     Sigma_y = Sigma / CosLorenzAngleY;
 
     // Insert a charge loss due to Rad Damage here
     float energyOnCollector = ionization_points[i].energy();  // The energy that reaches the collector
 
     // add pixel aging
     if (AddPixelAging) {
       float kValue = pixel_aging(pixelAging_, pixdet, tTopo);
       energyOnCollector *= exp(-1 * kValue * DriftDistance / moduleThickness);
     }
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << " Dift DistanceZ= " << DriftDistance << " module thickness= " << moduleThickness
                                 << " Start Energy= " << ionization_points[i].energy()
                                 << " Energy after loss= " << energyOnCollector;
 #endif
     SignalPoint sp(CloudCenterX, CloudCenterY, Sigma_x, Sigma_y, hit.tof(), energyOnCollector);
 
     // Load the Charge distribution parameters
     collection_points[i] = (sp);
 
   }  // loop over ionization points, i.
 
 }  // end drift

◆ DriftDirection()

LocalVector SiPixelDigitizerAlgorithm::DriftDirection	(	const PixelGeomDetUnit *	pixdet,
		const GlobalVector &	bfield,
		const DetId &	detId
	)		const

private

Definition at line 2278 of file SiPixelDigitizerAlgorithm.cc.

References alpha2Order, mkfit::Config::Bfield, hcalRecHitTable_cff::detId, Exception, GeomDet::geographicalId(), SiPixelLorentzAngle::getLorentzAngle(), GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), LogDebug, GloballyPositioned< T >::position(), DetId::rawId(), GloballyPositioned< T >::rotation(), pfClustersFromCombinedCaloHF_cfi::scale, SiPixelLorentzAngle_, GeomDet::surface(), tanLorentzAnglePerTesla_BPix, tanLorentzAnglePerTesla_FPix, PixelGeomDetUnit::type(), and use_LorentzAngle_DB_.

Referenced by drift().

                                                                                 {
   Frame detFrame(pixdet->surface().position(), pixdet->surface().rotation());
   LocalVector Bfield = detFrame.toLocal(bfield);
 
   float alpha2_FPix;
   float alpha2_BPix;
   float alpha2;
 
   //float dir_x = -tanLorentzAnglePerTesla * Bfield.y();
   //float dir_y = +tanLorentzAnglePerTesla * Bfield.x();
   //float dir_z = -1.; // E field always in z direction, so electrons go to -z
   // The dir_z has to be +/- 1. !
   // LocalVector theDriftDirection = LocalVector(dir_x,dir_y,dir_z);
 
   float dir_x = 0.0f;
   float dir_y = 0.0f;
   float dir_z = 0.0f;
   float scale = 0.0f;
 
   uint32_t detID = pixdet->geographicalId().rawId();
 
   // Read Lorentz angle from cfg file:**************************************************************
 
   if (!use_LorentzAngle_DB_) {
     if (alpha2Order) {
       alpha2_FPix = tanLorentzAnglePerTesla_FPix * tanLorentzAnglePerTesla_FPix;
       alpha2_BPix = tanLorentzAnglePerTesla_BPix * tanLorentzAnglePerTesla_BPix;
     } else {
       alpha2_FPix = 0.0f;
       alpha2_BPix = 0.0f;
     }
 
     if (pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()) {  // barrel layers
       dir_x = -(tanLorentzAnglePerTesla_BPix * Bfield.y() + alpha2_BPix * Bfield.z() * Bfield.x());
       dir_y = +(tanLorentzAnglePerTesla_BPix * Bfield.x() - alpha2_BPix * Bfield.z() * Bfield.y());
       dir_z = -(1 + alpha2_BPix * Bfield.z() * Bfield.z());
       scale = -dir_z;
     } else if (pixdet->type().isTrackerPixel()) {  // forward disks
       dir_x = -(tanLorentzAnglePerTesla_FPix * Bfield.y() + alpha2_FPix * Bfield.z() * Bfield.x());
       dir_y = +(tanLorentzAnglePerTesla_FPix * Bfield.x() - alpha2_FPix * Bfield.z() * Bfield.y());
       dir_z = -(1 + alpha2_FPix * Bfield.z() * Bfield.z());
       scale = -dir_z;
     } else {
       throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;
     }
   }  // end: Read LA from cfg file.
 
   //Read Lorentz angle from DB:********************************************************************
   if (use_LorentzAngle_DB_) {
     float lorentzAngle = SiPixelLorentzAngle_->getLorentzAngle(detId);
     alpha2 = lorentzAngle * lorentzAngle;
     dir_x = -(lorentzAngle * Bfield.y() + alpha2 * Bfield.z() * Bfield.x());
     dir_y = +(lorentzAngle * Bfield.x() - alpha2 * Bfield.z() * Bfield.y());
     dir_z = -(1 + alpha2 * Bfield.z() * Bfield.z());
     scale = -dir_z;
   }  // end: Read LA from DataBase.
 
   LocalVector theDriftDirection = LocalVector(dir_x / scale, dir_y / scale, dir_z / scale);
 
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " The drift direction in local coordinate is " << theDriftDirection;
 #endif
 
   return theDriftDirection;
 }

◆ fillSimHitMaps()

void SiPixelDigitizerAlgorithm::fillSimHitMaps	(	std::vector< PSimHit >	simHits,
		const unsigned int	tofBin
	)

Definition at line 1646 of file SiPixelDigitizerAlgorithm.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, SimHitCollMap, SimHitMap, FastTrackerRecHitCombiner_cfi::simHits, ecaldqm::subdetID(), and DetId::subdetId().

                                                                                                     {
   // store here the SimHit map for later
   int printnum = 0;
   for (std::vector<PSimHit>::const_iterator it = simHits.begin(), itEnd = simHits.end(); it != itEnd;
        ++it, ++printnum) {
     unsigned int detID = (*it).detUnitId();
     unsigned int subdetID = DetId(detID).subdetId();
     subDetTofBin theSubDetTofBin = std::make_pair(subdetID, tofBin);
     SimHitMap[SimHitCollMap[theSubDetTofBin]].push_back(*it);
   }
 }

◆ fluctuateEloss()

void SiPixelDigitizerAlgorithm::fluctuateEloss	(	int	particleId,
		float	momentum,
		float	eloss,
		float	length,
		int	NumberOfSegments,
		float	elossVector[],
		CLHEP::HepRandomEngine *	engine
	)		const

private

Definition at line 1194 of file SiPixelDigitizerAlgorithm.cc.

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

Referenced by primary_ionization().

                                                                                    {
   // Get dedx for this track
   //float dedx;
   //if( length > 0.) dedx = eloss/length;
   //else dedx = eloss;
 
   double particleMass = 139.6;  // Mass in MeV, Assume pion
   pid = std::abs(pid);
   if (pid != 211) {  // Mass in MeV
     if (pid == 11)
       particleMass = 0.511;
     else if (pid == 13)
       particleMass = 105.7;
     else if (pid == 321)
       particleMass = 493.7;
     else if (pid == 2212)
       particleMass = 938.3;
   }
   // What is the track segment length.
   float segmentLength = length / NumberOfSegs;
 
   // Generate charge fluctuations.
   float de = 0.;
   float sum = 0.;
   double segmentEloss = (1000. * eloss) / NumberOfSegs;  //eloss in MeV
   for (int i = 0; i < NumberOfSegs; i++) {
     //       material,*,   momentum,energy,*, *,  mass
     //myglandz_(14.,segmentLength,2.,2.,dedx,de,0.14);
     // The G4 routine needs momentum in MeV, mass in Mev, delta-cut in MeV,
     // track segment length in mm, segment eloss in MeV
     // Returns fluctuated eloss in MeV
     double deltaCutoff = tMax;  // the cutoff is sometimes redefined inside, so fix it.
     de = fluctuate->SampleFluctuations(double(particleMomentum * 1000.),
                                        particleMass,
                                        deltaCutoff,
                                        double(segmentLength * 10.),
                                        segmentEloss,
                                        engine) /
          1000.;  //convert to GeV
     elossVector[i] = de;
     sum += de;
   }
 
   if (sum > 0.) {  // If fluctuations give eloss>0.
     // Rescale to the same total eloss
     float ratio = eloss / sum;
 
     for (int ii = 0; ii < NumberOfSegs; ii++)
       elossVector[ii] = ratio * elossVector[ii];
   } else {  // If fluctuations gives 0 eloss
     float averageEloss = eloss / NumberOfSegs;
     for (int ii = 0; ii < NumberOfSegs; ii++)
       elossVector[ii] = averageEloss;
   }
   return;
 }

◆ induce_signal()

void SiPixelDigitizerAlgorithm::induce_signal	(	std::vector< PSimHit >::const_iterator	inputBegin,
		std::vector< PSimHit >::const_iterator	inputEnd,
		const PSimHit &	hit,
		const size_t	hitIndex,
		const size_t	FirstHitIndex,
		const unsigned int	tofBin,
		const PixelGeomDetUnit *	pixdet,
		const std::vector< SignalPoint > &	collection_points
	)

private

Definition at line 1376 of file SiPixelDigitizerAlgorithm.cc.

References _signal, LaserClient_cfi::Amplitude, calcQ(), officialStyle::chan, Topology::channel(), PixelDigi::channelToPixel(), PixelTestBeamValidation_cfi::Charge, ClusterWidth, hcalRecHitTable_cff::detId, GeomDet::geographicalId(), mps_fire::i, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::ix(), ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::endcap::iy(), Topology::localPosition(), LogDebug, makeDigiSimLinks_, Topology::measurementPosition(), PixelTopology::ncolumns(), PixelTopology::nrows(), PixelTopology::pitch(), PixelDigi::pixelToChannel(), DetId::rawId(), VtxSmearedHGCALCloseBy_cfi::SigmaX, VtxSmearedHGCALCloseBy_cfi::SigmaY, PixelGeomDetUnit::specificTopology(), store_SimHitEntryExitPoints_, TheNewSiPixelChargeReweightingAlgorithmClass, UseReweighting, x, PV2DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::x(), y, PV2DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by accumulateSimHits().

                                                                                                {
   // X  - Rows, Left-Right, 160, (1.6cm)   for barrel
   // Y  - Columns, Down-Up, 416, (6.4cm)
 
   const PixelTopology* topol = &pixdet->specificTopology();
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
 
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " enter induce_signal, " << topol->pitch().first << " " << topol->pitch().second;  //OK
 #endif
 
   // local map to store pixels hit by 1 Hit.
   typedef std::map<int, float, std::less<int> > hit_map_type;
   hit_map_type hit_signal;
 
   // map to store pixel integrals in the x and in the y directions
   std::map<int, float, std::less<int> > x, y;
 
   // Assign signals to readout channels and store sorted by channel number
 
   // Iterate over collection points on the collection plane
   for (std::vector<SignalPoint>::const_iterator i = collection_points.begin(); i != collection_points.end(); ++i) {
     float CloudCenterX = i->position().x();  // Charge position in x
     float CloudCenterY = i->position().y();  //                 in y
     float SigmaX = i->sigma_x();             // Charge spread in x
     float SigmaY = i->sigma_y();             //               in y
     float Charge = i->amplitude();           // Charge amplitude
 
     if (SigmaX == 0 || SigmaY == 0) {
       LogDebug("Pixel Digitizer") << SigmaX << " " << SigmaY << " cloud " << i->position().x() << " "
                                   << i->position().y() << " " << i->sigma_x() << " " << i->sigma_y() << " "
                                   << i->amplitude() << "\n";
     }
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << " cloud " << i->position().x() << " " << i->position().y() << " " << i->sigma_x()
                                 << " " << i->sigma_y() << " " << i->amplitude();
 #endif
 
     // Find the maximum cloud spread in 2D plane , assume 3*sigma
     float CloudRight = CloudCenterX + ClusterWidth * SigmaX;
     float CloudLeft = CloudCenterX - ClusterWidth * SigmaX;
     float CloudUp = CloudCenterY + ClusterWidth * SigmaY;
     float CloudDown = CloudCenterY - ClusterWidth * SigmaY;
 
     // Define 2D cloud limit points
     LocalPoint PointRightUp = LocalPoint(CloudRight, CloudUp);
     LocalPoint PointLeftDown = LocalPoint(CloudLeft, CloudDown);
 
     // This points can be located outside the sensor area.
     // The conversion to measurement point does not check for that
     // so the returned pixel index might be wrong (outside range).
     // We rely on the limits check below to fix this.
     // But remember whatever we do here THE CHARGE OUTSIDE THE ACTIVE
     // PIXEL AREA IS LOST, it should not be collected.
 
     // Convert the 2D points to pixel indices
     MeasurementPoint mp = topol->measurementPosition(PointRightUp);  //OK
 
     int IPixRightUpX = int(floor(mp.x()));
     int IPixRightUpY = int(floor(mp.y()));
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << " right-up " << PointRightUp << " " << mp.x() << " " << mp.y() << " " << IPixRightUpX
                                 << " " << IPixRightUpY;
 #endif
 
     mp = topol->measurementPosition(PointLeftDown);  //OK
 
     int IPixLeftDownX = int(floor(mp.x()));
     int IPixLeftDownY = int(floor(mp.y()));
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << " left-down " << PointLeftDown << " " << mp.x() << " " << mp.y() << " "
                                 << IPixLeftDownX << " " << IPixLeftDownY;
 #endif
 
     // Check detector limits to correct for pixels outside range.
     int numColumns = topol->ncolumns();  // det module number of cols&rows
     int numRows = topol->nrows();
 
     IPixRightUpX = numRows > IPixRightUpX ? IPixRightUpX : numRows - 1;
     IPixRightUpY = numColumns > IPixRightUpY ? IPixRightUpY : numColumns - 1;
     IPixLeftDownX = 0 < IPixLeftDownX ? IPixLeftDownX : 0;
     IPixLeftDownY = 0 < IPixLeftDownY ? IPixLeftDownY : 0;
 
     x.clear();  // clear temporary integration array
     y.clear();
 
     // First integrate charge strips in x
     int ix;                                               // TT for compatibility
     for (ix = IPixLeftDownX; ix <= IPixRightUpX; ix++) {  // loop over x index
       float xUB, xLB, UpperBound, LowerBound;
 
       // Why is set to 0 if ix=0, does it meen that we accept charge
       // outside the sensor? CHeck How it was done in ORCA?
       //if(ix == 0) LowerBound = 0.;
       if (ix == 0 || SigmaX == 0.)  // skip for surface segemnts
         LowerBound = 0.;
       else {
         mp = MeasurementPoint(float(ix), 0.0);
         xLB = topol->localPosition(mp).x();
         LowerBound = 1 - calcQ((xLB - CloudCenterX) / SigmaX);
       }
 
       if (ix == numRows - 1 || SigmaX == 0.)
         UpperBound = 1.;
       else {
         mp = MeasurementPoint(float(ix + 1), 0.0);
         xUB = topol->localPosition(mp).x();
         UpperBound = 1. - calcQ((xUB - CloudCenterX) / SigmaX);
       }
 
       float TotalIntegrationRange = UpperBound - LowerBound;  // get strip
       x[ix] = TotalIntegrationRange;                          // save strip integral
       if (SigmaX == 0 || SigmaY == 0)
         LogDebug("Pixel Digitizer") << TotalIntegrationRange << " " << ix << "\n";
     }
 
     // Now integrate strips in y
     int iy;                                               // TT for compatibility
     for (iy = IPixLeftDownY; iy <= IPixRightUpY; iy++) {  //loope over y ind
       float yUB, yLB, UpperBound, LowerBound;
 
       if (iy == 0 || SigmaY == 0.)
         LowerBound = 0.;
       else {
         mp = MeasurementPoint(0.0, float(iy));
         yLB = topol->localPosition(mp).y();
         LowerBound = 1. - calcQ((yLB - CloudCenterY) / SigmaY);
       }
 
       if (iy == numColumns - 1 || SigmaY == 0.)
         UpperBound = 1.;
       else {
         mp = MeasurementPoint(0.0, float(iy + 1));
         yUB = topol->localPosition(mp).y();
         UpperBound = 1. - calcQ((yUB - CloudCenterY) / SigmaY);
       }
 
       float TotalIntegrationRange = UpperBound - LowerBound;
       y[iy] = TotalIntegrationRange;  // save strip integral
       if (SigmaX == 0 || SigmaY == 0)
         LogDebug("Pixel Digitizer") << TotalIntegrationRange << " " << iy << "\n";
     }
 
     // Get the 2D charge integrals by folding x and y strips
     int chan;
     for (ix = IPixLeftDownX; ix <= IPixRightUpX; ix++) {    // loop over x index
       for (iy = IPixLeftDownY; iy <= IPixRightUpY; iy++) {  //loope over y ind
 
         float ChargeFraction = Charge * x[ix] * y[iy];
 
         if (ChargeFraction > 0.) {
           chan = PixelDigi::pixelToChannel(ix, iy);  // Get index
           // Load the amplitude
           hit_signal[chan] += ChargeFraction;
         }  // endif
 
 #ifdef TP_DEBUG
         mp = MeasurementPoint(float(ix), float(iy));
         LocalPoint lp = topol->localPosition(mp);
         chan = topol->channel(lp);
         LogDebug("Pixel Digitizer") << " pixel " << ix << " " << iy << " - "
                                     << " " << chan << " " << ChargeFraction << " " << mp.x() << " " << mp.y() << " "
                                     << lp.x() << " " << lp.y() << " "  // givex edge position
                                     << chan;                           // edge belongs to previous ?
 #endif
 
       }  // endfor iy
     }    //endfor ix
 
   }  // loop over charge distributions
 
   // Fill the global map with all hit pixels from this event
 
   bool reweighted = false;
   bool makeDSLinks = store_SimHitEntryExitPoints_ || makeDigiSimLinks_;
 
   size_t ReferenceIndex4CR = 0;
   if (UseReweighting) {
     if (hit.processType() == 0) {
       ReferenceIndex4CR = hitIndex;
       reweighted = TheNewSiPixelChargeReweightingAlgorithmClass->hitSignalReweight<digitizerUtility::Amplitude>(
           hit, hit_signal, hitIndex, ReferenceIndex4CR, tofBin, topol, detID, theSignal, hit.processType(), makeDSLinks);
     } else {
       std::vector<PSimHit>::const_iterator crSimHit = inputBegin;
       ReferenceIndex4CR = FirstHitIndex;
       // if the first hit in the same detId is not associated to the same trackId, try to find a better match
       if ((*inputBegin).trackId() != hit.trackId()) {
         // loop over all the hit from the 1st in the same detId to the hit itself to find the primary particle of the same trackId
         uint32_t detId = pixdet->geographicalId().rawId();
         size_t localIndex = FirstHitIndex;
         for (std::vector<PSimHit>::const_iterator ssbegin = inputBegin; localIndex < hitIndex;
              ++ssbegin, ++localIndex) {
           if ((*ssbegin).detUnitId() != detId) {
             continue;
           }
           if ((*ssbegin).trackId() == hit.trackId() && (*ssbegin).processType() == 0) {
             crSimHit = ssbegin;
             ReferenceIndex4CR = localIndex;
             break;
           }
         }
       }
 
       reweighted = TheNewSiPixelChargeReweightingAlgorithmClass->hitSignalReweight<digitizerUtility::Amplitude>(
           (*crSimHit),
           hit_signal,
           hitIndex,
           ReferenceIndex4CR,
           tofBin,
           topol,
           detID,
           theSignal,
           hit.processType(),
           makeDSLinks);
     }
   }
   if (!reweighted) {
     for (hit_map_type::const_iterator im = hit_signal.begin(); im != hit_signal.end(); ++im) {
       int chan = (*im).first;
       if (ReferenceIndex4CR == 0) {
         // no determination has been done previously because !UseReweighting
         // we need to determine it now:
         if (hit.processType() == 0)
           ReferenceIndex4CR = hitIndex;
         else {
           ReferenceIndex4CR = FirstHitIndex;
           // if the first hit in the same detId is not associated to the same trackId, try to find a better match
           if ((*inputBegin).trackId() != hit.trackId()) {
             // loop on all the hit from the 1st of the collection to the hit itself to find the Primary particle of the same trackId
             uint32_t detId = pixdet->geographicalId().rawId();
             size_t localIndex = FirstHitIndex;
             for (std::vector<PSimHit>::const_iterator ssbegin = inputBegin; localIndex < hitIndex;
                  ++ssbegin, ++localIndex) {
               if ((*ssbegin).detUnitId() != detId) {
                 continue;
               }
               if ((*ssbegin).trackId() == hit.trackId() && (*ssbegin).processType() == 0) {
                 ReferenceIndex4CR = localIndex;
                 break;
               }
             }
           }
         }
       }
       theSignal[chan] += (makeDSLinks ? digitizerUtility::Amplitude(
                                             (*im).second, &hit, hitIndex, ReferenceIndex4CR, tofBin, (*im).second)
                                       : digitizerUtility::Amplitude((*im).second, (*im).second));
 
 #ifdef TP_DEBUG
       std::pair<int, int> ip = PixelDigi::channelToPixel(chan);
       LogDebug("Pixel Digitizer") << " pixel " << ip.first << " " << ip.second << " " << theSignal[chan];
 #endif
     }
   }
 
 }  // end induce_signal

◆ init()

void SiPixelDigitizerAlgorithm::init ( const edm::EventSetup & es )

Definition at line 93 of file SiPixelDigitizerAlgorithm.cc.

References mps_splice::entry, Exception, spr::find(), edm::EventSetup::getData(), PixelDigiSimLink::HighTof, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, pixelDigitizer_cfi::KillBadFEDChannels, PixelDigiSimLink::LowTof, notFound, AlCaHLTBitMon_QueryRunRegistry::string, HcalDetIdTransform::transform(), and pixelDigitizer_cfi::UseReweighting.

Referenced by PreMixingSiPixelWorker::initializeEvent().

                                                             {
   if (use_ineff_from_db_) {  // load gain calibration service fromdb...
     theSiPixelGainCalibrationService_->setESObjects(es);
   }
   if (use_deadmodule_DB_) {
     SiPixelBadModule_ = &es.getData(SiPixelBadModuleToken_);
   }
   if (use_LorentzAngle_DB_) {
     // Get Lorentz angle from DB record
     SiPixelLorentzAngle_ = &es.getData(SiPixelLorentzAngleToken_);
   }
   //gets the map and geometry from the DB (to kill ROCs)
   map_ = &es.getData(mapToken_);
   geom_ = &es.getData(geomToken_);
 
   if (KillBadFEDChannels) {
     scenarioProbability_ = &es.getData(scenarioProbabilityToken_);
     quality_map = &es.getData(PixelFEDChannelCollectionMapToken_);
 
     SiPixelQualityProbabilities::probabilityMap m_probabilities = scenarioProbability_->getProbability_Map();
     std::vector<std::string> allScenarios;
 
     std::transform(quality_map->begin(),
                    quality_map->end(),
                    std::back_inserter(allScenarios),
                    [](const PixelFEDChannelCollectionMap::value_type& pair) { return pair.first; });
 
     std::vector<std::string> allScenariosInProb;
 
     for (auto it = m_probabilities.begin(); it != m_probabilities.end(); ++it) {
       //int PUbin = it->first;
       for (const auto& entry : it->second) {
         auto scenario = entry.first;
         auto probability = entry.second;
         if (probability != 0) {
           if (std::find(allScenariosInProb.begin(), allScenariosInProb.end(), scenario) == allScenariosInProb.end()) {
             allScenariosInProb.push_back(scenario);
           }
         }  // if prob!=0
       }    // loop on the scenarios for that PU bin
     }      // loop on PU bins
 
     std::vector<std::string> notFound;
     std::copy_if(allScenariosInProb.begin(),
                  allScenariosInProb.end(),
                  std::back_inserter(notFound),
                  [&allScenarios](const std::string& arg) {
                    return (std::find(allScenarios.begin(), allScenarios.end(), arg) == allScenarios.end());
                  });
 
     if (!notFound.empty()) {
       for (const auto& entry : notFound) {
         LogError("SiPixelFEDChannelContainer")
             << "The requested scenario: " << entry << " is not found in the map!! \n";
       }
       throw cms::Exception("SiPixelDigitizerAlgorithm") << "Found: " << notFound.size()
                                                         << " missing scenario(s) in SiPixelStatusScenariosRcd while "
                                                            "present in SiPixelStatusScenarioProbabilityRcd \n";
     }
   }
   LogInfo("PixelDigitizer ") << " PixelDigitizerAlgorithm init \n";
   LogInfo("PixelDigitizer ") << " PixelDigitizerAlgorithm  --> UseReweighting " << UseReweighting << "\n";
   LogInfo("PixelDigitizer ") << " PixelDigitizerAlgorithm  -->  store_SimHitEntryExitPoints_ "
                              << store_SimHitEntryExitPoints_ << "\n";
   LogInfo("PixelDigitizer ") << " PixelDigitizerAlgorithm  -->  makeDigiSimLinks_ " << makeDigiSimLinks_ << "\n";
 
   TheNewSiPixelChargeReweightingAlgorithmClass->init(es);
 
   int collectionIndex = 0;  // I don't find what are the different collections here
   int tofBin = 0;
   for (int i1 = 1; i1 < 3; i1++) {
     for (int i2 = 0; i2 < 2; i2++) {
       if (i2 == 0) {
         tofBin = PixelDigiSimLink::LowTof;
       } else {
         tofBin = PixelDigiSimLink::HighTof;
       }
       subDetTofBin theSubDetTofBin = std::make_pair(i1, tofBin);
       SimHitCollMap[theSubDetTofBin] = collectionIndex;
       collectionIndex++;
     }
   }
 }

◆ init_DynIneffDB()

void SiPixelDigitizerAlgorithm::init_DynIneffDB ( const edm::EventSetup & es )

Definition at line 611 of file SiPixelDigitizerAlgorithm.cc.

References AddPixelInefficiency, SiPixelDigitizerAlgorithm::PixelEfficiencies::FromConfig, geom_, edm::EventSetup::getData(), SiPixelDigitizerAlgorithm::PixelEfficiencies::init_from_db(), LogDebug, pixelEfficiencies_, SiPixelDynamicInefficiency_, and SiPixelDynamicInefficiencyToken_.

Referenced by PreMixingSiPixelWorker::put().

                                                                        {
   LogDebug("PixelDigitizer ") << " In SiPixelDigitizerAlgorithm::init_DynIneffDB " << AddPixelInefficiency << "  "
                               << pixelEfficiencies_.FromConfig << "\n";
   if (AddPixelInefficiency && !pixelEfficiencies_.FromConfig) {
     SiPixelDynamicInefficiency_ = &es.getData(SiPixelDynamicInefficiencyToken_);
     pixelEfficiencies_.init_from_db(geom_, SiPixelDynamicInefficiency_);
   }
 }

◆ initCal()

std::map< int, SiPixelDigitizerAlgorithm::CalParameters, std::less< int > > SiPixelDigitizerAlgorithm::initCal ( ) const

private

Definition at line 364 of file SiPixelDigitizerAlgorithm.cc.

References calmap, officialStyle::chan, PixelIndices::channelToPixelROC(), corrVsCorr::filename, mps_fire::i, recoMuon::in, runGCPTkAlMap::in_file, mps_splice::line, LogDebug, Skims_PA_cff::name, AlCaHLTBitMon_ParallelJobs::p, SiPixelDigitizerAlgorithm::CalParameters::p0, SiPixelDigitizerAlgorithm::CalParameters::p1, SiPixelDigitizerAlgorithm::CalParameters::p2, SiPixelDigitizerAlgorithm::CalParameters::p3, pfMETCorrectionType0_cfi::par0, pfMETCorrectionType0_cfi::par1, pfMETCorrectionType0_cfi::par2, pfMETCorrectionType0_cfi::par3, PixelIndices::pixelToChannelROC(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                             {
   std::map<int, SiPixelDigitizerAlgorithm::CalParameters, std::less<int> > calmap;
   // Prepare for the analog amplitude miss-calibration
   LogDebug("PixelDigitizer ") << " miss-calibrate the pixel amplitude \n";
 
   const bool ReadCalParameters = false;
   if (ReadCalParameters) {  // Read the calibration files from file
     // read the calibration constants from a file (testing only)
     std::ifstream in_file;  // data file pointer
     char filename[80] = "phCalibrationFit_C0.dat";
 
     in_file.open(filename, std::ios::in);  // in C++
     if (in_file.bad()) {
       LogInfo("PixelDigitizer ") << " File not found \n ";
       return calmap;  // signal error
     }
     LogInfo("PixelDigitizer ") << " file opened : " << filename << "\n";
 
     char line[500];
     for (int i = 0; i < 3; i++) {
       in_file.getline(line, 500, '\n');
       LogInfo("PixelDigitizer ") << line << "\n";
     }
 
     LogInfo("PixelDigitizer ") << " test map"
                                << "\n";
 
     float par0, par1, par2, par3;
     int colid, rowid;
     std::string name;
     // Read MC tracks
     for (int i = 0; i < (52 * 80); i++) {  // loop over tracks
       in_file >> par0 >> par1 >> par2 >> par3 >> name >> colid >> rowid;
       if (in_file.bad()) {  // check for errors
         LogError("PixelDigitizer") << "Cannot read data file for calmap"
                                    << "\n";
         return calmap;
       }
       if (in_file.eof() != 0) {
         LogError("PixelDigitizer") << "calmap " << in_file.eof() << " " << in_file.gcount() << " " << in_file.fail()
                                    << " " << in_file.good() << " end of file "
                                    << "\n";
         return calmap;
       }
 
       LogDebug("PixelDigitizer ") << " line " << i << " " << par0 << " " << par1 << " " << par2 << " " << par3 << " "
                                   << colid << " " << rowid << "\n";
 
       CalParameters onePix;
       onePix.p0 = par0;
       onePix.p1 = par1;
       onePix.p2 = par2;
       onePix.p3 = par3;
 
       // Convert ROC pixel index to channel
       int chan = PixelIndices::pixelToChannelROC(rowid, colid);
       calmap.insert(std::pair<int, CalParameters>(chan, onePix));
 
       // Testing the index conversion, can be skipped
       std::pair<int, int> p = PixelIndices::channelToPixelROC(chan);
       if (rowid != p.first)
         LogInfo("PixelDigitizer ") << " wrong channel row " << rowid << " " << p.first << "\n";
       if (colid != p.second)
         LogInfo("PixelDigitizer ") << " wrong channel col " << colid << " " << p.second << "\n";
 
     }  // pixel loop in a ROC
 
     LogInfo("PixelDigitizer ") << " map size  " << calmap.size() << " max " << calmap.max_size() << " "
                                << calmap.empty() << "\n";
 
     //     LogInfo("PixelDigitizer ") << " map size  " << calmap.size()  << "\n";
     //     map<int,CalParameters,std::less<int> >::iterator ix,it;
     //     map<int,CalParameters,std::less<int> >::const_iterator ip;
     //     for (ix = calmap.begin(); ix != calmap.end(); ++ix) {
     //       int i = (*ix).first;
     //       std::pair<int,int> p = channelToPixelROC(i);
     //       it  = calmap.find(i);
     //       CalParameters y  = (*it).second;
     //       CalParameters z = (*ix).second;
     //       LogInfo("PixelDigitizer ") << i <<" "<<p.first<<" "<<p.second<<" "<<y.p0<<" "<<z.p0<<" "<<calmap[i].p0<<"\n";
 
     //       //int dummy=0;
     //       //cin>>dummy;
     //     }
 
   }  // end if readparameters
   return calmap;
 }  // end initCal()

◆ initializeEvent()

void SiPixelDigitizerAlgorithm::initializeEvent ( )

inline

Definition at line 66 of file SiPixelDigitizerAlgorithm.h.

References _signal.

Referenced by PreMixingSiPixelWorker::initializeEvent().

66 { _signal.clear(); }

SiPixelDigitizerAlgorithm::_signal

signalMaps _signal

Definition: SiPixelDigitizerAlgorithm.h:276

◆ killBadFEDChannels()

bool SiPixelDigitizerAlgorithm::killBadFEDChannels ( ) const

Definition at line 924 of file SiPixelDigitizerAlgorithm.cc.

References KillBadFEDChannels.

Referenced by PreMixingSiPixelWorker::put().

924 { return KillBadFEDChannels; }

SiPixelDigitizerAlgorithm::KillBadFEDChannels

const bool KillBadFEDChannels

Definition: SiPixelDigitizerAlgorithm.h:352

◆ lateSignalReweight()

void SiPixelDigitizerAlgorithm::lateSignalReweight	(	const PixelGeomDetUnit *	pixdet,
		std::vector< PixelDigi > &	digis,
		std::vector< PixelSimHitExtraInfo > &	newClass_Sim_extra,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 2486 of file SiPixelDigitizerAlgorithm.cc.

References gpuClustering::adc, addThresholdSmearing, LaserClient_cfi::Amplitude, officialStyle::chan, PixelDigi::channelToPixel(), cuy::col, doMissCalInLateCR, Exception, GeomDet::geographicalId(), mps_fire::i, createfilelist::int, GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), TrackerTopology::layer(), LogDebug, missCalibrate(), GeomDetEnumerators::P1PXB, GeomDetEnumerators::PixelBarrel, DetId::rawId(), GeomDet::subDetector(), theAdcFullScLateCR, theElectronPerADC, TheNewSiPixelChargeReweightingAlgorithmClass, theNoiseInElectrons, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, theThresholdInE_FPix, theThresholdSmearing_BPix, theThresholdSmearing_BPix_L1, theThresholdSmearing_BPix_L2, theThresholdSmearing_FPix, PixelGeomDetUnit::type(), and UseReweighting.

Referenced by PreMixingSiPixelWorker::addPileups().

                                                                                  {
   // Function to apply the Charge Reweighting on top of digi in case of PU from mixing library
   // for time dependent MC
   std::vector<PixelDigi> New_digis;
   uint32_t detID = pixdet->geographicalId().rawId();
 
   if (UseReweighting) {
     LogError("PixelDigitizer ") << " ********************************  \n";
     LogError("PixelDigitizer ") << " ********************************  \n";
     LogError("PixelDigitizer ") << " *****  INCONSISTENCY !!!   *****  \n";
     LogError("PixelDigitizer ")
         << " applyLateReweighting_ and UseReweighting can not be true at the same time for PU ! \n";
     LogError("PixelDigitizer ") << " ---> DO NOT APPLY CHARGE REWEIGHTING TWICE !!! \n";
     LogError("PixelDigitizer ") << " ******************************** \n";
     LogError("PixelDigitizer ") << " ******************************** \n";
     return;
   }
 
   float thePixelThresholdInE = 0.;
   if (theNoiseInElectrons > 0.) {
     if (pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()) {  // Barrel modules
       int lay = tTopo->layer(detID);
       if (addThresholdSmearing) {
         if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelBarrel ||
             pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB) {
           if (lay == 1) {
             thePixelThresholdInE = CLHEP::RandGaussQ::shoot(
                 engine, theThresholdInE_BPix_L1, theThresholdSmearing_BPix_L1);  // gaussian smearing
           } else if (lay == 2) {
             thePixelThresholdInE = CLHEP::RandGaussQ::shoot(
                 engine, theThresholdInE_BPix_L2, theThresholdSmearing_BPix_L2);  // gaussian smearing
           } else {
             thePixelThresholdInE =
                 CLHEP::RandGaussQ::shoot(engine, theThresholdInE_BPix, theThresholdSmearing_BPix);  // gaussian smearing
           }
         }
       } else {
         if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelBarrel ||
             pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB) {
           if (lay == 1) {
             thePixelThresholdInE = theThresholdInE_BPix_L1;
           } else if (lay == 2) {
             thePixelThresholdInE = theThresholdInE_BPix_L2;
           } else {
             thePixelThresholdInE = theThresholdInE_BPix;  // no smearing
           }
         }
       }
 
     } else if (pixdet->type().isTrackerPixel()) {  // Forward disks modules
 
       if (addThresholdSmearing) {
         thePixelThresholdInE =
             CLHEP::RandGaussQ::shoot(engine, theThresholdInE_FPix, theThresholdSmearing_FPix);  // gaussian smearing
       } else {
         thePixelThresholdInE = theThresholdInE_FPix;  // no smearing
       }
 
     } else {
       throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;
     }
   }
 
   // loop on the SimHit extra info class
   // apply the reweighting for that SimHit on a cluster way
   bool reweighted = false;
   std::vector<PixelSimHitExtraInfo>::iterator loopTempSH;
   for (loopTempSH = newClass_Sim_extra.begin(); loopTempSH != newClass_Sim_extra.end(); ++loopTempSH) {
     signal_map_type theDigiSignal;
     PixelSimHitExtraInfo TheNewInfo = *loopTempSH;
     reweighted = TheNewSiPixelChargeReweightingAlgorithmClass->lateSignalReweight<digitizerUtility::Amplitude>(
         pixdet, digis, TheNewInfo, theDigiSignal, tTopo, engine);
     if (!reweighted) {
       // loop on the non-reweighthed digis associated to the considered SimHit
       std::vector<PixelDigi>::const_iterator loopDigi;
       for (loopDigi = digis.begin(); loopDigi != digis.end(); ++loopDigi) {
         unsigned int chan = loopDigi->channel();
         // check if that digi is related to the SimHit
         if (loopTempSH->isInTheList(chan)) {
           float corresponding_charge = loopDigi->adc();
           theDigiSignal[chan] += digitizerUtility::Amplitude(corresponding_charge, corresponding_charge);
         }
       }
     }
 
     // transform theDigiSignal into digis
     int Thresh_inADC = int(thePixelThresholdInE / theElectronPerADC);
     for (signal_map_const_iterator i = theDigiSignal.begin(); i != theDigiSignal.end(); ++i) {
       float signalInADC = (*i).second;  // signal in ADC
       if (signalInADC > 0.) {
         if (signalInADC >= Thresh_inADC) {
           int chan = (*i).first;  // channel number
           std::pair<int, int> ip = PixelDigi::channelToPixel(chan);
           int adc = int(signalInADC);
           // add MissCalibration
           if (doMissCalInLateCR) {
             int row = ip.first;
             int col = ip.second;
             adc =
                 int(missCalibrate(detID, tTopo, pixdet, col, row, signalInADC * theElectronPerADC));  //full misscalib.
           }
 
           if (adc > theAdcFullScLateCR)
             adc = theAdcFullScLateCR;  // Check maximum value
 
 #ifdef TP_DEBUG
           LogDebug("Pixel Digitizer") << (*i).first << " " << (*i).second << " " << signalInADC << " " << adc
                                       << ip.first << " " << ip.second;
 #endif
 
           // Load digis
           New_digis.emplace_back(ip.first, ip.second, adc);
         }
       }
     }  // end loop on theDigiSignal
     theDigiSignal.clear();
   }
   digis.clear();
   digis = New_digis;
 }

◆ make_digis()

void SiPixelDigitizerAlgorithm::make_digis	(	float	thePixelThresholdInE,
		uint32_t	detID,
		const PixelGeomDetUnit *	pixdet,
		std::vector< PixelDigi > &	digis,
		std::vector< PixelDigiSimLink > &	simlinks,
		std::vector< PixelDigiAddTempInfo > &	newClass_Digi_extra,
		const TrackerTopology *	tTopo
	)		const

private

Definition at line 1663 of file SiPixelDigitizerAlgorithm.cc.

References _signal, gpuClustering::adc, officialStyle::chan, PixelDigi::channelToPixel(), cuy::col, doMissCalibrate, PSimHit::entryPoint(), PSimHit::exitPoint(), f, newFWLiteAna::found, HLT_2024v11_cff::fraction, mps_fire::i, info(), createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, LogDebug, makeDigiSimLinks_, SiStripPI::min, missCalibrate(), PSimHit::processType(), nano_mu_digi_cff::rawId, SimHitCollMap, SimHitMap, mcMuonSeeds_cfi::SimTrack, store_SimHitEntryExitPoints_, theAdcFullScale, theElectronPerADC, theThresholdInE_BPix, theThresholdInE_BPix_L1, theThresholdInE_BPix_L2, theThresholdInE_FPix, and PSimHit::trackId().

Referenced by digitize().

                                                                                {
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " make digis "
                               << " "
                               << " pixel threshold FPix" << theThresholdInE_FPix << " "
                               << " pixel threshold BPix" << theThresholdInE_BPix << " "
                               << " pixel threshold BPix Layer1" << theThresholdInE_BPix_L1 << " "
                               << " pixel threshold BPix Layer2" << theThresholdInE_BPix_L2 << " "
                               << " List pixels passing threshold ";
 #endif
 
   // Loop over hit pixels
 
   signalMaps::const_iterator it = _signal.find(detID);
   if (it == _signal.end()) {
     return;
   }
 
   const signal_map_type& theSignal = (*it).second;
 
   // unsigned long is enough to store SimTrack id and EncodedEventId
   using TrackEventId = std::pair<decltype(SimTrack().trackId()), decltype(EncodedEventId().rawId())>;
   std::map<TrackEventId, float> simi;  // re-used
 
   for (signal_map_const_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
     float signalInElectrons = (*i).second;  // signal in electrons
 
     // Do the miss calibration for calibration studies only.
     //if(doMissCalibrate) signalInElectrons = missCalibrate(signalInElectrons)
 
     // Do only for pixels above threshold
 
     if (signalInElectrons >= thePixelThresholdInE &&
         signalInElectrons > 0.) {  // check threshold, always reject killed (0-charge) digis
 
       int chan = (*i).first;  // channel number
       std::pair<int, int> ip = PixelDigi::channelToPixel(chan);
       int adc = 0;  // ADC count as integer
 
       // Do the miss calibration for calibration studies only.
       if (doMissCalibrate) {
         int row = ip.first;                                                           // X in row
         int col = ip.second;                                                          // Y is in col
         adc = int(missCalibrate(detID, tTopo, pixdet, col, row, signalInElectrons));  //full misscalib.
       } else {                                             // Just do a simple electron->adc conversion
         adc = int(signalInElectrons / theElectronPerADC);  // calibrate gain
       }
       adc = std::min(adc, theAdcFullScale);  // Check maximum value
 #ifdef TP_DEBUG
       LogDebug("Pixel Digitizer") << (*i).first << " " << (*i).second << " " << signalInElectrons << " " << adc
                                   << ip.first << " " << ip.second;
 #endif
 
       // Load digis
       digis.emplace_back(ip.first, ip.second, adc);
 
       if (makeDigiSimLinks_ && !(*i).second.hitInfos().empty()) {
         //digilink
         unsigned int il = 0;
         for (const auto& info : (*i).second.hitInfos()) {
           // note: according to C++ standard operator[] does
           // value-initializiation, which for float means initial value of 0
           simi[std::make_pair(info.trackId(), info.eventId().rawId())] += (*i).second.individualampl()[il];
           il++;
         }
 
         //sum the contribution of the same trackid
         for (const auto& info : (*i).second.hitInfos()) {
           // skip if track already processed
           auto found = simi.find(std::make_pair(info.trackId(), info.eventId().rawId()));
           if (found == simi.end())
             continue;
 
           float sum_samechannel = found->second;
           float fraction = sum_samechannel / (*i).second;
           if (fraction > 1.f)
             fraction = 1.f;
 
           // Approximation: pick hitIndex and tofBin only from the first SimHit
           simlinks.emplace_back((*i).first, info.trackId(), info.hitIndex(), info.tofBin(), info.eventId(), fraction);
           simi.erase(found);
         }
         simi.clear();  // although should be empty already
       }
 
       if (store_SimHitEntryExitPoints_ && !(*i).second.hitInfos().empty()) {
         // get info stored, like in simlinks...
         for (const auto& info : (*i).second.hitInfos()) {
           unsigned int CFPostoBeUsed = info.hitIndex4ChargeRew();
           // check if the association (chan, index) is already in the newClass_Digi_extra collection
           // if yes, don't push a duplicated entry ; if not, push a new entry
           std::vector<PixelDigiAddTempInfo>::iterator loopNewClass;
           bool already_present = false;
           for (loopNewClass = newClass_Digi_extra.begin(); loopNewClass != newClass_Digi_extra.end(); ++loopNewClass) {
             if (chan == (int)loopNewClass->channel() && CFPostoBeUsed == loopNewClass->hitIndex()) {
               already_present = true;
               loopNewClass->addCharge(info.getAmpl());
             }
           }
           if (!already_present) {
             unsigned int tofBin = info.tofBin();
             // then inspired by https://github.com/cms-sw/cmssw/blob/master/SimTracker/TrackerHitAssociation/src/TrackerHitAssociator.cc#L566 :
             subDetTofBin theSubDetTofBin = std::make_pair(DetId(detID).subdetId(), tofBin);
             auto it = SimHitCollMap.find(theSubDetTofBin);
             if (it != SimHitCollMap.end()) {
               auto it2 = SimHitMap.find((it->second));
 
               if (it2 != SimHitMap.end()) {
                 const PSimHit& theSimHit = (it2->second)[CFPostoBeUsed];
                 newClass_Digi_extra.emplace_back(chan,
                                                  info.hitIndex4ChargeRew(),
                                                  theSimHit.entryPoint(),
                                                  theSimHit.exitPoint(),
                                                  theSimHit.processType(),
                                                  theSimHit.trackId(),
                                                  detID,
                                                  info.getAmpl());
               }
             }
           }
         }  // end for
       }    // end if store_SimHitEntryExitPoints_
     }
   }
 }

◆ missCalibrate()

float SiPixelDigitizerAlgorithm::missCalibrate	(	uint32_t	detID,
		const TrackerTopology *	tTopo,
		const PixelGeomDetUnit *	pixdet,
		int	col,
		int	row,
		float	amp
	)		const

private

Definition at line 2186 of file SiPixelDigitizerAlgorithm.cc.

References BPix_p0, BPix_p1, BPix_p2, BPix_p3, cuy::col, electronsPerVCAL, electronsPerVCAL_L1, electronsPerVCAL_L1_Offset, electronsPerVCAL_Offset, Exception, FPix_p0, FPix_p1, FPix_p2, FPix_p3, GeomDetType::isBarrel(), GeomDetType::isTrackerPixel(), nano_mu_digi_cff::layer, LogDebug, LaserDQM_cfg::p1, SiStripOfflineCRack_cfg::p2, chargedHadronTrackResolutionFilter_cfi::p3, TrackerTopology::pxbLayer(), DetId::subdetId(), nnet::tanh(), theElectronPerADC, and PixelGeomDetUnit::type().

Referenced by lateSignalReweight(), and make_digis().

                                                                                     {
   // Central values
   //const float p0=0.00352, p1=0.868, p2=112., p3=113.; // pix(0,0,0)
   //  const float p0=0.00382, p1=0.886, p2=112.7, p3=113.0; // average roc=0
   //const float p0=0.00492, p1=1.998, p2=90.6, p3=134.1; // average roc=6
   // Smeared (rms)
   //const float s0=0.00020, s1=0.051, s2=5.4, s3=4.4; // average roc=0
   //const float s0=0.00015, s1=0.043, s2=3.2, s3=3.1; // col average roc=0
 
   // Make 2 sets of parameters for Fpix and BPIx:
 
   float p0 = 0.0f;
   float p1 = 0.0f;
   float p2 = 0.0f;
   float p3 = 0.0f;
 
   if (pixdet->type().isTrackerPixel() && pixdet->type().isBarrel()) {  // barrel layers
     p0 = BPix_p0;
     p1 = BPix_p1;
     p2 = BPix_p2;
     p3 = BPix_p3;
   } else if (pixdet->type().isTrackerPixel()) {  // forward disks
     p0 = FPix_p0;
     p1 = FPix_p1;
     p2 = FPix_p2;
     p3 = FPix_p3;
   } else {
     throw cms::Exception("NotAPixelGeomDetUnit") << "Not a pixel geomdet unit" << detID;
   }
 
   float newAmp = 0.f;  //Modified signal
 
   // Convert electrons to VCAL units
   float signal = (signalInElectrons - electronsPerVCAL_Offset) / electronsPerVCAL;
 
   // New gains/offsets are needed for phase1 L1
   int layer = 0;
   if (DetId(detID).subdetId() == 1)
     layer = tTopo->pxbLayer(detID);
   if (layer == 1)
     signal = (signalInElectrons - electronsPerVCAL_L1_Offset) / electronsPerVCAL_L1;
 
   // Simulate the analog response with fixed parametrization
   newAmp = p3 + p2 * tanh(p0 * signal - p1);
 
   // Use the pixel-by-pixel calibrations
   //transform to ROC index coordinates
   //int chipIndex=0, colROC=0, rowROC=0;
   //std::unique_ptr<PixelIndices> pIndexConverter(new PixelIndices(numColumns,numRows));
   //pIndexConverter->transformToROC(col,row,chipIndex,colROC,rowROC);
 
   // Use calibration from a file
   //int chanROC = PixelIndices::pixelToChannelROC(rowROC,colROC); // use ROC coordinates
   //float pp0=0, pp1=0,pp2=0,pp3=0;
   //map<int,CalParameters,std::less<int> >::const_iterator it=calmap.find(chanROC);
   //CalParameters y  = (*it).second;
   //pp0 = y.p0;
   //pp1 = y.p1;
   //pp2 = y.p2;
   //pp3 = y.p3;
 
   //
   // Use random smearing
   // Randomize the pixel response
   //float pp0  = RandGaussQ::shoot(p0,s0);
   //float pp1  = RandGaussQ::shoot(p1,s1);
   //float pp2  = RandGaussQ::shoot(p2,s2);
   //float pp3  = RandGaussQ::shoot(p3,s3);
 
   //newAmp = pp3 + pp2 * tanh(pp0*signal - pp1); // Final signal
 
   LogDebug("Pixel Digitizer") << " misscalibrate " << col << " " << row
                               << " "
                               // <<chipIndex<<" " <<colROC<<" " <<rowROC<<" "
                               << signalInElectrons << " " << signal << " " << newAmp << " "
                               << (signalInElectrons / theElectronPerADC) << "\n";
 
   return newAmp;
 }

◆ module_killing_conf()

void SiPixelDigitizerAlgorithm::module_killing_conf ( uint32_t detID )

private

Definition at line 2368 of file SiPixelDigitizerAlgorithm.cc.

References _signal, PixelDigi::channelToPixel(), DeadModules, mps_fire::i, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by digitize().

                                                                   {
   bool isbad = false;
 
   Parameters::const_iterator itDeadModules = DeadModules.begin();
 
   int detid = detID;
   for (; itDeadModules != DeadModules.end(); ++itDeadModules) {
     int Dead_detID = itDeadModules->getParameter<int>("Dead_detID");
     if (detid == Dead_detID) {
       isbad = true;
       break;
     }
   }
 
   if (!isbad)
     return;
 
   signal_map_type& theSignal = _signal[detID];
 
   std::string Module = itDeadModules->getParameter<std::string>("Module");
 
   if (Module == "whole") {
     for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
       i->second.set(0.);  // reset amplitude
     }
   }
 
   for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
     std::pair<int, int> ip = PixelDigi::channelToPixel(i->first);  //get pixel pos
 
     if (Module == "tbmA" && ip.first >= 80 && ip.first <= 159) {
       i->second.set(0.);
     }
 
     if (Module == "tbmB" && ip.first <= 79) {
       i->second.set(0.);
     }
   }
 }

◆ module_killing_DB()

void SiPixelDigitizerAlgorithm::module_killing_DB ( uint32_t detID )

private

Definition at line 2408 of file SiPixelDigitizerAlgorithm.cc.

References _signal, funct::abs(), PixelDigi::channelToPixel(), TauDecayModes::dec, SiPixelQuality::disabledModuleType::errorType, SiPixelFedCablingMap::findItem(), SiPixelQuality::getBadComponentList(), SiPixelQuality::getBadRocs(), mps_fire::i, l1ctLayer2EG_cff::id, sipixelobjects::PixelROC::idInDetUnit(), SiPixelQuality::IsRocBad(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, DTRecHitClients_cfi::local, LogDebug, map_, castor_dqm_sourceclient_file_cfg::path, SiPixelFedCablingMap::pathToDetUnit(), SiPixelBadModule_, and sipixelobjects::PixelROC::toGlobal().

Referenced by digitize().

                                                                 {
   // Not SLHC safe for now
 
   bool isbad = false;
 
   std::vector<SiPixelQuality::disabledModuleType> disabledModules = SiPixelBadModule_->getBadComponentList();
 
   SiPixelQuality::disabledModuleType badmodule;
 
   for (size_t id = 0; id < disabledModules.size(); id++) {
     if (detID == disabledModules[id].DetID) {
       isbad = true;
       badmodule = disabledModules[id];
       break;
     }
   }
 
   if (!isbad)
     return;
 
   signal_map_type& theSignal = _signal[detID];
 
   LogDebug("Pixel Digitizer") << "Hit in: " << detID << " errorType " << badmodule.errorType << " BadRocs=" << std::hex
                               << SiPixelBadModule_->getBadRocs(detID) << std::dec << " "
                               << "\n";
   if (badmodule.errorType == 0) {  // this is a whole dead module.
 
     for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
       i->second.set(0.);  // reset amplitude
     }
   } else {  // all other module types: half-modules and single ROCs.
     // Get Bad ROC position:
     //follow the example of getBadRocPositions in CondFormats/SiPixelObjects/src/SiPixelQuality.cc
     std::vector<GlobalPixel> badrocpositions(0);
     for (unsigned int j = 0; j < 16; j++) {
       if (SiPixelBadModule_->IsRocBad(detID, j) == true) {
         std::vector<CablingPathToDetUnit> path = map_->pathToDetUnit(detID);
         typedef std::vector<CablingPathToDetUnit>::const_iterator IT;
         for (IT it = path.begin(); it != path.end(); ++it) {
           const PixelROC* myroc = map_->findItem(*it);
           if (myroc->idInDetUnit() == j) {
             LocalPixel::RocRowCol local = {39, 25};  //corresponding to center of ROC row, col
             GlobalPixel global = myroc->toGlobal(LocalPixel(local));
             badrocpositions.push_back(global);
             break;
           }
         }
       }
     }  // end of getBadRocPositions
 
     for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
       std::pair<int, int> ip = PixelDigi::channelToPixel(i->first);  //get pixel pos
 
       for (std::vector<GlobalPixel>::const_iterator it = badrocpositions.begin(); it != badrocpositions.end(); ++it) {
         if (it->row >= 80 && ip.first >= 80) {
           if ((std::abs(ip.second - it->col) < 26)) {
             i->second.set(0.);
           } else if (it->row == 120 && ip.second - it->col == 26) {
             i->second.set(0.);
           } else if (it->row == 119 && it->col - ip.second == 26) {
             i->second.set(0.);
           }
         } else if (it->row < 80 && ip.first < 80) {
           if ((std::abs(ip.second - it->col) < 26)) {
             i->second.set(0.);
           } else if (it->row == 40 && ip.second - it->col == 26) {
             i->second.set(0.);
           } else if (it->row == 39 && it->col - ip.second == 26) {
             i->second.set(0.);
           }
         }
       }
     }
   }
 }

◆ pixel_aging()

float SiPixelDigitizerAlgorithm::pixel_aging	(	const PixelAging &	aging,
		const PixelGeomDetUnit *	pixdet,
		const TrackerTopology *	tTopo
	)		const

private

Definition at line 2130 of file SiPixelDigitizerAlgorithm.cc.

References GeomDet::geographicalId(), TrackerTopology::layer(), LogDebug, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, GeomDetEnumerators::P2OTB, GeomDetEnumerators::P2OTEC, GeomDetEnumerators::P2PXEC, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, TrackerTopology::pxbLadder(), TrackerTopology::pxbModule(), DetId::rawId(), and GeomDet::subDetector().

Referenced by drift().

                                                                                  {
   uint32_t detID = pixdet->geographicalId().rawId();
 
   // Predefined damage parameter (no aging)
   float pseudoRadDamage = 0.0f;
 
   // setup the chip indices conversion
   if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelBarrel ||
       pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB) {  // barrel layers
     int layerIndex = tTopo->layer(detID);
 
     pseudoRadDamage = aging.thePixelPseudoRadDamage[layerIndex - 1];
 
     LogDebug("Pixel Digitizer") << "pixel_aging: "
                                 << "\n";
     LogDebug("Pixel Digitizer") << "Subid " << pixdet->subDetector() << " layerIndex " << layerIndex << " ladder "
                                 << tTopo->pxbLadder(detID) << " module  " << tTopo->pxbModule(detID) << "\n";
 
   } else if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelEndcap ||
              pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXEC ||
              pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2PXEC) {  // forward disks
     unsigned int diskIndex =
         tTopo->layer(detID) + aging.FPixIndex;  // Use diskIndex-1 later to stay consistent with BPix
 
     pseudoRadDamage = aging.thePixelPseudoRadDamage[diskIndex - 1];
 
     LogDebug("Pixel Digitizer") << "pixel_aging: "
                                 << "\n";
     LogDebug("Pixel Digitizer") << "Subid " << pixdet->subDetector() << " diskIndex " << diskIndex << "\n";
   } else if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTB ||
              pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTEC) {
     // if phase 2 OT hardcoded value as it has always been
     pseudoRadDamage = 0.f;
   }  // if barrel/forward
 
   LogDebug("Pixel Digitizer") << " pseudoRadDamage " << pseudoRadDamage << "\n";
   LogDebug("Pixel Digitizer") << " end pixel_aging "
                               << "\n";
 
   return pseudoRadDamage;
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " enter pixel_aging " << pseudoRadDamage;
 #endif
 }

◆ pixel_inefficiency()

void SiPixelDigitizerAlgorithm::pixel_inefficiency	(	const PixelEfficiencies &	eff,
		const PixelGeomDetUnit *	pixdet,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 1901 of file SiPixelDigitizerAlgorithm.cc.

Referenced by digitize().

                                                                                  {
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
   const PixelTopology* topol = &pixdet->specificTopology();
   int numColumns = topol->ncolumns();  // det module number of cols&rows
   int numRows = topol->nrows();
   bool isPhase1 = pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB ||
                   pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXEC;
   // Predefined efficiencies
   double pixelEfficiency = 1.0;
   double columnEfficiency = 1.0;
   double chipEfficiency = 1.0;
   std::vector<double> pixelEfficiencyROCStdPixels(16, 1);
   std::vector<double> pixelEfficiencyROCBigPixels(16, 1);
 
   auto pIndexConverter = PixelIndices(numColumns, numRows);
 
   std::vector<int> badRocsFromFEDChannels(16, 0);
   if (eff.PixelFEDChannelCollection_ != nullptr) {
     PixelFEDChannelCollection::const_iterator it = eff.PixelFEDChannelCollection_->find(detID);
 
     if (it != eff.PixelFEDChannelCollection_->end()) {
       const std::vector<CablingPathToDetUnit>& path = map_->pathToDetUnit(detID);
       for (const auto& ch : *it) {
         for (unsigned int i_roc = ch.roc_first; i_roc <= ch.roc_last; ++i_roc) {
           for (const auto p : path) {
             const PixelROC* myroc = map_->findItem(p);
             if (myroc->idInDetUnit() == static_cast<unsigned int>(i_roc)) {
               LocalPixel::RocRowCol local = {39, 25};  //corresponding to center of ROC row,col
               GlobalPixel global = myroc->toGlobal(LocalPixel(local));
               int chipIndex(0), colROC(0), rowROC(0);
               pIndexConverter.transformToROC(global.col, global.row, chipIndex, colROC, rowROC);
               badRocsFromFEDChannels.at(chipIndex) = 1;
             }
           }
         }
       }  // loop over channels
     }    // detID in PixelFEDChannelCollection_
   }      // has PixelFEDChannelCollection_
 
   if (eff.FromConfig) {
     // setup the chip indices conversion
     if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelBarrel ||
         pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXB) {  // barrel layers
       int layerIndex = tTopo->layer(detID);
       pixelEfficiency = eff.thePixelEfficiency[layerIndex - 1];
       columnEfficiency = eff.thePixelColEfficiency[layerIndex - 1];
       chipEfficiency = eff.thePixelChipEfficiency[layerIndex - 1];
       LogDebug("Pixel Digitizer") << "Using BPix columnEfficiency = " << columnEfficiency
                                   << " for layer = " << layerIndex << "\n";
       // This should never happen, but only check if it is not an upgrade geometry
       if (NumberOfBarrelLayers == 3) {
         if (numColumns > 416)
           LogWarning("Pixel Geometry") << " wrong columns in barrel " << numColumns;
         if (numRows > 160)
           LogWarning("Pixel Geometry") << " wrong rows in barrel " << numRows;
 
         int ladder = tTopo->pxbLadder(detID);
         int module = tTopo->pxbModule(detID);
         if (module <= 4)
           module = 5 - module;
         else
           module -= 4;
 
         columnEfficiency *= eff.theLadderEfficiency_BPix[layerIndex - 1][ladder - 1] *
                             eff.theModuleEfficiency_BPix[layerIndex - 1][module - 1] * eff.pu_scale[layerIndex - 1];
       }
     } else if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::PixelEndcap ||
                pixdet->subDetector() == GeomDetEnumerators::SubDetector::P1PXEC ||
                pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2PXEC) {  // forward disks
 
       unsigned int diskIndex =
           tTopo->layer(detID) + eff.FPixIndex;  // Use diskIndex-1 later to stay consistent with BPix
       unsigned int panelIndex = tTopo->pxfPanel(detID);
       unsigned int moduleIndex = tTopo->pxfModule(detID);
       //if (eff.FPixIndex>diskIndex-1){throw cms::Exception("Configuration") <<"SiPixelDigitizer is using the wrong efficiency value. index = "
       //                                                                       <<diskIndex-1<<" , MinIndex = "<<eff.FPixIndex<<" ... "<<tTopo->pxfDisk(detID);}
       pixelEfficiency = eff.thePixelEfficiency[diskIndex - 1];
       columnEfficiency = eff.thePixelColEfficiency[diskIndex - 1];
       chipEfficiency = eff.thePixelChipEfficiency[diskIndex - 1];
       LogDebug("Pixel Digitizer") << "Using FPix columnEfficiency = " << columnEfficiency
                                   << " for Disk = " << tTopo->pxfDisk(detID) << "\n";
       // Sometimes the forward pixels have wrong size,
       // this crashes the index conversion, so exit, but only check if it is not an upgrade geometry
       if (NumberOfBarrelLayers ==
           3) {  // whether it is the present or the phase 1 detector can be checked using GeomDetEnumerators::SubDetector
         if (numColumns > 260 || numRows > 160) {
           if (numColumns > 260)
             LogWarning("Pixel Geometry") << " wrong columns in endcaps " << numColumns;
           if (numRows > 160)
             LogWarning("Pixel Geometry") << " wrong rows in endcaps " << numRows;
           return;
         }
         if ((panelIndex == 1 && (moduleIndex == 1 || moduleIndex == 2)) ||
             (panelIndex == 2 && moduleIndex == 1)) {  //inner modules
           columnEfficiency *= eff.theInnerEfficiency_FPix[diskIndex - 1] * eff.pu_scale[3];
         } else {  //outer modules
           columnEfficiency *= eff.theOuterEfficiency_FPix[diskIndex - 1] * eff.pu_scale[4];
         }
       }  // current detector, forward
     } else if (pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTB ||
                pixdet->subDetector() == GeomDetEnumerators::SubDetector::P2OTEC) {
       // If phase 2 outer tracker, hardcoded values as they have been so far
       pixelEfficiency = 0.999;
       columnEfficiency = 0.999;
       chipEfficiency = 0.999;
     }       // if barrel/forward
   } else {  // Load precomputed factors from Database
     pixelEfficiency = eff.PixelGeomFactors.at(detID);
     columnEfficiency = eff.ColGeomFactors.at(detID) * eff.pu_scale[eff.iPU.at(detID)];
     chipEfficiency = eff.ChipGeomFactors.at(detID);
     if (isPhase1) {
       for (unsigned int i_roc = 0; i_roc < eff.PixelGeomFactorsROCStdPixels.at(detID).size(); ++i_roc) {
         pixelEfficiencyROCStdPixels[i_roc] = eff.PixelGeomFactorsROCStdPixels.at(detID).at(i_roc);
         pixelEfficiencyROCBigPixels[i_roc] = eff.PixelGeomFactorsROCBigPixels.at(detID).at(i_roc);
       }
     }  // is Phase 1
   }
 
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " enter pixel_inefficiency " << pixelEfficiency << " " << columnEfficiency << " "
                               << chipEfficiency;
 #endif
 
   // Initilize the index converter
   //PixelIndices indexConverter(numColumns,numRows);
 
   int chipIndex = 0;
   int rowROC = 0;
   int colROC = 0;
   std::map<int, int, std::less<int> > chips, columns, pixelStd, pixelBig;
   std::map<int, int, std::less<int> >::iterator iter;
 
   // Find out the number of columns and rocs hits
   // Loop over hit pixels, amplitude in electrons, channel = coded row,col
   for (signal_map_const_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
     int chan = i->first;
     std::pair<int, int> ip = PixelDigi::channelToPixel(chan);
     int row = ip.first;   // X in row
     int col = ip.second;  // Y is in col
     //transform to ROC index coordinates
     pIndexConverter.transformToROC(col, row, chipIndex, colROC, rowROC);
     int dColInChip = pIndexConverter.DColumn(colROC);  // get ROC dcol from ROC col
     //dcol in mod
     int dColInDet = pIndexConverter.DColumnInModule(dColInChip, chipIndex);
 
     chips[chipIndex]++;
     columns[dColInDet]++;
     if (isPhase1) {
       if (topol->isItBigPixelInX(row) || topol->isItBigPixelInY(col))
         pixelBig[chipIndex]++;
       else
         pixelStd[chipIndex]++;
     }
   }
 
   // Delete some ROC hits.
   for (iter = chips.begin(); iter != chips.end(); iter++) {
     //float rand  = RandFlat::shoot();
     float rand = CLHEP::RandFlat::shoot(engine);
     if (rand > chipEfficiency)
       chips[iter->first] = 0;
   }
 
   // Delete some Dcol hits.
   for (iter = columns.begin(); iter != columns.end(); iter++) {
     //float rand  = RandFlat::shoot();
     float rand = CLHEP::RandFlat::shoot(engine);
     if (rand > columnEfficiency)
       columns[iter->first] = 0;
   }
 
   // Delete some pixel hits based on DCDC issue damage.
   if (isPhase1) {
     for (iter = pixelStd.begin(); iter != pixelStd.end(); iter++) {
       float rand = CLHEP::RandFlat::shoot(engine);
       if (rand > pixelEfficiencyROCStdPixels[iter->first])
         pixelStd[iter->first] = 0;
     }
 
     for (iter = pixelBig.begin(); iter != pixelBig.end(); iter++) {
       float rand = CLHEP::RandFlat::shoot(engine);
       if (rand > pixelEfficiencyROCBigPixels[iter->first])
         pixelBig[iter->first] = 0;
     }
   }
 
   // Now loop again over pixels to kill some of them.
   // Loop over hit pixels, amplitude in electrons, channel = coded row,col
   for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
     //    int chan = i->first;
     std::pair<int, int> ip = PixelDigi::channelToPixel(i->first);  //get pixel pos
     int row = ip.first;                                            // X in row
     int col = ip.second;                                           // Y is in col
     //transform to ROC index coordinates
     pIndexConverter.transformToROC(col, row, chipIndex, colROC, rowROC);
     int dColInChip = pIndexConverter.DColumn(colROC);  //get ROC dcol from ROC col
     //dcol in mod
     int dColInDet = pIndexConverter.DColumnInModule(dColInChip, chipIndex);
 
     //float rand  = RandFlat::shoot();
     float rand = CLHEP::RandFlat::shoot(engine);
     if (chips[chipIndex] == 0 || columns[dColInDet] == 0 || rand > pixelEfficiency ||
         (pixelStd.count(chipIndex) && pixelStd[chipIndex] == 0) ||
         (pixelBig.count(chipIndex) && pixelBig[chipIndex] == 0)) {
       // make pixel amplitude =0, pixel will be lost at clusterization
       i->second.set(0.);  // reset amplitude,
     }                     // end if
     if (isPhase1) {
       if ((pixelStd.count(chipIndex) && pixelStd[chipIndex] == 0) ||
           (pixelBig.count(chipIndex) && pixelBig[chipIndex] == 0) || (badRocsFromFEDChannels.at(chipIndex) == 1)) {
         //============================================================
         // make pixel amplitude =0, pixel will be lost at clusterization
         i->second.set(0.);  // reset amplitude,
       }                     // end if
     }                       // is Phase 1
     if (KillBadFEDChannels && badRocsFromFEDChannels.at(chipIndex) == 1) {
       i->second.set(0.);
     }
   }  // end pixel loop
 }  // end pixel_indefficiency

◆ pixel_inefficiency_db()

void SiPixelDigitizerAlgorithm::pixel_inefficiency_db ( uint32_t detID )

private

Definition at line 2348 of file SiPixelDigitizerAlgorithm.cc.

References _signal, PixelDigi::channelToPixel(), cuy::col, mps_fire::i, LogDebug, and theSiPixelGainCalibrationService_.

Referenced by digitize().

                                                                     {
   signal_map_type& theSignal = _signal[detID];
 
   // Loop over hit pixels, amplitude in electrons, channel = coded row,col
   for (signal_map_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
     //    int chan = i->first;
     std::pair<int, int> ip = PixelDigi::channelToPixel(i->first);  //get pixel pos
     int row = ip.first;                                            // X in row
     int col = ip.second;                                           // Y is in col
     //transform to ROC index coordinates
     if (theSiPixelGainCalibrationService_->isDead(detID, col, row)) {
       LogDebug("Pixel Digitizer") << "now in isdead check, row " << detID << " " << col << "," << row << "\n";
       // make pixel amplitude =0, pixel will be lost at clusterization
       i->second.set(0.);  // reset amplitude,
     }                     // end if
   }                       // end pixel loop
 }  // end pixel_indefficiency

◆ primary_ionization()

void SiPixelDigitizerAlgorithm::primary_ionization	(	const PSimHit &	hit,
		std::vector< EnergyDepositUnit > &	ionization_points,
		CLHEP::HepRandomEngine *	engine
	)		const

private

Definition at line 1128 of file SiPixelDigitizerAlgorithm.cc.

References simKBmtfDigis_cfi::eLoss, hcalRecHitTable_cff::energy, nano_mu_digi_cff::float, fluctuateCharge, fluctuateEloss(), GeVperElectron, mps_fire::i, createfilelist::int, LogDebug, PV3DBase< T, PVType, FrameType >::mag(), point, hit::x, hit::y, and hit::z.

Referenced by accumulateSimHits().

                                                                                        {
   // Straight line approximation for trajectory inside active media
 
   const float SegmentLength = 0.0010;  //10microns in cm
   float energy;
 
   // Get the 3D segment direction vector
   LocalVector direction = hit.exitPoint() - hit.entryPoint();
 
   float eLoss = hit.energyLoss();  // Eloss in GeV
   float length = direction.mag();  // Track length in Silicon
 
   int NumberOfSegments = int(length / SegmentLength);  // Number of segments
   if (NumberOfSegments < 1)
     NumberOfSegments = 1;
 
 #ifdef TP_DEBUG
   LogDebug("Pixel Digitizer") << " enter primary_ionzation " << NumberOfSegments
                               << " shift = " << (hit.exitPoint().x() - hit.entryPoint().x()) << " "
                               << (hit.exitPoint().y() - hit.entryPoint().y()) << " "
                               << (hit.exitPoint().z() - hit.entryPoint().z()) << " " << hit.particleType() << " "
                               << hit.pabs();
 #endif
 
   float* elossVector = new float[NumberOfSegments];  // Eloss vector
 
   if (fluctuateCharge) {
     //MP DA RIMUOVERE ASSOLUTAMENTE
     int pid = hit.particleType();
     //int pid=211;  // assume it is a pion
 
     float momentum = hit.pabs();
     // Generate fluctuated charge points
     fluctuateEloss(pid, momentum, eLoss, length, NumberOfSegments, elossVector, engine);
   }
 
   ionization_points.resize(NumberOfSegments);  // set size
 
   // loop over segments
   for (int i = 0; i != NumberOfSegments; i++) {
     // Divide the segment into equal length subsegments
     Local3DPoint point = hit.entryPoint() + float((i + 0.5) / NumberOfSegments) * direction;
 
     if (fluctuateCharge)
       energy = elossVector[i] / GeVperElectron;  // Convert charge to elec.
     else
       energy = hit.energyLoss() / GeVperElectron / float(NumberOfSegments);
 
     EnergyDepositUnit edu(energy, point);  //define position,energy point
     ionization_points[i] = edu;            // save
 
 #ifdef TP_DEBUG
     LogDebug("Pixel Digitizer") << i << " " << ionization_points[i].x() << " " << ionization_points[i].y() << " "
                                 << ionization_points[i].z() << " " << ionization_points[i].energy();
 #endif
 
   }  // end for loop
 
   delete[] elossVector;
 }

◆ resetSimHitMaps()

void SiPixelDigitizerAlgorithm::resetSimHitMaps ( )

Definition at line 1658 of file SiPixelDigitizerAlgorithm.cc.

References SimHitMap.

1658 { SimHitMap.clear(); }

SiPixelDigitizerAlgorithm::SimHitMap

simhit_map SimHitMap

Definition: SiPixelDigitizerAlgorithm.h:271

◆ setSimAccumulator()

void SiPixelDigitizerAlgorithm::setSimAccumulator ( const std::map< uint32_t, std::map< int, int > > & signalMap )

Definition at line 1018 of file SiPixelDigitizerAlgorithm.cc.

References _signal, officialStyle::chan, and theElectronPerADC.

Referenced by PreMixingSiPixelWorker::put().

                                                                                                       {
   for (const auto& det : signalMap) {
     auto& theSignal = _signal[det.first];
     for (const auto& chan : det.second) {
       theSignal[chan.first].set(chan.second *
                                 theElectronPerADC);  // will get divided again by theElectronPerAdc in digitize...
     }
   }
 }

Member Data Documentation

◆ _signal

signalMaps SiPixelDigitizerAlgorithm::_signal

private

Definition at line 276 of file SiPixelDigitizerAlgorithm.h.

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

◆ addChargeVCALSmearing

const bool SiPixelDigitizerAlgorithm::addChargeVCALSmearing

private

Definition at line 346 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

◆ addNoise

const bool SiPixelDigitizerAlgorithm::addNoise

private

Definition at line 345 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

◆ addNoisyPixels

const bool SiPixelDigitizerAlgorithm::addNoisyPixels

private

Definition at line 347 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

◆ AddPixelAging

const bool SiPixelDigitizerAlgorithm::AddPixelAging

private

Definition at line 362 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

◆ AddPixelInefficiency

const bool SiPixelDigitizerAlgorithm::AddPixelInefficiency

private

Definition at line 351 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), init_DynIneffDB(), SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelEfficiencies(), and SiPixelDigitizerAlgorithm().

◆ addThresholdSmearing

const bool SiPixelDigitizerAlgorithm::addThresholdSmearing

private

Definition at line 353 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), and lateSignalReweight().

◆ alpha2Order

const bool SiPixelDigitizerAlgorithm::alpha2Order

private

Definition at line 299 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift(), and DriftDirection().

◆ BPix_p0

const float SiPixelDigitizerAlgorithm::BPix_p0

private

Definition at line 339 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ BPix_p1

const float SiPixelDigitizerAlgorithm::BPix_p1

private

Definition at line 340 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ BPix_p2

const float SiPixelDigitizerAlgorithm::BPix_p2

private

Definition at line 341 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ BPix_p3

const float SiPixelDigitizerAlgorithm::BPix_p3

private

Definition at line 342 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ calmap

const std::map<int, CalParameters, std::less<int> > SiPixelDigitizerAlgorithm::calmap

private

Definition at line 378 of file SiPixelDigitizerAlgorithm.h.

Referenced by initCal().

◆ ClusterWidth

const float SiPixelDigitizerAlgorithm::ClusterWidth

private

Definition at line 302 of file SiPixelDigitizerAlgorithm.h.

Referenced by induce_signal().

◆ DeadModules

const Parameters SiPixelDigitizerAlgorithm::DeadModules

private

Definition at line 286 of file SiPixelDigitizerAlgorithm.h.

Referenced by module_killing_conf().

◆ Dist300

const float SiPixelDigitizerAlgorithm::Dist300

private

Definition at line 298 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

◆ doMissCalibrate

const bool SiPixelDigitizerAlgorithm::doMissCalibrate

private

Definition at line 356 of file SiPixelDigitizerAlgorithm.h.

Referenced by make_digis().

◆ doMissCalInLateCR

const bool SiPixelDigitizerAlgorithm::doMissCalInLateCR

private

Definition at line 357 of file SiPixelDigitizerAlgorithm.h.

Referenced by lateSignalReweight().

◆ electronsPerVCAL

const float SiPixelDigitizerAlgorithm::electronsPerVCAL

private

Definition at line 325 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ electronsPerVCAL_L1

const float SiPixelDigitizerAlgorithm::electronsPerVCAL_L1

private

Definition at line 327 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ electronsPerVCAL_L1_Offset

const float SiPixelDigitizerAlgorithm::electronsPerVCAL_L1_Offset

private

Definition at line 328 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ electronsPerVCAL_Offset

const float SiPixelDigitizerAlgorithm::electronsPerVCAL_Offset

private

Definition at line 326 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ fluctuate

const std::unique_ptr<SiG4UniversalFluctuation> SiPixelDigitizerAlgorithm::fluctuate

private

Definition at line 374 of file SiPixelDigitizerAlgorithm.h.

Referenced by fluctuateEloss().

◆ fluctuateCharge

const bool SiPixelDigitizerAlgorithm::fluctuateCharge

private

Definition at line 348 of file SiPixelDigitizerAlgorithm.h.

Referenced by primary_ionization().

◆ FPix_p0

const float SiPixelDigitizerAlgorithm::FPix_p0

private

Definition at line 335 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ FPix_p1

const float SiPixelDigitizerAlgorithm::FPix_p1

private

Definition at line 336 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ FPix_p2

const float SiPixelDigitizerAlgorithm::FPix_p2

private

Definition at line 337 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ FPix_p3

const float SiPixelDigitizerAlgorithm::FPix_p3

private

Definition at line 338 of file SiPixelDigitizerAlgorithm.h.

Referenced by missCalibrate().

◆ geom_

const TrackerGeometry* SiPixelDigitizerAlgorithm::geom_ = nullptr

private

Definition at line 119 of file SiPixelDigitizerAlgorithm.h.

Referenced by init_DynIneffDB().

◆ geomToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> SiPixelDigitizerAlgorithm::geomToken_

private

Definition at line 117 of file SiPixelDigitizerAlgorithm.h.

◆ GeVperElectron

const float SiPixelDigitizerAlgorithm::GeVperElectron

private

Definition at line 294 of file SiPixelDigitizerAlgorithm.h.

Referenced by primary_ionization().

◆ KillBadFEDChannels

const bool SiPixelDigitizerAlgorithm::KillBadFEDChannels

private

Definition at line 352 of file SiPixelDigitizerAlgorithm.h.

Referenced by killBadFEDChannels(), pixel_inefficiency(), and SiPixelDigitizerAlgorithm().

◆ makeDigiSimLinks_

const bool SiPixelDigitizerAlgorithm::makeDigiSimLinks_

private

Definition at line 278 of file SiPixelDigitizerAlgorithm.h.

Referenced by induce_signal(), and make_digis().

◆ map_

const SiPixelFedCablingMap* SiPixelDigitizerAlgorithm::map_ = nullptr

private

Definition at line 118 of file SiPixelDigitizerAlgorithm.h.

Referenced by module_killing_DB(), and pixel_inefficiency().

◆ mapToken_

const edm::ESGetToken<SiPixelFedCablingMap, SiPixelFedCablingMapRcd> SiPixelDigitizerAlgorithm::mapToken_

private

Definition at line 116 of file SiPixelDigitizerAlgorithm.h.

◆ NumberOfBarrelLayers

const int SiPixelDigitizerAlgorithm::NumberOfBarrelLayers

private

Definition at line 304 of file SiPixelDigitizerAlgorithm.h.

Referenced by pixel_inefficiency(), SiPixelDigitizerAlgorithm::PixelAging::PixelAging(), and SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelEfficiencies().

◆ NumberOfEndcapDisks

const int SiPixelDigitizerAlgorithm::NumberOfEndcapDisks

private

Definition at line 305 of file SiPixelDigitizerAlgorithm.h.

Referenced by SiPixelDigitizerAlgorithm::PixelAging::PixelAging(), and SiPixelDigitizerAlgorithm::PixelEfficiencies::PixelEfficiencies().

◆ pixelAging_

const PixelAging SiPixelDigitizerAlgorithm::pixelAging_

private

Definition at line 435 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

◆ pixelEfficiencies_

PixelEfficiencies SiPixelDigitizerAlgorithm::pixelEfficiencies_

private

Definition at line 434 of file SiPixelDigitizerAlgorithm.h.

Referenced by calculateInstlumiFactor(), chooseScenario(), digitize(), init_DynIneffDB(), and SiPixelDigitizerAlgorithm().

◆ PixelFEDChannelCollectionMapToken_

edm::ESGetToken<PixelFEDChannelCollectionMap, SiPixelFEDChannelContainerESProducerRcd> SiPixelDigitizerAlgorithm::PixelFEDChannelCollectionMapToken_

private

Definition at line 128 of file SiPixelDigitizerAlgorithm.h.

Referenced by SiPixelDigitizerAlgorithm().

◆ quality_map

const PixelFEDChannelCollectionMap* SiPixelDigitizerAlgorithm::quality_map

Definition at line 104 of file SiPixelDigitizerAlgorithm.h.

Referenced by chooseScenario().

◆ scenarioProbability_

const SiPixelQualityProbabilities* SiPixelDigitizerAlgorithm::scenarioProbability_ = nullptr

private

Definition at line 129 of file SiPixelDigitizerAlgorithm.h.

Referenced by chooseScenario().

◆ scenarioProbabilityToken_

edm::ESGetToken<SiPixelQualityProbabilities, SiPixelStatusScenarioProbabilityRcd> SiPixelDigitizerAlgorithm::scenarioProbabilityToken_

private

Definition at line 126 of file SiPixelDigitizerAlgorithm.h.

Referenced by SiPixelDigitizerAlgorithm().

◆ Sigma0

const float SiPixelDigitizerAlgorithm::Sigma0

private

Definition at line 297 of file SiPixelDigitizerAlgorithm.h.

Referenced by drift().

◆ SimHitCollMap

simhit_collectionMap SiPixelDigitizerAlgorithm::SimHitCollMap

private

Definition at line 273 of file SiPixelDigitizerAlgorithm.h.

Referenced by fillSimHitMaps(), and make_digis().

◆ SimHitMap

simhit_map SiPixelDigitizerAlgorithm::SimHitMap

private

Definition at line 271 of file SiPixelDigitizerAlgorithm.h.

Referenced by fillSimHitMaps(), make_digis(), and resetSimHitMaps().

◆ SiPixelBadModule_

const SiPixelQuality* SiPixelDigitizerAlgorithm::SiPixelBadModule_ = nullptr

private

Definition at line 113 of file SiPixelDigitizerAlgorithm.h.

Referenced by module_killing_DB().

◆ SiPixelBadModuleToken_

edm::ESGetToken<SiPixelQuality, SiPixelQualityRcd> SiPixelDigitizerAlgorithm::SiPixelBadModuleToken_

private

Definition at line 112 of file SiPixelDigitizerAlgorithm.h.

Referenced by SiPixelDigitizerAlgorithm().

◆ SiPixelDynamicInefficiency_

const SiPixelDynamicInefficiency* SiPixelDigitizerAlgorithm::SiPixelDynamicInefficiency_ = nullptr

private

Definition at line 123 of file SiPixelDigitizerAlgorithm.h.

Referenced by init_DynIneffDB().

◆ SiPixelDynamicInefficiencyToken_

edm::ESGetToken<SiPixelDynamicInefficiency, SiPixelDynamicInefficiencyRcd> SiPixelDigitizerAlgorithm::SiPixelDynamicInefficiencyToken_

private

Definition at line 122 of file SiPixelDigitizerAlgorithm.h.

Referenced by init_DynIneffDB(), and SiPixelDigitizerAlgorithm().

◆ SiPixelLorentzAngle_

const SiPixelLorentzAngle* SiPixelDigitizerAlgorithm::SiPixelLorentzAngle_ = nullptr

private

Definition at line 109 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ SiPixelLorentzAngleToken_

edm::ESGetToken<SiPixelLorentzAngle, SiPixelLorentzAngleSimRcd> SiPixelDigitizerAlgorithm::SiPixelLorentzAngleToken_

private

Definition at line 108 of file SiPixelDigitizerAlgorithm.h.

Referenced by SiPixelDigitizerAlgorithm().

◆ store_SimHitEntryExitPoints_

const bool SiPixelDigitizerAlgorithm::store_SimHitEntryExitPoints_

private

Definition at line 279 of file SiPixelDigitizerAlgorithm.h.

Referenced by induce_signal(), make_digis(), and SiPixelDigitizerAlgorithm().

◆ tanLorentzAnglePerTesla_BPix

const float SiPixelDigitizerAlgorithm::tanLorentzAnglePerTesla_BPix

private

Definition at line 333 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ tanLorentzAnglePerTesla_FPix

const float SiPixelDigitizerAlgorithm::tanLorentzAnglePerTesla_FPix

private

Definition at line 332 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection().

◆ theAdcFullScale

const int SiPixelDigitizerAlgorithm::theAdcFullScale

private

Definition at line 309 of file SiPixelDigitizerAlgorithm.h.

Referenced by make_digis(), and SiPixelDigitizerAlgorithm().

◆ theAdcFullScLateCR

const int SiPixelDigitizerAlgorithm::theAdcFullScLateCR

private

Definition at line 310 of file SiPixelDigitizerAlgorithm.h.

Referenced by lateSignalReweight().

◆ theElectronPerADC

const float SiPixelDigitizerAlgorithm::theElectronPerADC

private

Definition at line 308 of file SiPixelDigitizerAlgorithm.h.

Referenced by lateSignalReweight(), make_digis(), missCalibrate(), setSimAccumulator(), and SiPixelDigitizerAlgorithm().

◆ theGainSmearing

const float SiPixelDigitizerAlgorithm::theGainSmearing

private

Definition at line 358 of file SiPixelDigitizerAlgorithm.h.

◆ TheNewSiPixelChargeReweightingAlgorithmClass

std::unique_ptr<SiPixelChargeReweightingAlgorithm> SiPixelDigitizerAlgorithm::TheNewSiPixelChargeReweightingAlgorithmClass

private

Definition at line 288 of file SiPixelDigitizerAlgorithm.h.

Referenced by induce_signal(), lateSignalReweight(), and SiPixelDigitizerAlgorithm().

◆ theNoiseInElectrons

const float SiPixelDigitizerAlgorithm::theNoiseInElectrons

private

Definition at line 311 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), and lateSignalReweight().

◆ theNoiser

const std::unique_ptr<GaussianTailNoiseGenerator> SiPixelDigitizerAlgorithm::theNoiser

private

Definition at line 375 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

◆ theOffsetSmearing

const float SiPixelDigitizerAlgorithm::theOffsetSmearing

private

Definition at line 359 of file SiPixelDigitizerAlgorithm.h.

◆ theReadoutNoise

const float SiPixelDigitizerAlgorithm::theReadoutNoise

private

Definition at line 312 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise().

◆ theSiPixelGainCalibrationService_

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

private

Definition at line 425 of file SiPixelDigitizerAlgorithm.h.

Referenced by pixel_inefficiency_db().

◆ theThresholdInE_BPix

const float SiPixelDigitizerAlgorithm::theThresholdInE_BPix

private

Definition at line 316 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), lateSignalReweight(), make_digis(), and SiPixelDigitizerAlgorithm().

◆ theThresholdInE_BPix_L1

const float SiPixelDigitizerAlgorithm::theThresholdInE_BPix_L1

private

Definition at line 317 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), lateSignalReweight(), make_digis(), and SiPixelDigitizerAlgorithm().

◆ theThresholdInE_BPix_L2

const float SiPixelDigitizerAlgorithm::theThresholdInE_BPix_L2

private

Definition at line 318 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), lateSignalReweight(), make_digis(), and SiPixelDigitizerAlgorithm().

◆ theThresholdInE_FPix

const float SiPixelDigitizerAlgorithm::theThresholdInE_FPix

private

Definition at line 315 of file SiPixelDigitizerAlgorithm.h.

Referenced by add_noise(), digitize(), lateSignalReweight(), make_digis(), and SiPixelDigitizerAlgorithm().

◆ theThresholdSmearing_BPix

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_BPix

private

Definition at line 321 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), and lateSignalReweight().

◆ theThresholdSmearing_BPix_L1

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_BPix_L1

private

Definition at line 322 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), and lateSignalReweight().

◆ theThresholdSmearing_BPix_L2

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_BPix_L2

private

Definition at line 323 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), and lateSignalReweight().

◆ theThresholdSmearing_FPix

const double SiPixelDigitizerAlgorithm::theThresholdSmearing_FPix

private

Definition at line 320 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), and lateSignalReweight().

◆ theTofLowerCut

const float SiPixelDigitizerAlgorithm::theTofLowerCut

private

Definition at line 330 of file SiPixelDigitizerAlgorithm.h.

Referenced by accumulateSimHits().

◆ theTofUpperCut

const float SiPixelDigitizerAlgorithm::theTofUpperCut

private

Definition at line 331 of file SiPixelDigitizerAlgorithm.h.

Referenced by accumulateSimHits().

◆ tMax

const double SiPixelDigitizerAlgorithm::tMax

private

Definition at line 370 of file SiPixelDigitizerAlgorithm.h.

Referenced by fluctuateEloss(), and SiPixelDigitizerAlgorithm().

◆ use_deadmodule_DB_

const bool SiPixelDigitizerAlgorithm::use_deadmodule_DB_

private

Definition at line 283 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize(), and SiPixelDigitizerAlgorithm().

◆ use_ineff_from_db_

const bool SiPixelDigitizerAlgorithm::use_ineff_from_db_

private

Definition at line 281 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

◆ use_LorentzAngle_DB_

const bool SiPixelDigitizerAlgorithm::use_LorentzAngle_DB_

private

Definition at line 284 of file SiPixelDigitizerAlgorithm.h.

Referenced by DriftDirection(), and SiPixelDigitizerAlgorithm().

◆ use_module_killing_

const bool SiPixelDigitizerAlgorithm::use_module_killing_

private

Definition at line 282 of file SiPixelDigitizerAlgorithm.h.

Referenced by digitize().

◆ UseReweighting

const bool SiPixelDigitizerAlgorithm::UseReweighting

private

Definition at line 363 of file SiPixelDigitizerAlgorithm.h.

Referenced by induce_signal(), lateSignalReweight(), and SiPixelDigitizerAlgorithm().

Classes

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ array_2d

◆ Frame

◆ Parameters

◆ PixelFEDChannelCollectionMap

◆ signal_map_const_iterator

◆ signal_map_iterator

◆ signal_map_type

◆ signalMaps

◆ simhit_collectionMap

◆ simhit_map

◆ subDetTofBin

Constructor & Destructor Documentation

◆ SiPixelDigitizerAlgorithm()

◆ ~SiPixelDigitizerAlgorithm()

Member Function Documentation

◆ accumulateSimHits()

◆ add_noise()

◆ calcQ()

◆ calculateInstlumiFactor() [1/2]

◆ calculateInstlumiFactor() [2/2]

◆ chooseScenario() [1/2]

◆ chooseScenario() [2/2]

◆ digitize()

◆ drift()

◆ DriftDirection()

◆ fillSimHitMaps()

◆ fluctuateEloss()

◆ induce_signal()

◆ init()

◆ init_DynIneffDB()

◆ initCal()

◆ initializeEvent()

◆ killBadFEDChannels()

◆ lateSignalReweight()

◆ make_digis()

◆ missCalibrate()

◆ module_killing_conf()

◆ module_killing_DB()

◆ pixel_aging()

◆ pixel_inefficiency()

◆ pixel_inefficiency_db()

◆ primary_ionization()

◆ resetSimHitMaps()

◆ setSimAccumulator()

Member Data Documentation

◆ _signal

◆ addChargeVCALSmearing

◆ addNoise

◆ addNoisyPixels

◆ AddPixelAging

◆ AddPixelInefficiency

◆ addThresholdSmearing

◆ alpha2Order

◆ BPix_p0

◆ BPix_p1

◆ BPix_p2

◆ BPix_p3

◆ calmap

◆ ClusterWidth

◆ DeadModules

◆ Dist300

◆ doMissCalibrate

◆ doMissCalInLateCR

◆ electronsPerVCAL

◆ electronsPerVCAL_L1

◆ electronsPerVCAL_L1_Offset

◆ electronsPerVCAL_Offset

◆ fluctuate

◆ fluctuateCharge

◆ FPix_p0

◆ FPix_p1