#include <PixelDigitizerAlgorithm.h>

Inheritance diagram for PixelDigitizerAlgorithm:

Classes
class	TimewalkCurve

class	TimewalkModel

Public Member Functions
void	add_cross_talk (const Phase2TrackerGeomDetUnit *pixdet) override

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

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

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

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

	~PixelDigitizerAlgorithm () 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 ()

Public Attributes
bool	apply_timewalk_

const double	even_column_interchannelCoupling_next_column_

const double	even_row_interchannelCoupling_next_row_

const edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	fedCablingMapToken_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

const double	odd_column_interchannelCoupling_next_column_

const double	odd_row_interchannelCoupling_next_row_

edm::ESGetToken< SiPixelQuality, SiPixelQualityRcd >	siPixelBadModuleToken_

edm::ESGetToken< SiPixelLorentzAngle, SiPixelLorentzAngleSimRcd >	siPixelLorentzAngleToken_

const TimewalkModel	timewalk_model_

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_noise (const Phase2TrackerGeomDetUnit *pixdet)

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

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 12 of file PixelDigitizerAlgorithm.h.

Constructor & Destructor Documentation

◆ PixelDigitizerAlgorithm()

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

Definition at line 34 of file PixelDigitizerAlgorithm.cc.

     : Phase2TrackerDigitizerAlgorithm(conf.getParameter<ParameterSet>("AlgorithmCommon"),
                                       conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm"),
                                       iC),
       odd_row_interchannelCoupling_next_row_(conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm")
                                                  .getParameter<double>("Odd_row_interchannelCoupling_next_row")),
       even_row_interchannelCoupling_next_row_(conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm")
                                                   .getParameter<double>("Even_row_interchannelCoupling_next_row")),
       odd_column_interchannelCoupling_next_column_(
           conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm")
               .getParameter<double>("Odd_column_interchannelCoupling_next_column")),
       even_column_interchannelCoupling_next_column_(
           conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm")
               .getParameter<double>("Even_column_interchannelCoupling_next_column")),
       apply_timewalk_(conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm").getParameter<bool>("ApplyTimewalk")),
       timewalk_model_(
           conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm").getParameter<edm::ParameterSet>("TimewalkModel")),
       fedCablingMapToken_(iC.esConsumes()),
       geomToken_(iC.esConsumes()) {
   if (use_deadmodule_DB_)
     siPixelBadModuleToken_ = iC.esConsumes();
   if (use_LorentzAngle_DB_)
     siPixelLorentzAngleToken_ = iC.esConsumes();
   pixelFlag_ = true;
   LogDebug("PixelDigitizerAlgorithm") << "Algorithm 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_;
 }

◆ ~PixelDigitizerAlgorithm()

PixelDigitizerAlgorithm::~PixelDigitizerAlgorithm ( )

override

Definition at line 67 of file PixelDigitizerAlgorithm.cc.

67 { LogDebug("PixelDigitizerAlgorithm") << "Algorithm deleted"; }

References LogDebug.

Member Function Documentation

◆ add_cross_talk()

void PixelDigitizerAlgorithm::add_cross_talk ( const Phase2TrackerGeomDetUnit * pixdet )

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 81 of file PixelDigitizerAlgorithm.cc.

                                                                                    {
   if (!pixelFlag_)
     return;
  
   const Phase2TrackerTopology* topol = &pixdet->specificTopology();
  
   // cross-talk calculation valid for the case of 25x100 pixels
   const float pitch_first = 0.0025;
   const float pitch_second = 0.0100;
  
   // 0.5 um tolerance when comparing the pitch to accommodate the small changes in different TK geometrie (temporary fix)
   const double pitch_tolerance(0.0005);
  
   if (std::abs(topol->pitch().first - pitch_first) > pitch_tolerance ||
       std::abs(topol->pitch().second - pitch_second) > pitch_tolerance)
     return;
  
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
   signal_map_type signalNew;
  
   int numRows = topol->nrows();
   int numColumns = topol->ncolumns();
  
   for (auto& s : theSignal) {
     float signalInElectrons = s.second.ampl();  // signal in electrons
  
     auto hitChan = PixelDigi::channelToPixel(s.first);
  
     float signalInElectrons_odd_row_Xtalk_next_row = signalInElectrons * odd_row_interchannelCoupling_next_row_;
     float signalInElectrons_even_row_Xtalk_next_row = signalInElectrons * even_row_interchannelCoupling_next_row_;
     float signalInElectrons_odd_column_Xtalk_next_column =
         signalInElectrons * odd_column_interchannelCoupling_next_column_;
     float signalInElectrons_even_column_Xtalk_next_column =
         signalInElectrons * even_column_interchannelCoupling_next_column_;
  
     // subtract the charge which will be shared
     s.second.set(signalInElectrons - signalInElectrons_odd_row_Xtalk_next_row -
                  signalInElectrons_even_row_Xtalk_next_row - signalInElectrons_odd_column_Xtalk_next_column -
                  signalInElectrons_even_column_Xtalk_next_column);
  
     if (hitChan.first != 0) {
       auto XtalkPrev = std::make_pair(hitChan.first - 1, hitChan.second);
       int chanXtalkPrev = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second)
                                      : Phase2TrackerDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second);
       if (hitChan.first % 2 == 1)
         signalNew.emplace(chanXtalkPrev,
                           DigitizerUtility::Amplitude(signalInElectrons_even_row_Xtalk_next_row, nullptr, -1.0));
       else
         signalNew.emplace(chanXtalkPrev,
                           DigitizerUtility::Amplitude(signalInElectrons_odd_row_Xtalk_next_row, nullptr, -1.0));
     }
     if (hitChan.first < numRows - 1) {
       auto XtalkNext = std::make_pair(hitChan.first + 1, hitChan.second);
       int chanXtalkNext = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkNext.first, XtalkNext.second)
                                      : Phase2TrackerDigi::pixelToChannel(XtalkNext.first, XtalkNext.second);
       if (hitChan.first % 2 == 1)
         signalNew.emplace(chanXtalkNext,
                           DigitizerUtility::Amplitude(signalInElectrons_odd_row_Xtalk_next_row, nullptr, -1.0));
       else
         signalNew.emplace(chanXtalkNext,
                           DigitizerUtility::Amplitude(signalInElectrons_even_row_Xtalk_next_row, nullptr, -1.0));
     }
  
     if (hitChan.second != 0) {
       auto XtalkPrev = std::make_pair(hitChan.first, hitChan.second - 1);
       int chanXtalkPrev = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second)
                                      : Phase2TrackerDigi::pixelToChannel(XtalkPrev.first, XtalkPrev.second);
       if (hitChan.second % 2 == 1)
         signalNew.emplace(chanXtalkPrev,
                           DigitizerUtility::Amplitude(signalInElectrons_even_column_Xtalk_next_column, nullptr, -1.0));
       else
         signalNew.emplace(chanXtalkPrev,
                           DigitizerUtility::Amplitude(signalInElectrons_odd_column_Xtalk_next_column, nullptr, -1.0));
     }
     if (hitChan.second < numColumns - 1) {
       auto XtalkNext = std::make_pair(hitChan.first, hitChan.second + 1);
       int chanXtalkNext = pixelFlag_ ? PixelDigi::pixelToChannel(XtalkNext.first, XtalkNext.second)
                                      : Phase2TrackerDigi::pixelToChannel(XtalkNext.first, XtalkNext.second);
       if (hitChan.second % 2 == 1)
         signalNew.emplace(chanXtalkNext,
                           DigitizerUtility::Amplitude(signalInElectrons_odd_column_Xtalk_next_column, nullptr, -1.0));
       else
         signalNew.emplace(chanXtalkNext,
                           DigitizerUtility::Amplitude(signalInElectrons_even_column_Xtalk_next_column, nullptr, -1.0));
     }
   }
   for (auto const& l : signalNew) {
     int chan = l.first;
     auto iter = theSignal.find(chan);
     if (iter != theSignal.end()) {
       iter->second += l.second.ampl();
     } else {
       theSignal.emplace(chan, DigitizerUtility::Amplitude(l.second.ampl(), nullptr, -1.0));
     }
   }
 }

References Phase2TrackerDigitizerAlgorithm::_signal, funct::abs(), officialStyle::chan, PixelDigi::channelToPixel(), even_column_interchannelCoupling_next_column_, even_row_interchannelCoupling_next_row_, GeomDet::geographicalId(), cmsLHEtoEOSManager::l, PixelTopology::ncolumns(), PixelTopology::nrows(), odd_column_interchannelCoupling_next_column_, odd_row_interchannelCoupling_next_row_, PixelTopology::pitch(), Phase2TrackerDigitizerAlgorithm::pixelFlag_, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), alignCSCRings::s, and PixelGeomDetUnit::specificTopology().

◆ init()

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

overridevirtual

Implements Phase2TrackerDigitizerAlgorithm.

Definition at line 19 of file PixelDigitizerAlgorithm.cc.

                                                           {
   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)
   fedCablingMap_ = &es.getData(fedCablingMapToken_);
   geom_ = &es.getData(geomToken_);
 }

References edm::EventSetup::getData().

◆ isAboveThreshold()

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

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 231 of file PixelDigitizerAlgorithm.cc.

                                                                 {
   if (charge < thr)
     return false;
   if (apply_timewalk_ && hitInfo) {
     float corrected_time = hitInfo->time();
     double time = corrected_time + timewalk_model_(charge, thr);
     return (time >= theTofLowerCut_ && time < theTofUpperCut_);
   } else
     return true;
 }

References apply_timewalk_, ALCARECOTkAlJpsiMuMu_cff::charge, Phase2TrackerDigitizerAlgorithm::theTofLowerCut_, Phase2TrackerDigitizerAlgorithm::theTofUpperCut_, DigitizerUtility::SimHitInfo::time(), protons_cff::time, and timewalk_model_.

◆ select_hit()

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

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 71 of file PixelDigitizerAlgorithm.cc.

                                                                                                  {
   double time = hit.tof() - tCorr;
   return (time >= theTofLowerCut_ && time < theTofUpperCut_);
 }