#include <PixelBrickedDigitizerAlgorithm.h>

Inheritance diagram for PixelBrickedDigitizerAlgorithm:

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

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

	~PixelBrickedDigitizerAlgorithm () override

Public Member Functions inherited from PixelDigitizerAlgorithm
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 ()

Additional Inherited Members
Public Attributes inherited from PixelDigitizerAlgorithm
bool	apply_timewalk_

double	even_column_interchannelCoupling_next_column_

double	even_row_interchannelCoupling_next_row_

const edm::ESGetToken < SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	fedCablingMapToken_

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

double	odd_column_interchannelCoupling_next_column_

double	odd_row_interchannelCoupling_next_row_

edm::ESGetToken < SiPixelQuality, SiPixelQualityRcd >	siPixelBadModuleToken_

edm::ESGetToken < SiPixelLorentzAngle, SiPixelLorentzAngleSimRcd >	siPixelLorentzAngleToken_

const TimewalkModel	timewalk_model_

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)

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 13 of file PixelBrickedDigitizerAlgorithm.h.

Constructor & Destructor Documentation

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

Definition at line 26 of file PixelBrickedDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::addPixelInefficiency_, PixelDigitizerAlgorithm::even_row_interchannelCoupling_next_row_, edm::ParameterSet::getParameter(), LogDebug, Phase2TrackerDigitizerAlgorithm::pixelFlag_, Phase2TrackerDigitizerAlgorithm::theAdcFullScale_, Phase2TrackerDigitizerAlgorithm::theElectronPerADC_, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap_, and Phase2TrackerDigitizerAlgorithm::tMax_.

     : PixelDigitizerAlgorithm(conf, iC)
 /*    odd_row_interchannelCoupling_next_row_(conf.getParameter<ParameterSet>("PixelBrickedDigitizerAlgorithm")
                                                  .getParameter<double>("Odd_row_interchannelCoupling_next_row"))
          even_row_interchannelCoupling_next_row_(conf.getParameter<ParameterSet>("PixelBrickedDigitizerAlgorithm")
                                                   .getParameter<double>("Even_row_interchannelCoupling_next_row")),
       odd_column_interchannelCoupling_next_column_(
           conf.getParameter<ParameterSet>("PixelBrickedDigitizerAlgorithm")
               .getParameter<double>("Odd_column_interchannelCoupling_next_column")),
       even_column_interchannelCoupling_next_column_(
           conf.getParameter<ParameterSet>("PixelBrickedDigitizerAlgorithm")
       .getParameter<double>("Even_column_interchannelCoupling_next_column"))*/
 {
   even_row_interchannelCoupling_next_row_ = conf.getParameter<ParameterSet>("PixelBrickedDigitizerAlgorithm")
                                                 .getParameter<double>("Even_row_interchannelCoupling_next_row");
   pixelFlag_ = true;
   LogDebug("PixelBrickedDigitizerAlgorithm")
       << "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_;
 }

PixelBrickedDigitizerAlgorithm::~PixelBrickedDigitizerAlgorithm ( )

override

Definition at line 50 of file PixelBrickedDigitizerAlgorithm.cc.

References LogDebug.

                                                                 {
   LogDebug("PixelBrickedDigitizerAlgorithm") << "Algorithm deleted";
 }

Member Function Documentation

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

override

Definition at line 53 of file PixelBrickedDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::_signal, c_inv, Phase2TrackerDigitizerAlgorithm::calcQ(), officialStyle::chan, PixelTestBeamValidation_cfi::Charge, Phase2TrackerDigitizerAlgorithm::clusterWidth_, GeomDet::geographicalId(), PSimHit::localPosition(), Topology::localPosition(), mag(), Phase2TrackerDigitizerAlgorithm::makeDigiSimLinks_, SiStripPI::max, Topology::measurementPosition(), SiStripPI::min, PixelTopology::ncolumns(), PixelTopology::nrows(), Phase2TrackerDigitizerAlgorithm::pixelFlag_, Phase2TrackerDigi::pixelToChannel(), PixelDigi::pixelToChannel(), DetId::rawId(), PixelGeomDetUnit::specificTopology(), GeomDet::surface(), PSimHit::tof(), Surface::toGlobal(), findQualityFiles::v, x, PV2DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::x(), y, PV2DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::y().

                                                                                                                     {
   // X  - Rows, Left-Right, 160, (1.6cm)   for barrel
   // Y  - Columns, Down-Up, 416, (6.4cm)
   const Phase2TrackerTopology* topol = &pixdet->specificTopology();
   uint32_t detID = pixdet->geographicalId().rawId();
   signal_map_type& theSignal = _signal[detID];
 
   // local map to store pixels hit by 1 Hit.
   using hit_map_type = std::map<int, float, std::less<int> >;
   hit_map_type hit_signal;
 
   // Assign signals to readout channels and store sorted by channel number
   // Iterate over collection points on the collection plane
   for (auto const& v : collection_points) {
     float CloudCenterX = v.position().x();  // Charge position in x
     float CloudCenterY = v.position().y();  //                 in y
     float SigmaX = v.sigma_x();             // Charge spread in x
     float SigmaY = v.sigma_y();             //               in y
     float Charge = v.amplitude();           // Charge amplitude
 
     // 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);
     //MeasurementPoint mp_bricked = topol->measurementPosition(PointRightUp);
     int IPixRightUpX = static_cast<int>(std::floor(mp.x()));  // cast reqd.
     //int IPixRightUpY = static_cast<int>(std::floor(mp.y()));
 
     int numColumns = topol->ncolumns();  // det module number of cols&rows
     int numRows = topol->nrows();
     IPixRightUpX = numRows > IPixRightUpX ? IPixRightUpX : numRows - 1;
 
     //Specific to bricked geometry
     int IPixRightUpY = static_cast<int>(mp.y() - 0.5 * (IPixRightUpX % 2));
 
     mp = topol->measurementPosition(PointLeftDown);
 
     int IPixLeftDownX = static_cast<int>(std::floor(mp.x()));
 
     IPixLeftDownX = 0 < IPixLeftDownX ? IPixLeftDownX : 0;
 
     //Specific to bricked geometry
     int IPixLeftDownY = static_cast<int>(mp.y() - 0.5 * (IPixLeftDownX % 2));  //changed in case negative value
 
     IPixRightUpY = numColumns > IPixRightUpY ? IPixRightUpY : numColumns - 1;
     IPixLeftDownY = 0 < IPixLeftDownY ? IPixLeftDownY : 0;
 
     // First integrate charge strips in x
     hit_map_type x;
     for (int ix = IPixLeftDownX; ix <= IPixRightUpX; ++ix) {  // loop over x index
       float xLB, LowerBound;
       // Why is set to 0 if ix=0, does it meen that we accept charge
       // outside the sensor?
       if (ix == 0 || SigmaX == 0.) {  // skip for surface segemnts
         LowerBound = 0.;
       } else {
         mp = MeasurementPoint(ix, 0.0);
         xLB = topol->localPosition(mp).x();
         LowerBound = 1 - calcQ((xLB - CloudCenterX) / SigmaX);
       }
 
       float xUB, UpperBound;
       if (ix == numRows - 1 || SigmaX == 0.) {
         UpperBound = 1.;
       } else {
         mp = MeasurementPoint(ix + 1, 0.0);
         xUB = topol->localPosition(mp).x();
         UpperBound = 1. - calcQ((xUB - CloudCenterX) / SigmaX);
       }
       float TotalIntegrationRange = UpperBound - LowerBound;  // get strip
       x.emplace(ix, TotalIntegrationRange);                   // save strip integral
     }
 
     // Now integrate strips in y. Two maps will be filled: y and y_bricked which will both be used for the induced signal.
     int IPixLeftDownY_bricked = IPixLeftDownY;
     int IPixRightUpY_bricked = IPixRightUpY;
 
     //Specific to bricked geometry
     IPixRightUpY = std::min(IPixRightUpY + int((IPixRightUpX % 2)), numColumns - 1);
 
     //This map will be twice as large as the non-bricked hit map in y to harbor both the integrated charge from the bricked and non-bricked columns.
     hit_map_type y;
     for (int iy = IPixLeftDownY; iy <= IPixRightUpY; ++iy) {  // loop over y index
       float yLB, LowerBound;
       if (iy == 0 || SigmaY == 0.) {
         LowerBound = 0.;
       } else {
         mp = MeasurementPoint(0.0, iy);
         yLB = topol->localPosition(mp).y();
         LowerBound = 1. - calcQ((yLB - CloudCenterY) / SigmaY);
       }
 
       float yUB, UpperBound;
       if (iy >= numColumns - 1 || SigmaY == 0.) {
         UpperBound = 1.;
       } else {
         mp = MeasurementPoint(0.0, iy + 1);
         yUB = topol->localPosition(mp).y();
         UpperBound = 1. - calcQ((yUB - CloudCenterY) / SigmaY);
       }
 
       float TotalIntegrationRange = UpperBound - LowerBound;
 
       //Even indices correspond to the non-bricked columns
       y.emplace(2 * iy, TotalIntegrationRange);  // save strip integral
     }
 
     IPixLeftDownY_bricked = std::max(IPixLeftDownY_bricked - int((!(IPixLeftDownX % 2))), 0);
     for (int iy = IPixLeftDownY_bricked; iy <= IPixRightUpY_bricked; ++iy) {  // loop over y index
       float yLB, LowerBound;
       if (iy == 0 || SigmaY == 0.) {
         LowerBound = 0.;
       } else {
         mp = MeasurementPoint(0.0, iy + 0.5);
         yLB = topol->localPosition(mp).y();
         LowerBound = 1. - calcQ((yLB - CloudCenterY) / SigmaY);
       }
 
       float yUB, UpperBound;
       if (iy >= numColumns || SigmaY == 0.) {  // This was changed for bricked pixels
         UpperBound = 1.;
       } else {
         mp = MeasurementPoint(0.0, iy + 1.5);
         yUB = topol->localPosition(mp).y();
         UpperBound = 1. - calcQ((yUB - CloudCenterY) / SigmaY);
       }
 
       float TotalIntegrationRange = UpperBound - LowerBound;
       //Odd indices correspond to bricked columns
       y.emplace(2 * iy + 1, TotalIntegrationRange);  // save strip integral
     }                                                //loop over y index
 
     // Get the 2D charge integrals by folding x and y strips
     for (int ix = IPixLeftDownX; ix <= IPixRightUpX; ++ix) {                                 // loop over x index
       for (int iy = std::max(0, IPixLeftDownY - int((ix % 2))); iy <= IPixRightUpY; ++iy) {  // loop over y index
         int iy_considered = iy * 2 + ix % 2;
         float ChargeFraction = Charge * x[ix] * y[iy_considered];
 
         int chanFired = -1;
         if (ChargeFraction > 0.) {
           chanFired =
               pixelFlag_ ? PixelDigi::pixelToChannel(ix, iy) : Phase2TrackerDigi::pixelToChannel(ix, iy);  // Get index
           // Load the ampl
           hit_signal[chanFired] += ChargeFraction;
         }
       }
     }  //x loop
   }    //collection loop
   // Fill the global map with all hit pixels from this event
   float corr_time = hit.tof() - pixdet->surface().toGlobal(hit.localPosition()).mag() * c_inv;
   for (auto const& hit_s : hit_signal) {
     int chan = hit_s.first;
     theSignal[chan] +=
         (makeDigiSimLinks_ ? DigitizerUtility::Amplitude(hit_s.second, &hit, hit_s.second, corr_time, hitIndex, tofBin)
                            : DigitizerUtility::Amplitude(hit_s.second, nullptr, hit_s.second));
   }
 }

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation