#include <PixelDigitizerAlgorithm.h>

Inheritance diagram for PixelDigitizerAlgorithm:

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 Phase2TrackerGeomDetUnit *pixdet, const GlobalVector &bfield) override

void	add_cross_talk (const Phase2TrackerGeomDetUnit *pixdet) override

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

	PixelDigitizerAlgorithm (const edm::ParameterSet &conf)

	~PixelDigitizerAlgorithm () override

Public Member Functions inherited from Phase2TrackerDigitizerAlgorithm
virtual void	digitize (const Phase2TrackerGeomDetUnit pixdet, std::map< int, DigitizerUtility::DigiSimInfo > &digi_map, const TrackerTopology tTopo)

virtual void	initializeEvent (CLHEP::HepRandomEngine &eng)

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

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

virtual	~Phase2TrackerDigitizerAlgorithm ()

Public Attributes
const double	even_column_interchannelCoupling_next_column

const double	even_row_interchannelCoupling_next_row

const double	odd_column_interchannelCoupling_next_column

const double	odd_row_interchannelCoupling_next_row

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

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

using	signal_map_const_iterator = signal_map_type::const_iterator

using	signal_map_iterator = signal_map_type::iterator

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

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

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

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

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

double	calcQ (float x) const

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

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

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

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

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

virtual void	module_killing_conf (uint32_t detID)

virtual void	module_killing_DB (uint32_t detID)

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

virtual void	pixel_inefficiency_db (uint32_t detID)

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

Protected Attributes inherited from Phase2TrackerDigitizerAlgorithm
signalMaps	_signal

const bool	addNoise

const bool	addNoisyPixels

const bool	AddPixelInefficiency

const bool	addThresholdSmearing

const bool	addXtalk

const bool	alpha2Order

std::vector< edm::ParameterSet >	badPixels

const float	ClusterWidth

const Parameters	DeadModules

const std::unique_ptr< SiG4UniversalFluctuation >	fluctuate

const bool	fluctuateCharge

std::unique_ptr< CLHEP::RandGaussQ >	gaussDistribution_

edm::ESHandle< TrackerGeometry >	geom_

const float	GeVperElectron

const float	interstripCoupling

const bool	makeDigiSimLinks_

edm::ESHandle< SiPixelFedCablingMap >	map_

bool	pixelFlag

const double	pseudoRadDamage

const double	pseudoRadDamageRadius

CLHEP::HepRandomEngine *	rengine_

const float	Sigma0

const float	SigmaCoeff

edm::ESHandle< SiPixelQuality >	SiPixelBadModule_

edm::ESHandle< SiPixelLorentzAngle >	SiPixelLorentzAngle_

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 PixelDigitizerAlgorithm.h.

Constructor & Destructor Documentation

PixelDigitizerAlgorithm::PixelDigitizerAlgorithm ( const edm::ParameterSet & conf )

Definition at line 64 of file PixelDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::AddPixelInefficiency, Phase2TrackerDigitizerAlgorithm::pixelFlag, Phase2TrackerDigitizerAlgorithm::theAdcFullScale, Phase2TrackerDigitizerAlgorithm::theElectronPerADC, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap, and Phase2TrackerDigitizerAlgorithm::tMax.

     : Phase2TrackerDigitizerAlgorithm(conf.getParameter<ParameterSet>("AlgorithmCommon"),
                                       conf.getParameter<ParameterSet>("PixelDigitizerAlgorithm")),
       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")) {
   pixelFlag = true;
   LogInfo("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 ( )

override

Definition at line 86 of file PixelDigitizerAlgorithm.cc.

References LogDebug.

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

LogDebug

#define LogDebug(id)

Definition: MessageLogger.h:670

Member Function Documentation

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

overridevirtual

Implements Phase2TrackerDigitizerAlgorithm.

Definition at line 87 of file PixelDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::drift(), GeomDet::geographicalId(), Phase2TrackerDigitizerAlgorithm::induce_signal(), LogDebug, mag(), Phase2TrackerDigitizerAlgorithm::primary_ionization(), DetId::rawId(), GeomDet::surface(), Phase2TrackerDigitizerAlgorithm::theTofLowerCut, Phase2TrackerDigitizerAlgorithm::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 be stored to create the digi-sim link later
   for (auto it = inputBegin; it != inputEnd; ++it, ++simHitGlobalIndex) {
     // skip hits not in this detector.
     if ((*it).detUnitId() != detId)
       continue;
 
     LogDebug("PixelDigitizerAlgorithm") << (*it).particleType() << " " << (*it).pabs() << " " << (*it).energyLoss()
                                         << " " << (*it).tof() << " " << (*it).trackId() << " " << (*it).processType()
                                         << " " << (*it).detUnitId() << (*it).entryPoint() << " " << (*it).exitPoint();
 
     std::vector<DigitizerUtility::EnergyDepositUnit> ionization_points;
     std::vector<DigitizerUtility::SignalPoint> collection_points;
 
     // fill collection_points for this SimHit, indpendent of topology
     // Check the TOF cut
     if (((*it).tof() - pixdet->surface().toGlobal((*it).localPosition()).mag() / 30.) >= theTofLowerCut &&
         ((*it).tof() - pixdet->surface().toGlobal((*it).localPosition()).mag() / 30.) <= theTofUpperCut) {
       primary_ionization(*it, ionization_points);  // fills _ionization_points
       // transforms _ionization_points to collection_points
       drift(*it, pixdet, bfield, ionization_points, collection_points);
 
       // compute induced signal on readout elements and add to _signal
       // *ihit needed only for SimHit<-->Digi link
       induce_signal(*it, simHitGlobalIndex, tofBin, pixdet, collection_points);
     }
   }
 }

void PixelDigitizerAlgorithm::add_cross_talk ( const Phase2TrackerGeomDetUnit * pixdet )

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 128 of file PixelDigitizerAlgorithm.cc.

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().

                                                                                    {
   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 (abs(topol->pitch().first - pitch_first) > pitch_tolerance ||
       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()) {
       theSignal[chan] += l.second.ampl();
     } else {
       theSignal.emplace(chan, DigitizerUtility::Amplitude(l.second.ampl(), nullptr, -1.0));
     }
   }
 }

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

overridevirtual

Implements Phase2TrackerDigitizerAlgorithm.

Definition at line 49 of file PixelDigitizerAlgorithm.cc.

References edm::EventSetup::get().

                                                           {
   if (use_ineff_from_db_)  // load gain calibration service fromdb...
     theSiPixelGainCalibrationService_->setESObjects(es);
 
   if (use_deadmodule_DB_)
     es.get<SiPixelQualityRcd>().get(SiPixelBadModule_);
 
   if (use_LorentzAngle_DB_)  // Get Lorentz angle from DB record
     es.get<SiPixelLorentzAngleSimRcd>().get(SiPixelLorentzAngle_);
 
   // gets the map and geometry from the DB (to kill ROCs)
   es.get<SiPixelFedCablingMapRcd>().get(map_);
   es.get<TrackerDigiGeometryRecord>().get(geom_);
 }