#include <SSDigitizerAlgorithm.h>

Inheritance diagram for SSDigitizerAlgorithm:

Public Member Functions
void	init (const edm::EventSetup &es) override

bool	isAboveThreshold (const DigitizerUtility::SimHitInfo *hitInfo, float charge, float thr) const override

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

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

	~SSDigitizerAlgorithm () override

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

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

virtual void	initializeEvent (CLHEP::HepRandomEngine &eng)

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

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

virtual	~Phase2TrackerDigitizerAlgorithm ()

Private Types
enum	{ SquareWindow, SampledMode, LatchedMode, SampledOrLachedMode, HIPFindingMode }

Private Member Functions
double	cbc3PulsePolarExpansion (double x) const

double	getSignalScale (double xval) const

bool	select_hit_latchedMode (const PSimHit &hit, double tCorr, double &sigScale) const

bool	select_hit_sampledMode (const PSimHit &hit, double tCorr, double &sigScale) const

double	signalShape (double x) const

void	storeSignalShape ()

Private Attributes
float	deadTime_

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

int	hitDetectionMode_

std::vector< double >	pulseShapeParameters_

std::vector< double >	pulseShapeVec_

edm::ESGetToken < SiPhase2OuterTrackerLorentzAngle, SiPhase2OuterTrackerLorentzAngleSimRcd >	siPhase2OTLorentzAngleToken_

Static Private Attributes
static constexpr float	bx_time {25}

static constexpr size_t	interpolationPoints {1000}

static constexpr int	interpolationStep {10}

Additional Inherited Members
Protected Types inherited from Phase2TrackerDigitizerAlgorithm
using	Frame = GloballyPositioned< double >

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

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

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

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

virtual void	add_noise (const Phase2TrackerGeomDetUnit *pixdet)

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

float	calcQ (float x)

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

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

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

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

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

virtual void	module_killing_conf (uint32_t detID)

virtual void	module_killing_DB (const Phase2TrackerGeomDetUnit *pixdet)

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

virtual void	pixel_inefficiency_db (uint32_t detID)

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

Protected Attributes inherited from Phase2TrackerDigitizerAlgorithm
signalMaps	_signal

const bool	addNoise_

const bool	addNoisyPixels_

const bool	addPixelInefficiency_

const bool	addThresholdSmearing_

const bool	addXtalk_

const bool	alpha2Order_

Parameters	badPixels_

const float	clusterWidth_

const Parameters	deadModules_

const SiPixelFedCablingMap *	fedCablingMap_

const std::unique_ptr < SiG4UniversalFluctuation >	fluctuate_

const bool	fluctuateCharge_

std::unique_ptr < CLHEP::RandGaussQ >	gaussDistribution_

const TrackerGeometry *	geom_

const float	GeVperElectron_

const float	interstripCoupling_

const bool	makeDigiSimLinks_

bool	pixelFlag_

const double	pseudoRadDamage_

const double	pseudoRadDamageRadius_

CLHEP::HepRandomEngine *	rengine_

const float	Sigma0_

const float	SigmaCoeff_

const SiPhase2OuterTrackerLorentzAngle *	siPhase2OTLorentzAngle_

const SiPixelQuality *	siPixelBadModule_

const SiPixelLorentzAngle *	siPixelLorentzAngle_

std::unique_ptr < CLHEP::RandGaussQ >	smearedThreshold_Barrel_

std::unique_ptr < CLHEP::RandGaussQ >	smearedThreshold_Endcap_

const SubdetEfficiencies	subdetEfficiencies_

const float	tanLorentzAnglePerTesla_Barrel_

const float	tanLorentzAnglePerTesla_Endcap_

const int	theAdcFullScale_

const float	theElectronPerADC_

const double	theHIPThresholdInE_Barrel_

const double	theHIPThresholdInE_Endcap_

const float	theNoiseInElectrons_

const std::unique_ptr < GaussianTailNoiseGenerator >	theNoiser_

const int	thePhase2ReadoutMode_

const float	theReadoutNoise_

const std::unique_ptr < SiPixelGainCalibrationOfflineSimService >	theSiPixelGainCalibrationService_

const float	theThresholdInE_Barrel_

const float	theThresholdInE_Endcap_

const double	theThresholdSmearing_Barrel_

const double	theThresholdSmearing_Endcap_

const float	theTofLowerCut_

const float	theTofUpperCut_

const double	tMax_

const bool	use_deadmodule_DB_

const bool	use_ineff_from_db_

const bool	use_LorentzAngle_DB_

const bool	use_module_killing_

Detailed Description

Definition at line 9 of file SSDigitizerAlgorithm.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
SquareWindow
SampledMode
LatchedMode
SampledOrLachedMode
HIPFindingMode

Definition at line 21 of file SSDigitizerAlgorithm.h.

21 { SquareWindow, SampledMode, LatchedMode, SampledOrLachedMode, HIPFindingMode };

SSDigitizerAlgorithm::LatchedMode

Definition: SSDigitizerAlgorithm.h:21

SSDigitizerAlgorithm::SquareWindow

Definition: SSDigitizerAlgorithm.h:21

SSDigitizerAlgorithm::SampledMode

Definition: SSDigitizerAlgorithm.h:21

SSDigitizerAlgorithm::SampledOrLachedMode

Definition: SSDigitizerAlgorithm.h:21

SSDigitizerAlgorithm::HIPFindingMode

Definition: SSDigitizerAlgorithm.h:21

Constructor & Destructor Documentation

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

Definition at line 36 of file SSDigitizerAlgorithm.cc.

     : Phase2TrackerDigitizerAlgorithm(conf.getParameter<ParameterSet>("AlgorithmCommon"),
                                       conf.getParameter<ParameterSet>("SSDigitizerAlgorithm"),
                                       iC),
       hitDetectionMode_(conf.getParameter<ParameterSet>("SSDigitizerAlgorithm").getParameter<int>("HitDetectionMode")),
       pulseShapeParameters_(conf.getParameter<ParameterSet>("SSDigitizerAlgorithm")
                                 .getParameter<std::vector<double> >("PulseShapeParameters")),
       deadTime_(conf.getParameter<ParameterSet>("SSDigitizerAlgorithm").getParameter<double>("CBCDeadTime")),
       geomToken_(iC.esConsumes()) {
   if (use_LorentzAngle_DB_)
     siPhase2OTLorentzAngleToken_ = iC.esConsumes();
   pixelFlag_ = false;
   LogDebug("SSDigitizerAlgorithm ") << "SSDigitizerAlgorithm constructed "
                                     << "Configuration parameters:"
                                     << "Threshold/Gain = "
                                     << "threshold in electron Endcap = " << theThresholdInE_Endcap_
                                     << "threshold in electron Barrel = " << theThresholdInE_Barrel_ << " "
                                     << theElectronPerADC_ << " " << theAdcFullScale_ << " The delta cut-off is set to "
                                     << tMax_ << " pix-inefficiency " << addPixelInefficiency_;
   storeSignalShape();
 }

SSDigitizerAlgorithm::~SSDigitizerAlgorithm ( )

override

Definition at line 57 of file SSDigitizerAlgorithm.cc.

References LogDebug.

57 { LogDebug("SSDigitizerAlgorithm") << "SSDigitizerAlgorithm deleted"; }

LogDebug

#define LogDebug(id)

Definition: MessageLogger.h:233

Member Function Documentation

double SSDigitizerAlgorithm::cbc3PulsePolarExpansion ( double x ) const

private

Definition at line 113 of file SSDigitizerAlgorithm.cc.

References funct::cos(), hcaldqm::quantity::fN, mps_fire::i, dqmiolumiharvest::j, funct::pow(), pulseShapeParameters_, alignCSCRings::r, funct::sin(), metsig::tau, theta(), and phase1PixelTopology::xOffset.

Referenced by signalShape().

                                                                    {
   constexpr size_t max_par = 6;
   if (pulseShapeParameters_.size() < max_par)
     return -1;
   double xOffset = pulseShapeParameters_[0];
   double tau = pulseShapeParameters_[1];
   double r = pulseShapeParameters_[2];
   double theta = pulseShapeParameters_[3];
   int nTerms = static_cast<int>(pulseShapeParameters_[4]);
 
   double fN = 0;
   double xx = x - xOffset;
   if (xx < 0)
     return 0;
 
   for (int i = 0; i < nTerms; i++) {
     double angularTerm = 0;
     double temporalTerm = 0;
     double rTerm = std::pow(r, i) / (std::pow(tau, 2. * i) * ::nFactorial(i + 2));
     for (int j = 0; j <= i; j++) {
       angularTerm += std::pow(std::cos(theta), (double)(i - j)) * std::pow(std::sin(theta), (double)j);
       temporalTerm += ::aScalingConstant(i, j) * std::pow(xx, (double)(i - j)) * std::pow(tau, (double)j);
     }
     double fi = rTerm * angularTerm * temporalTerm;
 
     fN += fi;
   }
   return fN;
 }

double SSDigitizerAlgorithm::getSignalScale ( double xval ) const

private

Definition at line 157 of file SSDigitizerAlgorithm.cc.

References reco::ceil(), mps_fire::i, interpolationStep, pulseShapeVec_, and hgcalPerformanceValidation::val.

Referenced by select_hit_latchedMode(), and select_hit_sampledMode().

                                                              {
   double res = 0.0;
   int len = pulseShapeVec_.size();
 
   if (xval < 0.0 || xval * interpolationStep >= len)
     return res;
 
   unsigned int lower = std::floor(xval) * interpolationStep;
   unsigned int upper = std::ceil(xval) * interpolationStep;
   for (size_t i = lower + 1; i < upper * interpolationStep; i++) {
     float val = i * 0.1;
     if (val > xval) {
       res = pulseShapeVec_[i - 1];
       break;
     }
   }
   return res;
 }

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

overridevirtual

Implements Phase2TrackerDigitizerAlgorithm.

Definition at line 28 of file SSDigitizerAlgorithm.cc.

References edm::EventSetup::getData().

                                                        {
   if (use_LorentzAngle_DB_) {  // Get Lorentz angle from DB record
     siPhase2OTLorentzAngle_ = &es.getData(siPhase2OTLorentzAngleToken_);
   }
 
   geom_ = &es.getData(geomToken_);
 }

bool SSDigitizerAlgorithm::isAboveThreshold	(	const DigitizerUtility::SimHitInfo *	hitInfo,
		float	charge,
		float	thr
	)		const

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 178 of file SSDigitizerAlgorithm.cc.

                                                              {
   return (charge >= thr);
 }

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

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 61 of file SSDigitizerAlgorithm.cc.

References hitDetectionMode_, LatchedMode, mps_fire::result, SampledMode, select_hit_latchedMode(), select_hit_sampledMode(), Phase2TrackerDigitizerAlgorithm::theTofLowerCut_, Phase2TrackerDigitizerAlgorithm::theTofUpperCut_, and PSimHit::tof().

                                                                                               {
   bool result = false;
   if (hitDetectionMode_ == SSDigitizerAlgorithm::SampledMode)
     result = select_hit_sampledMode(hit, tCorr, sigScale);
   else if (hitDetectionMode_ == SSDigitizerAlgorithm::LatchedMode)
     result = select_hit_latchedMode(hit, tCorr, sigScale);
   else {
     double toa = hit.tof() - tCorr;
     result = (toa > theTofLowerCut_ && toa < theTofUpperCut_);
   }
   return result;
 }

bool SSDigitizerAlgorithm::select_hit_latchedMode	(	const PSimHit &	hit,
		double	tCorr,
		double &	sigScale
	)		const

private

Definition at line 90 of file SSDigitizerAlgorithm.cc.

References EncodedEventId::bunchCrossing(), bx_time, deadTime_, PSimHit::detUnitId(), PSimHit::energyLoss(), PSimHit::eventId(), getSignalScale(), Phase2TrackerDigitizerAlgorithm::GeVperElectron_, mps_fire::i, DetId::subdetId(), Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap_, StripSubdetector::TOB, and PSimHit::tof().

Referenced by select_hit().

                                                                                                           {
   float toa = hit.tof() - tCorr;
   toa -= hit.eventId().bunchCrossing() * bx_time;
 
   float sampling_time = (-1) * (hit.eventId().bunchCrossing() + 1) * bx_time;
 
   DetId det_id = DetId(hit.detUnitId());
   float theThresholdInE =
       (det_id.subdetId() == StripSubdetector::TOB) ? theThresholdInE_Barrel_ : theThresholdInE_Endcap_;
 
   bool lastPulse = true;
   bool aboveThr = false;
   for (float i = deadTime_; i <= bx_time; i++) {
     sigScale = getSignalScale(sampling_time - toa + i);
 
     aboveThr = (sigScale * hit.energyLoss() / GeVperElectron_ > theThresholdInE);
     if (!lastPulse && aboveThr)
       return true;
 
     lastPulse = aboveThr;
   }
   return false;
 }

bool SSDigitizerAlgorithm::select_hit_sampledMode	(	const PSimHit &	hit,
		double	tCorr,
		double &	sigScale
	)		const

private

Definition at line 76 of file SSDigitizerAlgorithm.cc.

References bx_time, PSimHit::detUnitId(), PSimHit::energyLoss(), getSignalScale(), Phase2TrackerDigitizerAlgorithm::GeVperElectron_, DetId::subdetId(), Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap_, StripSubdetector::TOB, and PSimHit::tof().

Referenced by select_hit().

                                                                                                           {
   double toa = hit.tof() - tCorr;
   double sampling_time = bx_time;
 
   DetId det_id = DetId(hit.detUnitId());
   float theThresholdInE =
       (det_id.subdetId() == StripSubdetector::TOB) ? theThresholdInE_Barrel_ : theThresholdInE_Endcap_;
 
   sigScale = getSignalScale(sampling_time - toa);
   return (sigScale * hit.energyLoss() / GeVperElectron_ > theThresholdInE);
 }

double SSDigitizerAlgorithm::signalShape ( double x ) const

private

Definition at line 142 of file SSDigitizerAlgorithm.cc.

References cbc3PulsePolarExpansion(), funct::exp(), funct::pow(), pulseShapeParameters_, metsig::tau, and phase1PixelTopology::xOffset.

Referenced by storeSignalShape().

                                                        {
   double xOffset = pulseShapeParameters_[0];
   double tau = pulseShapeParameters_[1];
   double maxCharge = pulseShapeParameters_[5];
 
   double xx = x - xOffset;
   return maxCharge * (std::exp(-xx / tau) * std::pow(xx / tau, 2.) * cbc3PulsePolarExpansion(x));
 }

void SSDigitizerAlgorithm::storeSignalShape ( )

private

Definition at line 150 of file SSDigitizerAlgorithm.cc.

References mps_fire::i, interpolationPoints, interpolationStep, pulseShapeVec_, signalShape(), and hgcalPerformanceValidation::val.

Referenced by SSDigitizerAlgorithm().

                                             {
   for (size_t i = 0; i < interpolationPoints; i++) {
     float val = i / interpolationStep;
 
     pulseShapeVec_.push_back(signalShape(val));
   }
 }