PixelDigitizerAlgorithm Class Reference

#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
void	module_killing_DB (const Phase2TrackerGeomDetUnit *pixdet) 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_
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_

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::Ph2Amplitude, 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 (std::vector< PSimHit >::const_iterator inputBegin, const PSimHit &hit, const size_t hitIndex, const size_t firstHitIndex, const uint32_t tofBin, const Phase2TrackerGeomDetUnit *pixdet, const std::vector< digitizerUtility::SignalPoint > &collection_points)
virtual void	module_killing_conf (uint32_t detID)
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< SiPixelChargeReweightingAlgorithm >	theSiPixelChargeReweightingAlgorithm_
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_
const bool	useChargeReweighting_

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 43 of file PixelDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::addPixelInefficiency_, edm::ConsumesCollector::esConsumes(), LogDebug, Phase2TrackerDigitizerAlgorithm::pixelFlag_, siPixelBadModuleToken_, siPixelLorentzAngleToken_, Phase2TrackerDigitizerAlgorithm::theAdcFullScale_, Phase2TrackerDigitizerAlgorithm::theElectronPerADC_, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Barrel_, Phase2TrackerDigitizerAlgorithm::theThresholdInE_Endcap_, Phase2TrackerDigitizerAlgorithm::tMax_, Phase2TrackerDigitizerAlgorithm::use_deadmodule_DB_, and Phase2TrackerDigitizerAlgorithm::use_LorentzAngle_DB_.

    : 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 77 of file PixelDigitizerAlgorithm.cc.

References LogDebug.

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

Member Function Documentation

add_cross_talk()

void PixelDigitizerAlgorithm::add_cross_talk ( const Phase2TrackerGeomDetUnit *  pixdet )

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 92 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 (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::Ph2Amplitude(signalInElectrons_even_row_Xtalk_next_row, nullptr, -1.0));
      else
        signalNew.emplace(chanXtalkPrev,
                          digitizerUtility::Ph2Amplitude(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::Ph2Amplitude(signalInElectrons_odd_row_Xtalk_next_row, nullptr, -1.0));
      else
        signalNew.emplace(chanXtalkNext,
                          digitizerUtility::Ph2Amplitude(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::Ph2Amplitude(signalInElectrons_even_column_Xtalk_next_column, nullptr, -1.0));
      else
        signalNew.emplace(
            chanXtalkPrev,
            digitizerUtility::Ph2Amplitude(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::Ph2Amplitude(signalInElectrons_odd_column_Xtalk_next_column, nullptr, -1.0));
      else
        signalNew.emplace(
            chanXtalkNext,
            digitizerUtility::Ph2Amplitude(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::Ph2Amplitude(l.second.ampl(), nullptr, -1.0));
    }
  }
}

init()

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

overridevirtual

Implements Phase2TrackerDigitizerAlgorithm.

Definition at line 25 of file PixelDigitizerAlgorithm.cc.

References edm::EventSetup::getData().

                                                          {
  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_);
  if (useChargeReweighting_) {
    theSiPixelChargeReweightingAlgorithm_->init(es);
  }
}

isAboveThreshold()

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

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 246 of file PixelDigitizerAlgorithm.cc.

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

                                                                {
  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;
}

module_killing_DB()

void PixelDigitizerAlgorithm::module_killing_DB ( const Phase2TrackerGeomDetUnit *  pixdet )

overridevirtual

Implements Phase2TrackerDigitizerAlgorithm.

Definition at line 261 of file PixelDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::_signal, funct::abs(), Phase2TrackerDigitizerAlgorithm::badPixels_, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), SiPixelQuality::disabledModuleType::errorType, Phase2TrackerDigitizerAlgorithm::fedCablingMap_, SiPixelFedCablingMap::findItem(), GeomDet::geographicalId(), SiPixelQuality::getBadComponentList(), sipixelobjects::PixelROC::idInDetUnit(), SiPixelQuality::IsRocBad(), dqmiolumiharvest::j, dqmdumpme::k, DTRecHitClients_cfi::local, mod(), PixelTopology::ncolumns(), AlCaHLTBitMon_ParallelJobs::p, castor_dqm_sourceclient_file_cfg::path, SiPixelFedCablingMap::pathToDetUnit(), Phase2TrackerDigitizerAlgorithm::pixelFlag_, DetId::rawId(), alignCSCRings::s, Phase2TrackerDigitizerAlgorithm::siPixelBadModule_, PixelGeomDetUnit::specificTopology(), and sipixelobjects::PixelROC::toGlobal().

                                                                                      {
  bool isbad = false;
  uint32_t detID = pixdet->geographicalId().rawId();
  int ncol = pixdet->specificTopology().ncolumns();
  if (ncol < 0)
    return;
  std::vector<SiPixelQuality::disabledModuleType> disabledModules = siPixelBadModule_->getBadComponentList();

  SiPixelQuality::disabledModuleType badmodule;
  for (const auto& mod : disabledModules) {
    if (detID == mod.DetID) {
      isbad = true;
      badmodule = mod;
      break;
    }
  }

  if (!isbad)
    return;

  signal_map_type& theSignal = _signal[detID];  // check validity
  if (badmodule.errorType == 0) {               // this is a whole dead module.
    for (auto& s : theSignal)
      s.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;
    for (size_t j = 0; j < static_cast<size_t>(ncol); j++) {
      if (siPixelBadModule_->IsRocBad(detID, j)) {
        std::vector<CablingPathToDetUnit> path = fedCablingMap_->pathToDetUnit(detID);
        for (auto const& p : path) {
          const PixelROC* myroc = fedCablingMap_->findItem(p);
          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;
          }
        }
      }
    }

    for (auto& s : theSignal) {
      std::pair<int, int> ip;
      if (pixelFlag_)
        ip = PixelDigi::channelToPixel(s.first);
      else
        ip = Phase2TrackerDigi::channelToPixel(s.first);

      for (auto const& p : badrocpositions) {
        for (auto& k : badPixels_) {
          if (p.row == k.getParameter<int>("row") && ip.first == k.getParameter<int>("row") &&
              std::abs(ip.second - p.col) < k.getParameter<int>("col")) {
            s.second.set(0.);
          }
        }
      }
    }
  }
}

select_hit()

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

overridevirtual

Reimplemented from Phase2TrackerDigitizerAlgorithm.

Definition at line 82 of file PixelDigitizerAlgorithm.cc.

References Phase2TrackerDigitizerAlgorithm::theTofLowerCut_, Phase2TrackerDigitizerAlgorithm::theTofUpperCut_, and protons_cff::time.

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

Member Data Documentation

apply_timewalk_

bool PixelDigitizerAlgorithm::apply_timewalk_

Definition at line 62 of file PixelDigitizerAlgorithm.h.

Referenced by isAboveThreshold().

even_column_interchannelCoupling_next_column_

double PixelDigitizerAlgorithm::even_column_interchannelCoupling_next_column_

Definition at line 59 of file PixelDigitizerAlgorithm.h.

Referenced by add_cross_talk().

even_row_interchannelCoupling_next_row_

double PixelDigitizerAlgorithm::even_row_interchannelCoupling_next_row_

Definition at line 57 of file PixelDigitizerAlgorithm.h.

Referenced by add_cross_talk().

fedCablingMapToken_

const edm::ESGetToken<SiPixelFedCablingMap, SiPixelFedCablingMapRcd> PixelDigitizerAlgorithm::fedCablingMapToken_

Definition at line 67 of file PixelDigitizerAlgorithm.h.

geomToken_

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

Definition at line 68 of file PixelDigitizerAlgorithm.h.

odd_column_interchannelCoupling_next_column_

double PixelDigitizerAlgorithm::odd_column_interchannelCoupling_next_column_

Definition at line 58 of file PixelDigitizerAlgorithm.h.

Referenced by add_cross_talk().

odd_row_interchannelCoupling_next_row_

double PixelDigitizerAlgorithm::odd_row_interchannelCoupling_next_row_

Definition at line 56 of file PixelDigitizerAlgorithm.h.

Referenced by add_cross_talk().

siPixelBadModuleToken_

edm::ESGetToken<SiPixelQuality, SiPixelQualityRcd> PixelDigitizerAlgorithm::siPixelBadModuleToken_

Definition at line 65 of file PixelDigitizerAlgorithm.h.

Referenced by PixelDigitizerAlgorithm().

siPixelLorentzAngleToken_

edm::ESGetToken<SiPixelLorentzAngle, SiPixelLorentzAngleSimRcd> PixelDigitizerAlgorithm::siPixelLorentzAngleToken_

Definition at line 66 of file PixelDigitizerAlgorithm.h.

Referenced by PixelDigitizerAlgorithm().

timewalk_model_

const TimewalkModel PixelDigitizerAlgorithm::timewalk_model_

Definition at line 63 of file PixelDigitizerAlgorithm.h.

Referenced by isAboveThreshold().