EcalUncalibRecHitWorkerGlobal Class Reference

#include <EcalUncalibRecHitWorkerGlobal.h>

Inheritance diagram for EcalUncalibRecHitWorkerGlobal:

Public Member Functions
	EcalUncalibRecHitWorkerGlobal ()
	EcalUncalibRecHitWorkerGlobal (const edm::ParameterSet &, edm::ConsumesCollector &c)
edm::ParameterSetDescription	getAlgoDescription () override
bool	run (const edm::Event &evt, const EcalDigiCollection::const_iterator &digi, EcalUncalibratedRecHitCollection &result) override
void	set (const edm::EventSetup &es) override
	~EcalUncalibRecHitWorkerGlobal () override
Public Member Functions inherited from EcalUncalibRecHitWorkerRunOneDigiBase
	EcalUncalibRecHitWorkerRunOneDigiBase ()
	EcalUncalibRecHitWorkerRunOneDigiBase (const edm::ParameterSet &p)
	EcalUncalibRecHitWorkerRunOneDigiBase (const edm::ParameterSet &p, edm::ConsumesCollector &c)
void	run (const edm::Event &evt, const EcalDigiCollection &digis, EcalUncalibratedRecHitCollection &result) override
	~EcalUncalibRecHitWorkerRunOneDigiBase () override
Public Member Functions inherited from EcalUncalibRecHitWorkerBaseClass
	EcalUncalibRecHitWorkerBaseClass ()
	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &)
	EcalUncalibRecHitWorkerBaseClass (const edm::ParameterSet &, edm::ConsumesCollector &c)
virtual void	set (const edm::Event &evt)
virtual	~EcalUncalibRecHitWorkerBaseClass ()

Protected Member Functions
template<class C >
int	isSaturated (const C &digi)
double	timeCorrection (float ampli, const std::vector< float > &amplitudeBins, const std::vector< float > &shiftBins)

Protected Attributes
double	amplitudeThreshEB_
double	amplitudeThreshEE_
const EcalWeightSet::EcalChi2WeightMatrix *	chi2mat [2]
double	chi2ThreshEB_
double	chi2ThreshEE_
std::vector< double >	EBamplitudeFitParameters_
std::vector< double >	EBchi2Parameters_
std::vector< double >	ebPulseShape_
double	ebSpikeThresh_
double	EBtimeConstantTerm_
std::pair< double, double >	EBtimeFitLimits_
std::vector< double >	EBtimeFitParameters_
double	EBtimeNconst_
std::vector< double >	EEamplitudeFitParameters_
std::vector< double >	EEchi2Parameters_
std::vector< double >	eePulseShape_
double	EEtimeConstantTerm_
std::pair< double, double >	EEtimeFitLimits_
std::vector< double >	EEtimeFitParameters_
double	EEtimeNconst_
double	gainRatios [3]
edm::ESHandle< EcalGainRatios >	gains_
edm::ESHandle< EcalWeightXtalGroups >	grps_
edm::ESHandle< EcalTimeCalibConstants >	itime_
bool	kPoorRecoFlagEB_
bool	kPoorRecoFlagEE_
edm::ESHandle< EcalTimeOffsetConstant >	offtime_
double	outOfTimeThreshG12mEB_
double	outOfTimeThreshG12mEE_
double	outOfTimeThreshG12pEB_
double	outOfTimeThreshG12pEE_
double	outOfTimeThreshG61mEB_
double	outOfTimeThreshG61mEE_
double	outOfTimeThreshG61pEB_
double	outOfTimeThreshG61pEE_
double	pedRMSVec [3]
edm::ESHandle< EcalPedestals >	peds_
double	pedVec [3]
EcalUncalibRecHitRatioMethodAlgo< EBDataFrame >	ratioMethod_barrel_
EcalUncalibRecHitRatioMethodAlgo< EEDataFrame >	ratioMethod_endcap_
edm::ESHandle< EcalSampleMask >	sampleMaskHand_
EBShape	testbeamEBShape
EEShape	testbeamEEShape
edm::ESHandle< EcalTimeBiasCorrections >	timeCorrBias_
edm::ESGetToken< EcalGainRatios, EcalGainRatiosRcd >	tokenGains_
edm::ESGetToken< EcalWeightXtalGroups, EcalWeightXtalGroupsRcd >	tokenGrps_
edm::ESGetToken< EcalTimeCalibConstants, EcalTimeCalibConstantsRcd >	tokenItime_
edm::ESGetToken< EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd >	tokenOfftime_
edm::ESGetToken< EcalPedestals, EcalPedestalsRcd >	tokenPeds_
edm::ESGetToken< EcalSampleMask, EcalSampleMaskRcd >	tokenSampleMask_
edm::ESGetToken< EcalTimeBiasCorrections, EcalTimeBiasCorrectionsRcd >	tokenTimeCorrBias_
edm::ESGetToken< EcalTBWeights, EcalTBWeightsRcd >	tokenWgts_
const EcalWeightSet::EcalWeightMatrix *	weights [2]
EcalUncalibRecHitRecWeightsAlgo< EBDataFrame >	weightsMethod_barrel_
EcalUncalibRecHitRecWeightsAlgo< EEDataFrame >	weightsMethod_endcap_
edm::ESHandle< EcalTBWeights >	wgts_

Detailed Description

Definition at line 44 of file EcalUncalibRecHitWorkerGlobal.h.

Constructor & Destructor Documentation

EcalUncalibRecHitWorkerGlobal() [1/2]

EcalUncalibRecHitWorkerGlobal::EcalUncalibRecHitWorkerGlobal	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &	c
	)

Definition at line 11 of file EcalUncalibRecHitWorkerGlobal.cc.

    : EcalUncalibRecHitWorkerRunOneDigiBase(ps, c),
      tokenPeds_(c.esConsumes<EcalPedestals, EcalPedestalsRcd>()),
      tokenGains_(c.esConsumes<EcalGainRatios, EcalGainRatiosRcd>()),
      tokenGrps_(c.esConsumes<EcalWeightXtalGroups, EcalWeightXtalGroupsRcd>()),
      tokenWgts_(c.esConsumes<EcalTBWeights, EcalTBWeightsRcd>()),
      testbeamEEShape(EEShape(true)),
      testbeamEBShape(EBShape(true)),
      tokenSampleMask_(c.esConsumes<EcalSampleMask, EcalSampleMaskRcd>()),
      tokenTimeCorrBias_(c.esConsumes<EcalTimeBiasCorrections, EcalTimeBiasCorrectionsRcd>()),
      tokenItime_(c.esConsumes<EcalTimeCalibConstants, EcalTimeCalibConstantsRcd>()),
      tokenOfftime_(c.esConsumes<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd>()) {
  // ratio method parameters
  EBtimeFitParameters_ = ps.getParameter<std::vector<double>>("EBtimeFitParameters");
  EEtimeFitParameters_ = ps.getParameter<std::vector<double>>("EEtimeFitParameters");
  EBamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EBamplitudeFitParameters");
  EEamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EEamplitudeFitParameters");
  EBtimeFitLimits_.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
  EBtimeFitLimits_.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
  EEtimeFitLimits_.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
  EEtimeFitLimits_.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
  EBtimeConstantTerm_ = ps.getParameter<double>("EBtimeConstantTerm");
  EBtimeNconst_ = ps.getParameter<double>("EBtimeNconst");
  EEtimeConstantTerm_ = ps.getParameter<double>("EEtimeConstantTerm");
  EEtimeNconst_ = ps.getParameter<double>("EEtimeNconst");
  outOfTimeThreshG12pEB_ = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
  outOfTimeThreshG12mEB_ = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
  outOfTimeThreshG61pEB_ = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
  outOfTimeThreshG61mEB_ = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
  outOfTimeThreshG12pEE_ = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
  outOfTimeThreshG12mEE_ = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
  outOfTimeThreshG61pEE_ = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
  outOfTimeThreshG61mEE_ = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
  amplitudeThreshEB_ = ps.getParameter<double>("amplitudeThresholdEB");
  amplitudeThreshEE_ = ps.getParameter<double>("amplitudeThresholdEE");
 
  // spike threshold
  ebSpikeThresh_ = ps.getParameter<double>("ebSpikeThreshold");
 
  ebPulseShape_ = ps.getParameter<std::vector<double>>("ebPulseShape");
  eePulseShape_ = ps.getParameter<std::vector<double>>("eePulseShape");
 
  // chi2 parameters
  kPoorRecoFlagEB_ = ps.getParameter<bool>("kPoorRecoFlagEB");
  kPoorRecoFlagEE_ = ps.getParameter<bool>("kPoorRecoFlagEE");
 
  chi2ThreshEB_ = ps.getParameter<double>("chi2ThreshEB_");
  chi2ThreshEE_ = ps.getParameter<double>("chi2ThreshEE_");
  EBchi2Parameters_ = ps.getParameter<std::vector<double>>("EBchi2Parameters");
  EEchi2Parameters_ = ps.getParameter<std::vector<double>>("EEchi2Parameters");
}

References amplitudeThreshEB_, amplitudeThreshEE_, chi2ThreshEB_, chi2ThreshEE_, EBamplitudeFitParameters_, EBchi2Parameters_, ebPulseShape_, ebSpikeThresh_, EBtimeConstantTerm_, EBtimeFitLimits_, EBtimeFitParameters_, EBtimeNconst_, EEamplitudeFitParameters_, EEchi2Parameters_, eePulseShape_, EEtimeConstantTerm_, EEtimeFitLimits_, EEtimeFitParameters_, EEtimeNconst_, edm::ParameterSet::getParameter(), kPoorRecoFlagEB_, kPoorRecoFlagEE_, outOfTimeThreshG12mEB_, outOfTimeThreshG12mEE_, outOfTimeThreshG12pEB_, outOfTimeThreshG12pEE_, outOfTimeThreshG61mEB_, outOfTimeThreshG61mEE_, outOfTimeThreshG61pEB_, and outOfTimeThreshG61pEE_.

EcalUncalibRecHitWorkerGlobal() [2/2]

EcalUncalibRecHitWorkerGlobal::EcalUncalibRecHitWorkerGlobal ( )

inline

Definition at line 47 of file EcalUncalibRecHitWorkerGlobal.h.

: testbeamEEShape(EEShape(true)), testbeamEBShape(EBShape(true)) { ; }

~EcalUncalibRecHitWorkerGlobal()

EcalUncalibRecHitWorkerGlobal::~EcalUncalibRecHitWorkerGlobal ( )

inlineoverride

Definition at line 48 of file EcalUncalibRecHitWorkerGlobal.h.

{};

Member Function Documentation

getAlgoDescription()

edm::ParameterSetDescription EcalUncalibRecHitWorkerGlobal::getAlgoDescription ( )

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 441 of file EcalUncalibRecHitWorkerGlobal.cc.

                                                                             {
  edm::ParameterSetDescription psd;
  psd.addNode(
      edm::ParameterDescription<std::vector<double>>(
          "eePulseShape", {5.2e-05, -5.26e-05, 6.66e-05, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194}, true) and
      edm::ParameterDescription<std::vector<double>>(
          "EBtimeFitParameters",
          {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621},
          true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain61pEB", 5, true) and
      edm::ParameterDescription<double>("amplitudeThresholdEE", 10, true) and
      edm::ParameterDescription<double>("EBtimeConstantTerm", 0.6, true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain61pEE", 1000, true) and
      edm::ParameterDescription<double>("ebSpikeThreshold", 1.042, true) and
      edm::ParameterDescription<double>("EBtimeNconst", 28.5, true) and
      edm::ParameterDescription<bool>("kPoorRecoFlagEB", true, true) and
      edm::ParameterDescription<std::vector<double>>(
          "ebPulseShape", {5.2e-05, -5.26e-05, 6.66e-05, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194}, true) and
      edm::ParameterDescription<double>("EBtimeFitLimits_Lower", 0.2, true) and
      edm::ParameterDescription<bool>("kPoorRecoFlagEE", false, true) and
      edm::ParameterDescription<double>("chi2ThreshEB_", 36.0, true) and
      edm::ParameterDescription<std::vector<double>>(
          "EEtimeFitParameters",
          {-2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277},
          true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain61mEE", 1000, true) and
      edm::ParameterDescription<std::vector<double>>("EEchi2Parameters", {2.122, 0.022, 2.122, 0.022}, true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain12mEE", 1000, true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain12mEB", 5, true) and
      edm::ParameterDescription<double>("EEtimeFitLimits_Upper", 1.4, true) and
      edm::ParameterDescription<double>("EEtimeFitLimits_Lower", 0.2, true) and
      edm::ParameterDescription<std::vector<double>>("EEamplitudeFitParameters", {1.89, 1.4}, true) and
      edm::ParameterDescription<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652}, true) and
      edm::ParameterDescription<double>("amplitudeThresholdEB", 10, true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain12pEE", 1000, true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain12pEB", 5, true) and
      edm::ParameterDescription<double>("EEtimeNconst", 31.8, true) and
      edm::ParameterDescription<double>("outOfTimeThresholdGain61mEB", 5, true) and
      edm::ParameterDescription<std::vector<double>>("EBchi2Parameters", {2.122, 0.022, 2.122, 0.022}, true) and
      edm::ParameterDescription<double>("EEtimeConstantTerm", 1.0, true) and
      edm::ParameterDescription<double>("chi2ThreshEE_", 95.0, true) and
      edm::ParameterDescription<double>("EBtimeFitLimits_Upper", 1.4, true));
 
  return psd;
}

References edm::ParameterSetDescription::addNode().

isSaturated()

template<class C >

int EcalUncalibRecHitWorkerGlobal::isSaturated ( const C &  digi )

protected

Definition at line 90 of file EcalUncalibRecHitWorkerGlobal.cc.

                                                                 {
  //bool saturated_ = 0;
  int cnt;
  for (int j = 0; j < C::MAXSAMPLES - 5; ++j) {
    cnt = 0;
    for (int i = j; i < (j + 5) && i < C::MAXSAMPLES; ++i) {
      if (dataFrame.sample(i).gainId() == 0)
        ++cnt;
    }
    if (cnt == 5)
      return j - 1;  // the last unsaturated sample
  }
  return -1;  // no saturation found
}

References mps_fire::i, and dqmiolumiharvest::j.

run()

bool EcalUncalibRecHitWorkerGlobal::run ( const edm::Event &  evt, const EcalDigiCollection::const_iterator &  digi, EcalUncalibratedRecHitCollection &  result  )

overridevirtual

Implements EcalUncalibRecHitWorkerRunOneDigiBase.

Definition at line 163 of file EcalUncalibRecHitWorkerGlobal.cc.

                                                                                  {
  DetId detid(itdg->id());
 
  const EcalSampleMask* sampleMask_ = sampleMaskHand_.product();
 
  // intelligence for recHit computation
  EcalUncalibratedRecHit uncalibRecHit;
 
  const EcalPedestals::Item* aped = nullptr;
  const EcalMGPAGainRatio* aGain = nullptr;
  const EcalXtalGroupId* gid = nullptr;
  float offsetTime = 0;
 
  if (detid.subdetId() == EcalEndcap) {
    unsigned int hashedIndex = EEDetId(detid).hashedIndex();
    aped = &peds_->endcap(hashedIndex);
    aGain = &gains_->endcap(hashedIndex);
    gid = &grps_->endcap(hashedIndex);
    offsetTime = offtime_->getEEValue();
  } else {
    unsigned int hashedIndex = EBDetId(detid).hashedIndex();
    aped = &peds_->barrel(hashedIndex);
    aGain = &gains_->barrel(hashedIndex);
    gid = &grps_->barrel(hashedIndex);
    offsetTime = offtime_->getEBValue();
  }
 
  pedVec[0] = aped->mean_x12;
  pedVec[1] = aped->mean_x6;
  pedVec[2] = aped->mean_x1;
  pedRMSVec[0] = aped->rms_x12;
  pedRMSVec[1] = aped->rms_x6;
  pedRMSVec[2] = aped->rms_x1;
  gainRatios[0] = 1.;
  gainRatios[1] = aGain->gain12Over6();
  gainRatios[2] = aGain->gain6Over1() * aGain->gain12Over6();
 
  // compute the right bin of the pulse shape using time calibration constants
  EcalTimeCalibConstantMap::const_iterator it = itime_->find(detid);
  EcalTimeCalibConstant itimeconst = 0;
  if (it != itime_->end()) {
    itimeconst = (*it);
  } else {
    edm::LogError("EcalRecHitError") << "No time intercalib const found for xtal " << detid.rawId()
                                     << "! something wrong with EcalTimeCalibConstants in your DB? ";
  }
 
  // === amplitude computation ===
  int leadingSample = -1;
  if (detid.subdetId() == EcalEndcap) {
    leadingSample = ((EcalDataFrame)(*itdg)).lastUnsaturatedSample();
  } else {
    leadingSample = ((EcalDataFrame)(*itdg)).lastUnsaturatedSample();
  }
 
  if (leadingSample == 4) {  // saturation on the expected max sample
    uncalibRecHit = EcalUncalibratedRecHit((*itdg).id(), 4095 * 12, 0, 0, 0);
    uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kSaturated);
    // do not propagate the default chi2 = -1 value to the calib rechit (mapped to 64), set it to 0 when saturation
    uncalibRecHit.setChi2(0);
  } else if (leadingSample >= 0) {  // saturation on other samples: cannot extrapolate from the fourth one
    double pedestal = 0.;
    double gainratio = 1.;
    int gainId = ((EcalDataFrame)(*itdg)).sample(5).gainId();
 
    if (gainId == 0 || gainId == 3) {
      pedestal = aped->mean_x1;
      gainratio = aGain->gain6Over1() * aGain->gain12Over6();
    } else if (gainId == 1) {
      pedestal = aped->mean_x12;
      gainratio = 1.;
    } else if (gainId == 2) {
      pedestal = aped->mean_x6;
      gainratio = aGain->gain12Over6();
    }
    double amplitude = ((double)(((EcalDataFrame)(*itdg)).sample(5).adc()) - pedestal) * gainratio;
    uncalibRecHit = EcalUncalibratedRecHit((*itdg).id(), amplitude, 0, 0, 0);
    uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kSaturated);
    // do not propagate the default chi2 = -1 value to the calib rechit (mapped to 64), set it to 0 when saturation
    uncalibRecHit.setChi2(0);
  } else {
    // weights method
    EcalTBWeights::EcalTDCId tdcid(1);
    EcalTBWeights::EcalTBWeightMap const& wgtsMap = wgts_->getMap();
    EcalTBWeights::EcalTBWeightMap::const_iterator wit;
    wit = wgtsMap.find(std::make_pair(*gid, tdcid));
    if (wit == wgtsMap.end()) {
      edm::LogError("EcalUncalibRecHitError")
          << "No weights found for EcalGroupId: " << gid->id() << " and  EcalTDCId: " << tdcid
          << "\n  skipping digi with id: " << detid.rawId();
 
      return false;
    }
    const EcalWeightSet& wset = wit->second;  // this is the EcalWeightSet
 
    const EcalWeightSet::EcalWeightMatrix& mat1 = wset.getWeightsBeforeGainSwitch();
    const EcalWeightSet::EcalWeightMatrix& mat2 = wset.getWeightsAfterGainSwitch();
 
    weights[0] = &mat1;
    weights[1] = &mat2;
 
    // get uncalibrated recHit from weights
    if (detid.subdetId() == EcalEndcap) {
      uncalibRecHit = weightsMethod_endcap_.makeRecHit(*itdg, pedVec, pedRMSVec, gainRatios, weights, testbeamEEShape);
    } else {
      uncalibRecHit = weightsMethod_barrel_.makeRecHit(*itdg, pedVec, pedRMSVec, gainRatios, weights, testbeamEBShape);
    }
 
    // === time computation ===
    // ratio method
    float const clockToNsConstant = 25.;
    if (detid.subdetId() == EcalEndcap) {
      ratioMethod_endcap_.init(*itdg, *sampleMask_, pedVec, pedRMSVec, gainRatios);
      ratioMethod_endcap_.computeTime(EEtimeFitParameters_, EEtimeFitLimits_, EEamplitudeFitParameters_);
      ratioMethod_endcap_.computeAmplitude(EEamplitudeFitParameters_);
      EcalUncalibRecHitRatioMethodAlgo<EEDataFrame>::CalculatedRecHit crh = ratioMethod_endcap_.getCalculatedRecHit();
      double theTimeCorrectionEE = timeCorrection(
          uncalibRecHit.amplitude(), timeCorrBias_->EETimeCorrAmplitudeBins, timeCorrBias_->EETimeCorrShiftBins);
 
      uncalibRecHit.setJitter(crh.timeMax - 5 + theTimeCorrectionEE);
      uncalibRecHit.setJitterError(
          std::sqrt(pow(crh.timeError, 2) + std::pow(EEtimeConstantTerm_, 2) / std::pow(clockToNsConstant, 2)));
      // consider flagging as kOutOfTime only if above noise
      if (uncalibRecHit.amplitude() > pedRMSVec[0] * amplitudeThreshEE_) {
        float outOfTimeThreshP = outOfTimeThreshG12pEE_;
        float outOfTimeThreshM = outOfTimeThreshG12mEE_;
        // determine if gain has switched away from gainId==1 (x12 gain)
        // and determine cuts (number of 'sigmas') to ose for kOutOfTime
        // >3k ADC is necessasry condition for gain switch to occur
        if (uncalibRecHit.amplitude() > 3000.) {
          for (int iSample = 0; iSample < EEDataFrame::MAXSAMPLES; iSample++) {
            int GainId = ((EcalDataFrame)(*itdg)).sample(iSample).gainId();
            if (GainId != 1) {
              outOfTimeThreshP = outOfTimeThreshG61pEE_;
              outOfTimeThreshM = outOfTimeThreshG61mEE_;
              break;
            }
          }
        }
        float correctedTime = (crh.timeMax - 5) * clockToNsConstant + itimeconst + offsetTime;
        float cterm = EEtimeConstantTerm_;
        float sigmaped = pedRMSVec[0];  // approx for lower gains
        float nterm = EEtimeNconst_ * sigmaped / uncalibRecHit.amplitude();
        float sigmat = std::sqrt(nterm * nterm + cterm * cterm);
        if ((correctedTime > sigmat * outOfTimeThreshP) || (correctedTime < (-1. * sigmat * outOfTimeThreshM))) {
          uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kOutOfTime);
        }
      }
 
    } else {
      ratioMethod_barrel_.init(*itdg, *sampleMask_, pedVec, pedRMSVec, gainRatios);
      ratioMethod_barrel_.fixMGPAslew(*itdg);
      ratioMethod_barrel_.computeTime(EBtimeFitParameters_, EBtimeFitLimits_, EBamplitudeFitParameters_);
      ratioMethod_barrel_.computeAmplitude(EBamplitudeFitParameters_);
      EcalUncalibRecHitRatioMethodAlgo<EBDataFrame>::CalculatedRecHit crh = ratioMethod_barrel_.getCalculatedRecHit();
 
      double theTimeCorrectionEB = timeCorrection(
          uncalibRecHit.amplitude(), timeCorrBias_->EBTimeCorrAmplitudeBins, timeCorrBias_->EBTimeCorrShiftBins);
 
      uncalibRecHit.setJitter(crh.timeMax - 5 + theTimeCorrectionEB);
 
      uncalibRecHit.setJitterError(
          std::sqrt(std::pow(crh.timeError, 2) + std::pow(EBtimeConstantTerm_, 2) / std::pow(clockToNsConstant, 2)));
      // consider flagging as kOutOfTime only if above noise
      if (uncalibRecHit.amplitude() > pedRMSVec[0] * amplitudeThreshEB_) {
        float outOfTimeThreshP = outOfTimeThreshG12pEB_;
        float outOfTimeThreshM = outOfTimeThreshG12mEB_;
        // determine if gain has switched away from gainId==1 (x12 gain)
        // and determine cuts (number of 'sigmas') to ose for kOutOfTime
        // >3k ADC is necessasry condition for gain switch to occur
        if (uncalibRecHit.amplitude() > 3000.) {
          for (int iSample = 0; iSample < EBDataFrame::MAXSAMPLES; iSample++) {
            int GainId = ((EcalDataFrame)(*itdg)).sample(iSample).gainId();
            if (GainId != 1) {
              outOfTimeThreshP = outOfTimeThreshG61pEB_;
              outOfTimeThreshM = outOfTimeThreshG61mEB_;
              break;
            }
          }
        }
        float correctedTime = (crh.timeMax - 5) * clockToNsConstant + itimeconst + offsetTime;
        float cterm = EBtimeConstantTerm_;
        float sigmaped = pedRMSVec[0];  // approx for lower gains
        float nterm = EBtimeNconst_ * sigmaped / uncalibRecHit.amplitude();
        float sigmat = std::sqrt(nterm * nterm + cterm * cterm);
        if ((correctedTime > sigmat * outOfTimeThreshP) || (correctedTime < (-1. * sigmat * outOfTimeThreshM))) {
          uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kOutOfTime);
        }
      }
    }
 
    // === chi2express ===
    if (detid.subdetId() == EcalEndcap) {
      double amplitude = uncalibRecHit.amplitude();
      double amplitudeOutOfTime = 0.;
      double jitter = uncalibRecHit.jitter();
 
      EcalUncalibRecHitRecChi2Algo<EEDataFrame> chi2expressEE_(*itdg,
                                                               amplitude,
                                                               (itimeconst + offsetTime),
                                                               amplitudeOutOfTime,
                                                               jitter,
                                                               pedVec,
                                                               pedRMSVec,
                                                               gainRatios,
                                                               testbeamEEShape,
                                                               EEchi2Parameters_);
      double chi2 = chi2expressEE_.chi2();
      uncalibRecHit.setChi2(chi2);
 
      if (kPoorRecoFlagEE_) {
        if (chi2 > chi2ThreshEE_) {
          // first check if all samples are ok, if not don't use chi2 to flag
          bool samplesok = true;
          for (int sample = 0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
            if (!sampleMask_->useSampleEE(sample)) {
              samplesok = false;
              break;
            }
          }
          if (samplesok)
            uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kPoorReco);
        }
      }
 
    } else {
      double amplitude = uncalibRecHit.amplitude();
      double amplitudeOutOfTime = 0.;
      double jitter = uncalibRecHit.jitter();
 
      EcalUncalibRecHitRecChi2Algo<EBDataFrame> chi2expressEB_(*itdg,
                                                               amplitude,
                                                               (itimeconst + offsetTime),
                                                               amplitudeOutOfTime,
                                                               jitter,
                                                               pedVec,
                                                               pedRMSVec,
                                                               gainRatios,
                                                               testbeamEBShape,
                                                               EBchi2Parameters_);
      double chi2 = chi2expressEB_.chi2();
      uncalibRecHit.setChi2(chi2);
 
      if (kPoorRecoFlagEB_) {
        if (chi2 > chi2ThreshEB_) {
          // first check if all samples are ok, if not don't use chi2 to flag
          bool samplesok = true;
          for (int sample = 0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
            if (!sampleMask_->useSampleEB(sample)) {
              samplesok = false;
              break;
            }
          }
          if (samplesok)
            uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kPoorReco);
        }
      }
    }
  }
 
  // set flags if gain switch has occurred
  if (((EcalDataFrame)(*itdg)).hasSwitchToGain6())
    uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kHasSwitchToGain6);
  if (((EcalDataFrame)(*itdg)).hasSwitchToGain1())
    uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kHasSwitchToGain1);
 
  // put the recHit in the collection
  if (detid.subdetId() == EcalEndcap) {
    result.push_back(uncalibRecHit);
  } else {
    result.push_back(uncalibRecHit);
  }
 
  return true;
}

References CustomPhysics_cfi::amplitude, EcalUncalibratedRecHit::amplitude(), amplitudeThreshEB_, amplitudeThreshEE_, hltPixelTracks_cff::chi2, EcalUncalibRecHitRecChi2Algo< C >::chi2(), chi2ThreshEB_, chi2ThreshEE_, EcalUncalibRecHitRatioMethodAlgo< C >::computeAmplitude(), EcalUncalibRecHitRatioMethodAlgo< C >::computeTime(), EBamplitudeFitParameters_, EBchi2Parameters_, EBtimeConstantTerm_, EcalTimeBiasCorrections::EBTimeCorrAmplitudeBins, EcalTimeBiasCorrections::EBTimeCorrShiftBins, EBtimeFitLimits_, EBtimeFitParameters_, EBtimeNconst_, EcalEndcap, EEamplitudeFitParameters_, EEchi2Parameters_, EEtimeConstantTerm_, EcalTimeBiasCorrections::EETimeCorrAmplitudeBins, EcalTimeBiasCorrections::EETimeCorrShiftBins, EEtimeFitLimits_, EEtimeFitParameters_, EEtimeNconst_, EcalUncalibRecHitRatioMethodAlgo< C >::fixMGPAslew(), EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), ecalLiteDTU::gainId(), gainRatios, gains_, EcalUncalibRecHitRatioMethodAlgo< C >::getCalculatedRecHit(), EcalTimeOffsetConstant::getEBValue(), EcalTimeOffsetConstant::getEEValue(), EcalTBWeights::getMap(), EcalWeightSet::getWeightsAfterGainSwitch(), EcalWeightSet::getWeightsBeforeGainSwitch(), grps_, ecalpyutils::hashedIndex(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EcalXtalGroupId::id(), EcalUncalibRecHitRatioMethodAlgo< C >::init(), itime_, EcalUncalibratedRecHit::jitter(), EcalUncalibratedRecHit::kHasSwitchToGain1, EcalUncalibratedRecHit::kHasSwitchToGain6, EcalUncalibratedRecHit::kOutOfTime, EcalUncalibratedRecHit::kPoorReco, kPoorRecoFlagEB_, kPoorRecoFlagEE_, EcalUncalibratedRecHit::kSaturated, EcalUncalibRecHitRecWeightsAlgo< C >::makeRecHit(), EcalDataFrame::MAXSAMPLES, offtime_, outOfTimeThreshG12mEB_, outOfTimeThreshG12mEE_, outOfTimeThreshG12pEB_, outOfTimeThreshG12pEE_, outOfTimeThreshG61mEB_, outOfTimeThreshG61mEE_, outOfTimeThreshG61pEB_, outOfTimeThreshG61pEE_, EcalCondDBWriter_cfi::pedestal, pedRMSVec, peds_, pedVec, funct::pow(), edm::ESHandle< T >::product(), ratioMethod_barrel_, ratioMethod_endcap_, mps_fire::result, simplePhotonAnalyzer_cfi::sample, sampleMaskHand_, EcalUncalibratedRecHit::setChi2(), EcalUncalibratedRecHit::setFlagBit(), EcalUncalibratedRecHit::setJitter(), EcalUncalibratedRecHit::setJitterError(), mathSSE::sqrt(), testbeamEBShape, testbeamEEShape, timeCorrBias_, timeCorrection(), weights, weightsMethod_barrel_, weightsMethod_endcap_, and wgts_.

set()

void EcalUncalibRecHitWorkerGlobal::set ( const edm::EventSetup &  es )

overridevirtual

Implements EcalUncalibRecHitWorkerBaseClass.

Definition at line 63 of file EcalUncalibRecHitWorkerGlobal.cc.

                                                               {
  // common setup
  gains_ = es.getHandle(tokenGains_);
  peds_ = es.getHandle(tokenPeds_);
 
  // for the weights method
  grps_ = es.getHandle(tokenGrps_);
  wgts_ = es.getHandle(tokenWgts_);
 
  // which of the samples need be used
  sampleMaskHand_ = es.getHandle(tokenSampleMask_);
 
  // for the ratio method
 
  itime_ = es.getHandle(tokenItime_);
  offtime_ = es.getHandle(tokenOfftime_);
 
  // for the time correction methods
  timeCorrBias_ = es.getHandle(tokenTimeCorrBias_);
 
  // for the DB Ecal Pulse Sim Shape
  testbeamEEShape.setEventSetup(es);
  testbeamEBShape.setEventSetup(es);
}

References gains_, edm::EventSetup::getHandle(), grps_, itime_, offtime_, peds_, sampleMaskHand_, EcalShapeBase::setEventSetup(), testbeamEBShape, testbeamEEShape, timeCorrBias_, tokenGains_, tokenGrps_, tokenItime_, tokenOfftime_, tokenPeds_, tokenSampleMask_, tokenTimeCorrBias_, tokenWgts_, and wgts_.

timeCorrection()

double EcalUncalibRecHitWorkerGlobal::timeCorrection ( float  ampli, const std::vector< float > &  amplitudeBins, const std::vector< float > &  shiftBins  )

protected

Amplitude-dependent time corrections; EE and EB have separate corrections: EXtimeCorrAmplitudes (ADC) and EXtimeCorrShifts (ns) need to have the same number of elements Bins must be ordered in amplitude. First-last bins take care of under-overflows.

The algorithm is the same for EE and EB, only the correction vectors are different.

Returns

Jitter (in clock cycles) which will be added to UncalibRechit.setJitter(), 0 if no correction is applied.

Definition at line 114 of file EcalUncalibRecHitWorkerGlobal.cc.

                                                                                        {
  // computed initially in ns. Than turned in the BX's, as
  // EcalUncalibratedRecHit need be.
  double theCorrection = 0;
 
  // sanity check for arrays
  if (amplitudeBins.empty()) {
    edm::LogError("EcalRecHitError") << "timeCorrAmplitudeBins is empty, forcing no time bias corrections.";
 
    return 0;
  }
 
  if (amplitudeBins.size() != shiftBins.size()) {
    edm::LogError("EcalRecHitError") << "Size of timeCorrAmplitudeBins different from "
                                        "timeCorrShiftBins. Forcing no time bias corrections. ";
 
    return 0;
  }
 
  int myBin = -1;
  for (int bin = 0; bin < (int)amplitudeBins.size(); bin++) {
    if (ampli > amplitudeBins.at(bin)) {
      myBin = bin;
    } else {
      break;
    }
  }
 
  if (myBin == -1) {
    theCorrection = shiftBins.at(0);
  } else if (myBin == ((int)(amplitudeBins.size() - 1))) {
    theCorrection = shiftBins.at(myBin);
  } else if (-1 < myBin && myBin < ((int)amplitudeBins.size() - 1)) {
    // interpolate linearly between two assingned points
    theCorrection = (shiftBins.at(myBin + 1) - shiftBins.at(myBin));
    theCorrection *=
        (((double)ampli) - amplitudeBins.at(myBin)) / (amplitudeBins.at(myBin + 1) - amplitudeBins.at(myBin));
    theCorrection += shiftBins.at(myBin);
  } else {
    edm::LogError("EcalRecHitError") << "Assigning time correction impossible. Setting it to 0 ";
    theCorrection = 0.;
  }
 
  // convert ns into clocks
  return theCorrection / 25.;
}

References newFWLiteAna::bin, and createfilelist::int.

Referenced by run().

Member Data Documentation

amplitudeThreshEB_

double EcalUncalibRecHitWorkerGlobal::amplitudeThreshEB_

protected

Definition at line 111 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

amplitudeThreshEE_

double EcalUncalibRecHitWorkerGlobal::amplitudeThreshEE_

protected

Definition at line 112 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

chi2mat

const EcalWeightSet::EcalChi2WeightMatrix* EcalUncalibRecHitWorkerGlobal::chi2mat[2]

protected

Definition at line 78 of file EcalUncalibRecHitWorkerGlobal.h.

chi2ThreshEB_

double EcalUncalibRecHitWorkerGlobal::chi2ThreshEB_

protected

Definition at line 128 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

chi2ThreshEE_

double EcalUncalibRecHitWorkerGlobal::chi2ThreshEE_

protected

Definition at line 129 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EBamplitudeFitParameters_

std::vector<double> EcalUncalibRecHitWorkerGlobal::EBamplitudeFitParameters_

protected

Definition at line 91 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EBchi2Parameters_

std::vector<double> EcalUncalibRecHitWorkerGlobal::EBchi2Parameters_

protected

Definition at line 130 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

ebPulseShape_

std::vector<double> EcalUncalibRecHitWorkerGlobal::ebPulseShape_

protected

Definition at line 122 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal().

ebSpikeThresh_

double EcalUncalibRecHitWorkerGlobal::ebSpikeThresh_

protected

Definition at line 113 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal().

EBtimeConstantTerm_

double EcalUncalibRecHitWorkerGlobal::EBtimeConstantTerm_

protected

Definition at line 99 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EBtimeFitLimits_

std::pair<double, double> EcalUncalibRecHitWorkerGlobal::EBtimeFitLimits_

protected

Definition at line 93 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EBtimeFitParameters_

std::vector<double> EcalUncalibRecHitWorkerGlobal::EBtimeFitParameters_

protected

Definition at line 89 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EBtimeNconst_

double EcalUncalibRecHitWorkerGlobal::EBtimeNconst_

protected

Definition at line 100 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EEamplitudeFitParameters_

std::vector<double> EcalUncalibRecHitWorkerGlobal::EEamplitudeFitParameters_

protected

Definition at line 92 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EEchi2Parameters_

std::vector<double> EcalUncalibRecHitWorkerGlobal::EEchi2Parameters_

protected

Definition at line 131 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

eePulseShape_

std::vector<double> EcalUncalibRecHitWorkerGlobal::eePulseShape_

protected

Definition at line 123 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal().

EEtimeConstantTerm_

double EcalUncalibRecHitWorkerGlobal::EEtimeConstantTerm_

protected

Definition at line 101 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EEtimeFitLimits_

std::pair<double, double> EcalUncalibRecHitWorkerGlobal::EEtimeFitLimits_

protected

Definition at line 94 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EEtimeFitParameters_

std::vector<double> EcalUncalibRecHitWorkerGlobal::EEtimeFitParameters_

protected

Definition at line 90 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

EEtimeNconst_

double EcalUncalibRecHitWorkerGlobal::EEtimeNconst_

protected

Definition at line 102 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

gainRatios

double EcalUncalibRecHitWorkerGlobal::gainRatios[3]

protected

Definition at line 60 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

gains_

edm::ESHandle<EcalGainRatios> EcalUncalibRecHitWorkerGlobal::gains_

protected

Definition at line 65 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

grps_

edm::ESHandle<EcalWeightXtalGroups> EcalUncalibRecHitWorkerGlobal::grps_

protected

Definition at line 75 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

itime_

edm::ESHandle<EcalTimeCalibConstants> EcalUncalibRecHitWorkerGlobal::itime_

protected

Definition at line 120 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

kPoorRecoFlagEB_

bool EcalUncalibRecHitWorkerGlobal::kPoorRecoFlagEB_

protected

Definition at line 126 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

kPoorRecoFlagEE_

bool EcalUncalibRecHitWorkerGlobal::kPoorRecoFlagEE_

protected

Definition at line 127 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

offtime_

edm::ESHandle<EcalTimeOffsetConstant> EcalUncalibRecHitWorkerGlobal::offtime_

protected

Definition at line 121 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

outOfTimeThreshG12mEB_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12mEB_

protected

Definition at line 104 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG12mEE_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12mEE_

protected

Definition at line 108 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG12pEB_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12pEB_

protected

Definition at line 103 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG12pEE_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG12pEE_

protected

Definition at line 107 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG61mEB_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61mEB_

protected

Definition at line 106 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG61mEE_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61mEE_

protected

Definition at line 110 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG61pEB_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61pEB_

protected

Definition at line 105 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

outOfTimeThreshG61pEE_

double EcalUncalibRecHitWorkerGlobal::outOfTimeThreshG61pEE_

protected

Definition at line 109 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by EcalUncalibRecHitWorkerGlobal(), and run().

pedRMSVec

double EcalUncalibRecHitWorkerGlobal::pedRMSVec[3]

protected

Definition at line 59 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

peds_

edm::ESHandle<EcalPedestals> EcalUncalibRecHitWorkerGlobal::peds_

protected

Definition at line 64 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

pedVec

double EcalUncalibRecHitWorkerGlobal::pedVec[3]

protected

Definition at line 58 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

ratioMethod_barrel_

EcalUncalibRecHitRatioMethodAlgo<EBDataFrame> EcalUncalibRecHitWorkerGlobal::ratioMethod_barrel_

protected

Definition at line 96 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

ratioMethod_endcap_

EcalUncalibRecHitRatioMethodAlgo<EEDataFrame> EcalUncalibRecHitWorkerGlobal::ratioMethod_endcap_

protected

Definition at line 97 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

sampleMaskHand_

edm::ESHandle<EcalSampleMask> EcalUncalibRecHitWorkerGlobal::sampleMaskHand_

protected

Definition at line 86 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

testbeamEBShape

EBShape EcalUncalibRecHitWorkerGlobal::testbeamEBShape

protected

Definition at line 82 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

testbeamEEShape

EEShape EcalUncalibRecHitWorkerGlobal::testbeamEEShape

protected

Definition at line 81 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

timeCorrBias_

edm::ESHandle<EcalTimeBiasCorrections> EcalUncalibRecHitWorkerGlobal::timeCorrBias_

protected

Definition at line 116 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().

tokenGains_

edm::ESGetToken<EcalGainRatios, EcalGainRatiosRcd> EcalUncalibRecHitWorkerGlobal::tokenGains_

protected

Definition at line 63 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenGrps_

edm::ESGetToken<EcalWeightXtalGroups, EcalWeightXtalGroupsRcd> EcalUncalibRecHitWorkerGlobal::tokenGrps_

protected

Definition at line 73 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenItime_

edm::ESGetToken<EcalTimeCalibConstants, EcalTimeCalibConstantsRcd> EcalUncalibRecHitWorkerGlobal::tokenItime_

protected

Definition at line 118 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenOfftime_

edm::ESGetToken<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd> EcalUncalibRecHitWorkerGlobal::tokenOfftime_

protected

Definition at line 119 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenPeds_

edm::ESGetToken<EcalPedestals, EcalPedestalsRcd> EcalUncalibRecHitWorkerGlobal::tokenPeds_

protected

Definition at line 62 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenSampleMask_

edm::ESGetToken<EcalSampleMask, EcalSampleMaskRcd> EcalUncalibRecHitWorkerGlobal::tokenSampleMask_

protected

Definition at line 85 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenTimeCorrBias_

edm::ESGetToken<EcalTimeBiasCorrections, EcalTimeBiasCorrectionsRcd> EcalUncalibRecHitWorkerGlobal::tokenTimeCorrBias_

protected

Definition at line 115 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

tokenWgts_

edm::ESGetToken<EcalTBWeights, EcalTBWeightsRcd> EcalUncalibRecHitWorkerGlobal::tokenWgts_

protected

Definition at line 74 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by set().

weights

const EcalWeightSet::EcalWeightMatrix* EcalUncalibRecHitWorkerGlobal::weights[2]

protected

Definition at line 77 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

weightsMethod_barrel_

EcalUncalibRecHitRecWeightsAlgo<EBDataFrame> EcalUncalibRecHitWorkerGlobal::weightsMethod_barrel_

protected

Definition at line 79 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

weightsMethod_endcap_

EcalUncalibRecHitRecWeightsAlgo<EEDataFrame> EcalUncalibRecHitWorkerGlobal::weightsMethod_endcap_

protected

Definition at line 80 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run().

wgts_

edm::ESHandle<EcalTBWeights> EcalUncalibRecHitWorkerGlobal::wgts_

protected

Definition at line 76 of file EcalUncalibRecHitWorkerGlobal.h.

Referenced by run(), and set().