CMS 3D CMS Logo
EcalUncalibRecHitWorkerMultiFit.cc
Go to the documentation of this file.
1 #include "RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h"
2 
3 #include "FWCore/Framework/interface/EventSetup.h"
4 #include "FWCore/Framework/interface/Event.h"
5 #include "FWCore/Framework/interface/Run.h"
6 #include "FWCore/MessageLogger/interface/MessageLogger.h"
7 #include "FWCore/ParameterSet/interface/ParameterSet.h"
8 
9 #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
10 #include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
11 #include "CondFormats/DataRecord/interface/EcalWeightXtalGroupsRcd.h"
12 #include "CondFormats/DataRecord/interface/EcalTBWeightsRcd.h"
13 #include "CondFormats/DataRecord/interface/EcalSampleMaskRcd.h"
14 #include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
15 #include "CondFormats/DataRecord/interface/EcalTimeOffsetConstantRcd.h"
16 #include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h"
17 #include "CondFormats/DataRecord/interface/EcalSamplesCorrelationRcd.h"
18 #include "CondFormats/DataRecord/interface/EcalPulseShapesRcd.h"
19 #include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h"
20 
21 #include <FWCore/ParameterSet/interface/ConfigurationDescriptions.h>
22 #include <FWCore/ParameterSet/interface/ParameterSetDescription.h>
23 #include <FWCore/ParameterSet/interface/EmptyGroupDescription.h>
24 
25 EcalUncalibRecHitWorkerMultiFit::EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet& ps, edm::ConsumesCollector& c)
26  : EcalUncalibRecHitWorkerBaseClass(ps, c) {
27  // get the BX for the pulses to be activated
28  std::vector<int32_t> activeBXs = ps.getParameter<std::vector<int32_t>>("activeBXs");
29  activeBX.resize(activeBXs.size());
30  for (unsigned int ibx = 0; ibx < activeBXs.size(); ++ibx) {
31  activeBX.coeffRef(ibx) = activeBXs[ibx];
32  }
33 
34  // uncertainty calculation (CPU intensive)
35  ampErrorCalculation_ = ps.getParameter<bool>("ampErrorCalculation");
36  useLumiInfoRunHeader_ = ps.getParameter<bool>("useLumiInfoRunHeader");
37 
38  if (useLumiInfoRunHeader_) {
39  bunchSpacing_ = c.consumes<unsigned int>(edm::InputTag("bunchSpacingProducer"));
40  bunchSpacingManual_ = 0;
41  } else {
42  bunchSpacingManual_ = ps.getParameter<int>("bunchSpacing");
43  }
44 
45  doPrefitEB_ = ps.getParameter<bool>("doPrefitEB");
46  doPrefitEE_ = ps.getParameter<bool>("doPrefitEE");
47 
48  prefitMaxChiSqEB_ = ps.getParameter<double>("prefitMaxChiSqEB");
49  prefitMaxChiSqEE_ = ps.getParameter<double>("prefitMaxChiSqEE");
50 
51  dynamicPedestalsEB_ = ps.getParameter<bool>("dynamicPedestalsEB");
52  dynamicPedestalsEE_ = ps.getParameter<bool>("dynamicPedestalsEE");
53  mitigateBadSamplesEB_ = ps.getParameter<bool>("mitigateBadSamplesEB");
54  mitigateBadSamplesEE_ = ps.getParameter<bool>("mitigateBadSamplesEE");
55  gainSwitchUseMaxSampleEB_ = ps.getParameter<bool>("gainSwitchUseMaxSampleEB");
56  gainSwitchUseMaxSampleEE_ = ps.getParameter<bool>("gainSwitchUseMaxSampleEE");
57  selectiveBadSampleCriteriaEB_ = ps.getParameter<bool>("selectiveBadSampleCriteriaEB");
58  selectiveBadSampleCriteriaEE_ = ps.getParameter<bool>("selectiveBadSampleCriteriaEE");
59  addPedestalUncertaintyEB_ = ps.getParameter<double>("addPedestalUncertaintyEB");
60  addPedestalUncertaintyEE_ = ps.getParameter<double>("addPedestalUncertaintyEE");
61  simplifiedNoiseModelForGainSwitch_ = ps.getParameter<bool>("simplifiedNoiseModelForGainSwitch");
62 
63  // algorithm to be used for timing
64  auto const& timeAlgoName = ps.getParameter<std::string>("timealgo");
65  if (timeAlgoName == "RatioMethod")
66  timealgo_ = ratioMethod;
67  else if (timeAlgoName == "WeightsMethod")
68  timealgo_ = weightsMethod;
69  else if (timeAlgoName != "None")
70  edm::LogError("EcalUncalibRecHitError") << "No time estimation algorithm defined";
71 
72  // ratio method parameters
73  EBtimeFitParameters_ = ps.getParameter<std::vector<double>>("EBtimeFitParameters");
74  EEtimeFitParameters_ = ps.getParameter<std::vector<double>>("EEtimeFitParameters");
75  EBamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EBamplitudeFitParameters");
76  EEamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EEamplitudeFitParameters");
77  EBtimeFitLimits_.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
78  EBtimeFitLimits_.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
79  EEtimeFitLimits_.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
80  EEtimeFitLimits_.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
81  EBtimeConstantTerm_ = ps.getParameter<double>("EBtimeConstantTerm");
82  EEtimeConstantTerm_ = ps.getParameter<double>("EEtimeConstantTerm");
83  EBtimeNconst_ = ps.getParameter<double>("EBtimeNconst");
84  EEtimeNconst_ = ps.getParameter<double>("EEtimeNconst");
85  outOfTimeThreshG12pEB_ = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
86  outOfTimeThreshG12mEB_ = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
87  outOfTimeThreshG61pEB_ = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
88  outOfTimeThreshG61mEB_ = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
89  outOfTimeThreshG12pEE_ = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
90  outOfTimeThreshG12mEE_ = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
91  outOfTimeThreshG61pEE_ = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
92  outOfTimeThreshG61mEE_ = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
93  amplitudeThreshEB_ = ps.getParameter<double>("amplitudeThresholdEB");
94  amplitudeThreshEE_ = ps.getParameter<double>("amplitudeThresholdEE");
95 
96  // spike threshold
97  ebSpikeThresh_ = ps.getParameter<double>("ebSpikeThreshold");
98 
99  ebPulseShape_ = ps.getParameter<std::vector<double>>("ebPulseShape");
100  eePulseShape_ = ps.getParameter<std::vector<double>>("eePulseShape");
101 
102  // chi2 parameters for flags determination
103  kPoorRecoFlagEB_ = ps.getParameter<bool>("kPoorRecoFlagEB");
104  kPoorRecoFlagEE_ = ps.getParameter<bool>("kPoorRecoFlagEE");
105  chi2ThreshEB_ = ps.getParameter<double>("chi2ThreshEB_");
106  chi2ThreshEE_ = ps.getParameter<double>("chi2ThreshEE_");
107 }
108 
109 void EcalUncalibRecHitWorkerMultiFit::set(const edm::EventSetup& es) {
110  // common setup
111  es.get<EcalGainRatiosRcd>().get(gains);
112  es.get<EcalPedestalsRcd>().get(peds);
113 
114  // for the multifit method
115  if (!ampErrorCalculation_)
116  multiFitMethod_.disableErrorCalculation();
117  es.get<EcalSamplesCorrelationRcd>().get(noisecovariances);
118  es.get<EcalPulseShapesRcd>().get(pulseshapes);
119  es.get<EcalPulseCovariancesRcd>().get(pulsecovariances);
120 
121  // weights parameters for the time
122  es.get<EcalWeightXtalGroupsRcd>().get(grps);
123  es.get<EcalTBWeightsRcd>().get(wgts);
124 
125  // which of the samples need be used
126  es.get<EcalSampleMaskRcd>().get(sampleMaskHand_);
127 
128  // for the ratio method
129  es.get<EcalTimeCalibConstantsRcd>().get(itime);
130  es.get<EcalTimeOffsetConstantRcd>().get(offtime);
131 
132  // for the time correction methods
133  es.get<EcalTimeBiasCorrectionsRcd>().get(timeCorrBias_);
134 
135  int nnoise = SampleVector::RowsAtCompileTime;
136  SampleMatrix& noisecorEBg12 = noisecors_[1][0];
137  SampleMatrix& noisecorEBg6 = noisecors_[1][1];
138  SampleMatrix& noisecorEBg1 = noisecors_[1][2];
139  SampleMatrix& noisecorEEg12 = noisecors_[0][0];
140  SampleMatrix& noisecorEEg6 = noisecors_[0][1];
141  SampleMatrix& noisecorEEg1 = noisecors_[0][2];
142 
143  for (int i = 0; i < nnoise; ++i) {
144  for (int j = 0; j < nnoise; ++j) {
145  int vidx = std::abs(j - i);
146  noisecorEBg12(i, j) = noisecovariances->EBG12SamplesCorrelation[vidx];
147  noisecorEEg12(i, j) = noisecovariances->EEG12SamplesCorrelation[vidx];
148  noisecorEBg6(i, j) = noisecovariances->EBG6SamplesCorrelation[vidx];
149  noisecorEEg6(i, j) = noisecovariances->EEG6SamplesCorrelation[vidx];
150  noisecorEBg1(i, j) = noisecovariances->EBG1SamplesCorrelation[vidx];
151  noisecorEEg1(i, j) = noisecovariances->EEG1SamplesCorrelation[vidx];
152  }
153  }
154 }
155 
156 void EcalUncalibRecHitWorkerMultiFit::set(const edm::Event& evt) {
157  unsigned int bunchspacing = 450;
158 
159  if (useLumiInfoRunHeader_) {
160  edm::Handle<unsigned int> bunchSpacingH;
161  evt.getByToken(bunchSpacing_, bunchSpacingH);
162  bunchspacing = *bunchSpacingH;
163  } else {
164  bunchspacing = bunchSpacingManual_;
165  }
166 
167  if (useLumiInfoRunHeader_ || bunchSpacingManual_ > 0) {
168  if (bunchspacing == 25) {
169  activeBX.resize(10);
170  activeBX << -5, -4, -3, -2, -1, 0, 1, 2, 3, 4;
171  } else {
172  //50ns configuration otherwise (also for no pileup)
173  activeBX.resize(5);
174  activeBX << -4, -2, 0, 2, 4;
175  }
176  }
177 }
178 
188 double EcalUncalibRecHitWorkerMultiFit::timeCorrection(float ampli,
189  const std::vector<float>& amplitudeBins,
190  const std::vector<float>& shiftBins) {
191  // computed initially in ns. Than turned in the BX's, as
192  // EcalUncalibratedRecHit need be.
193  double theCorrection = 0;
194 
195  // sanity check for arrays
196  if (amplitudeBins.empty()) {
197  edm::LogError("EcalRecHitError") << "timeCorrAmplitudeBins is empty, forcing no time bias corrections.";
198 
199  return 0;
200  }
201 
202  if (amplitudeBins.size() != shiftBins.size()) {
203  edm::LogError("EcalRecHitError") << "Size of timeCorrAmplitudeBins different from "
204  "timeCorrShiftBins. Forcing no time bias corrections. ";
205 
206  return 0;
207  }
208 
209  // FIXME? what about a binary search?
210  int myBin = -1;
211  for (int bin = 0; bin < (int)amplitudeBins.size(); bin++) {
212  if (ampli > amplitudeBins[bin]) {
213  myBin = bin;
214  } else {
215  break;
216  }
217  }
218 
219  if (myBin == -1) {
220  theCorrection = shiftBins[0];
221  } else if (myBin == ((int)(amplitudeBins.size() - 1))) {
222  theCorrection = shiftBins[myBin];
223  } else {
224  // interpolate linearly between two assingned points
225  theCorrection = (shiftBins[myBin + 1] - shiftBins[myBin]);
226  theCorrection *= (((double)ampli) - amplitudeBins[myBin]) / (amplitudeBins[myBin + 1] - amplitudeBins[myBin]);
227  theCorrection += shiftBins[myBin];
228  }
229 
230  // convert ns into clocks
231  constexpr double inv25 = 1. / 25.;
232  return theCorrection * inv25;
233 }
234 
235 void EcalUncalibRecHitWorkerMultiFit::run(const edm::Event& evt,
236  const EcalDigiCollection& digis,
237  EcalUncalibratedRecHitCollection& result) {
238  if (digis.empty())
239  return;
240 
241  // assume all digis come from the same subdetector (either barrel or endcap)
242  DetId detid(digis.begin()->id());
243  bool barrel = (detid.subdetId() == EcalBarrel);
244 
245  multiFitMethod_.setSimplifiedNoiseModelForGainSwitch(simplifiedNoiseModelForGainSwitch_);
246  if (barrel) {
247  multiFitMethod_.setDoPrefit(doPrefitEB_);
248  multiFitMethod_.setPrefitMaxChiSq(prefitMaxChiSqEB_);
249  multiFitMethod_.setDynamicPedestals(dynamicPedestalsEB_);
250  multiFitMethod_.setMitigateBadSamples(mitigateBadSamplesEB_);
251  multiFitMethod_.setGainSwitchUseMaxSample(gainSwitchUseMaxSampleEB_);
252  multiFitMethod_.setSelectiveBadSampleCriteria(selectiveBadSampleCriteriaEB_);
253  multiFitMethod_.setAddPedestalUncertainty(addPedestalUncertaintyEB_);
254  } else {
255  multiFitMethod_.setDoPrefit(doPrefitEE_);
256  multiFitMethod_.setPrefitMaxChiSq(prefitMaxChiSqEE_);
257  multiFitMethod_.setDynamicPedestals(dynamicPedestalsEE_);
258  multiFitMethod_.setMitigateBadSamples(mitigateBadSamplesEE_);
259  multiFitMethod_.setGainSwitchUseMaxSample(gainSwitchUseMaxSampleEE_);
260  multiFitMethod_.setSelectiveBadSampleCriteria(selectiveBadSampleCriteriaEE_);
261  multiFitMethod_.setAddPedestalUncertainty(addPedestalUncertaintyEE_);
262  }
263 
264  FullSampleVector fullpulse(FullSampleVector::Zero());
265  FullSampleMatrix fullpulsecov(FullSampleMatrix::Zero());
266 
267  result.reserve(result.size() + digis.size());
268  for (auto itdg = digis.begin(); itdg != digis.end(); ++itdg) {
269  DetId detid(itdg->id());
270 
271  const EcalSampleMask* sampleMask_ = sampleMaskHand_.product();
272 
273  // intelligence for recHit computation
274  float offsetTime = 0;
275 
276  const EcalPedestals::Item* aped = nullptr;
277  const EcalMGPAGainRatio* aGain = nullptr;
278  const EcalXtalGroupId* gid = nullptr;
279  const EcalPulseShapes::Item* aPulse = nullptr;
280  const EcalPulseCovariances::Item* aPulseCov = nullptr;
281 
282  if (barrel) {
283  unsigned int hashedIndex = EBDetId(detid).hashedIndex();
284  aped = &peds->barrel(hashedIndex);
285  aGain = &gains->barrel(hashedIndex);
286  gid = &grps->barrel(hashedIndex);
287  aPulse = &pulseshapes->barrel(hashedIndex);
288  aPulseCov = &pulsecovariances->barrel(hashedIndex);
289  offsetTime = offtime->getEBValue();
290  } else {
291  unsigned int hashedIndex = EEDetId(detid).hashedIndex();
292  aped = &peds->endcap(hashedIndex);
293  aGain = &gains->endcap(hashedIndex);
294  gid = &grps->endcap(hashedIndex);
295  aPulse = &pulseshapes->endcap(hashedIndex);
296  aPulseCov = &pulsecovariances->endcap(hashedIndex);
297  offsetTime = offtime->getEEValue();
298  }
299 
300  double pedVec[3] = {aped->mean_x12, aped->mean_x6, aped->mean_x1};
301  double pedRMSVec[3] = {aped->rms_x12, aped->rms_x6, aped->rms_x1};
302  double gainRatios[3] = {1., aGain->gain12Over6(), aGain->gain6Over1() * aGain->gain12Over6()};
303 
304  for (int i = 0; i < EcalPulseShape::TEMPLATESAMPLES; ++i)
305  fullpulse(i + 7) = aPulse->pdfval[i];
306 
307  for (int i = 0; i < EcalPulseShape::TEMPLATESAMPLES; i++)
308  for (int j = 0; j < EcalPulseShape::TEMPLATESAMPLES; j++)
309  fullpulsecov(i + 7, j + 7) = aPulseCov->covval[i][j];
310 
311  // compute the right bin of the pulse shape using time calibration constants
312  EcalTimeCalibConstantMap::const_iterator it = itime->find(detid);
313  EcalTimeCalibConstant itimeconst = 0;
314  if (it != itime->end()) {
315  itimeconst = (*it);
316  } else {
317  edm::LogError("EcalRecHitError") << "No time intercalib const found for xtal " << detid.rawId()
318  << "! something wrong with EcalTimeCalibConstants in your DB? ";
319  }
320 
321  int lastSampleBeforeSaturation = -2;
322  for (unsigned int iSample = 0; iSample < EcalDataFrame::MAXSAMPLES; iSample++) {
323  if (((EcalDataFrame)(*itdg)).sample(iSample).gainId() == 0) {
324  lastSampleBeforeSaturation = iSample - 1;
325  break;
326  }
327  }
328 
329  // === amplitude computation ===
330 
331  if (lastSampleBeforeSaturation == 4) { // saturation on the expected max sample
332  result.emplace_back((*itdg).id(), 4095 * 12, 0, 0, 0);
333  auto& uncalibRecHit = result.back();
334  uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kSaturated);
335  // do not propagate the default chi2 = -1 value to the calib rechit (mapped to 64), set it to 0 when saturation
336  uncalibRecHit.setChi2(0);
337  } else if (lastSampleBeforeSaturation >=
338  -1) { // saturation on other samples: cannot extrapolate from the fourth one
339  int gainId = ((EcalDataFrame)(*itdg)).sample(5).gainId();
340  if (gainId == 0)
341  gainId = 3;
342  auto pedestal = pedVec[gainId - 1];
343  auto gainratio = gainRatios[gainId - 1];
344  double amplitude = ((double)(((EcalDataFrame)(*itdg)).sample(5).adc()) - pedestal) * gainratio;
345  result.emplace_back((*itdg).id(), amplitude, 0, 0, 0);
346  auto& uncalibRecHit = result.back();
347  uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kSaturated);
348  // do not propagate the default chi2 = -1 value to the calib rechit (mapped to 64), set it to 0 when saturation
349  uncalibRecHit.setChi2(0);
350  } else {
351  // multifit
352  const SampleMatrixGainArray& noisecors = noisecor(barrel);
353 
354  result.push_back(multiFitMethod_.makeRecHit(*itdg, aped, aGain, noisecors, fullpulse, fullpulsecov, activeBX));
355  auto& uncalibRecHit = result.back();
356 
357  // === time computation ===
358  if (timealgo_ == ratioMethod) {
359  // ratio method
360  constexpr float clockToNsConstant = 25.;
361  constexpr float invClockToNs = 1. / clockToNsConstant;
362  if (not barrel) {
363  ratioMethod_endcap_.init(*itdg, *sampleMask_, pedVec, pedRMSVec, gainRatios);
364  ratioMethod_endcap_.computeTime(EEtimeFitParameters_, EEtimeFitLimits_, EEamplitudeFitParameters_);
365  ratioMethod_endcap_.computeAmplitude(EEamplitudeFitParameters_);
366  EcalUncalibRecHitRatioMethodAlgo<EEDataFrame>::CalculatedRecHit crh =
367  ratioMethod_endcap_.getCalculatedRecHit();
368  double theTimeCorrectionEE = timeCorrection(
369  uncalibRecHit.amplitude(), timeCorrBias_->EETimeCorrAmplitudeBins, timeCorrBias_->EETimeCorrShiftBins);
370 
371  uncalibRecHit.setJitter(crh.timeMax - 5 + theTimeCorrectionEE);
372  uncalibRecHit.setJitterError(
373  std::sqrt(std::pow(crh.timeError, 2) + std::pow(EEtimeConstantTerm_ * invClockToNs, 2)));
374 
375  // consider flagging as kOutOfTime only if above noise
376  if (uncalibRecHit.amplitude() > pedRMSVec[0] * amplitudeThreshEE_) {
377  float outOfTimeThreshP = outOfTimeThreshG12pEE_;
378  float outOfTimeThreshM = outOfTimeThreshG12mEE_;
379  // determine if gain has switched away from gainId==1 (x12 gain)
380  // and determine cuts (number of 'sigmas') to ose for kOutOfTime
381  // >3k ADC is necessasry condition for gain switch to occur
382  if (uncalibRecHit.amplitude() > 3000.) {
383  for (int iSample = 0; iSample < EEDataFrame::MAXSAMPLES; iSample++) {
384  int GainId = ((EcalDataFrame)(*itdg)).sample(iSample).gainId();
385  if (GainId != 1) {
386  outOfTimeThreshP = outOfTimeThreshG61pEE_;
387  outOfTimeThreshM = outOfTimeThreshG61mEE_;
388  break;
389  }
390  }
391  }
392  float correctedTime = (crh.timeMax - 5) * clockToNsConstant + itimeconst + offsetTime;
393  float cterm = EEtimeConstantTerm_;
394  float sigmaped = pedRMSVec[0]; // approx for lower gains
395  float nterm = EEtimeNconst_ * sigmaped / uncalibRecHit.amplitude();
396  float sigmat = std::sqrt(nterm * nterm + cterm * cterm);
397  if ((correctedTime > sigmat * outOfTimeThreshP) || (correctedTime < -sigmat * outOfTimeThreshM)) {
398  uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kOutOfTime);
399  }
400  }
401 
402  } else {
403  ratioMethod_barrel_.init(*itdg, *sampleMask_, pedVec, pedRMSVec, gainRatios);
404  ratioMethod_barrel_.fixMGPAslew(*itdg);
405  ratioMethod_barrel_.computeTime(EBtimeFitParameters_, EBtimeFitLimits_, EBamplitudeFitParameters_);
406  ratioMethod_barrel_.computeAmplitude(EBamplitudeFitParameters_);
407  EcalUncalibRecHitRatioMethodAlgo<EBDataFrame>::CalculatedRecHit crh =
408  ratioMethod_barrel_.getCalculatedRecHit();
409 
410  double theTimeCorrectionEB = timeCorrection(
411  uncalibRecHit.amplitude(), timeCorrBias_->EBTimeCorrAmplitudeBins, timeCorrBias_->EBTimeCorrShiftBins);
412 
413  uncalibRecHit.setJitter(crh.timeMax - 5 + theTimeCorrectionEB);
414  uncalibRecHit.setJitterError(std::hypot(crh.timeError, EBtimeConstantTerm_ / clockToNsConstant));
415 
416  // consider flagging as kOutOfTime only if above noise
417  if (uncalibRecHit.amplitude() > pedRMSVec[0] * amplitudeThreshEB_) {
418  float outOfTimeThreshP = outOfTimeThreshG12pEB_;
419  float outOfTimeThreshM = outOfTimeThreshG12mEB_;
420  // determine if gain has switched away from gainId==1 (x12 gain)
421  // and determine cuts (number of 'sigmas') to ose for kOutOfTime
422  // >3k ADC is necessasry condition for gain switch to occur
423  if (uncalibRecHit.amplitude() > 3000.) {
424  for (int iSample = 0; iSample < EBDataFrame::MAXSAMPLES; iSample++) {
425  int GainId = ((EcalDataFrame)(*itdg)).sample(iSample).gainId();
426  if (GainId != 1) {
427  outOfTimeThreshP = outOfTimeThreshG61pEB_;
428  outOfTimeThreshM = outOfTimeThreshG61mEB_;
429  break;
430  }
431  }
432  }
433  float correctedTime = (crh.timeMax - 5) * clockToNsConstant + itimeconst + offsetTime;
434  float cterm = EBtimeConstantTerm_;
435  float sigmaped = pedRMSVec[0]; // approx for lower gains
436  float nterm = EBtimeNconst_ * sigmaped / uncalibRecHit.amplitude();
437  float sigmat = std::sqrt(nterm * nterm + cterm * cterm);
438  if ((correctedTime > sigmat * outOfTimeThreshP) || (correctedTime < -sigmat * outOfTimeThreshM)) {
439  uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kOutOfTime);
440  }
441  }
442  }
443  } else if (timealgo_ == weightsMethod) {
444  // weights method on the PU subtracted pulse shape
445  std::vector<double> amplitudes;
446  for (unsigned int ibx = 0; ibx < activeBX.size(); ++ibx)
447  amplitudes.push_back(uncalibRecHit.outOfTimeAmplitude(ibx));
448 
449  EcalTBWeights::EcalTDCId tdcid(1);
450  EcalTBWeights::EcalTBWeightMap const& wgtsMap = wgts->getMap();
451  EcalTBWeights::EcalTBWeightMap::const_iterator wit;
452  wit = wgtsMap.find(std::make_pair(*gid, tdcid));
453  if (wit == wgtsMap.end()) {
454  edm::LogError("EcalUncalibRecHitError")
455  << "No weights found for EcalGroupId: " << gid->id() << " and EcalTDCId: " << tdcid
456  << "\n skipping digi with id: " << detid.rawId();
457  result.pop_back();
458  continue;
459  }
460  const EcalWeightSet& wset = wit->second; // this is the EcalWeightSet
461 
462  const EcalWeightSet::EcalWeightMatrix& mat1 = wset.getWeightsBeforeGainSwitch();
463  const EcalWeightSet::EcalWeightMatrix& mat2 = wset.getWeightsAfterGainSwitch();
464 
465  weights[0] = &mat1;
466  weights[1] = &mat2;
467 
468  double timerh;
469  if (detid.subdetId() == EcalEndcap) {
470  timerh = weightsMethod_endcap_.time(*itdg, amplitudes, aped, aGain, fullpulse, weights);
471  } else {
472  timerh = weightsMethod_barrel_.time(*itdg, amplitudes, aped, aGain, fullpulse, weights);
473  }
474  uncalibRecHit.setJitter(timerh);
475  uncalibRecHit.setJitterError(0.); // not computed with weights
476  } else { // no time method;
477  uncalibRecHit.setJitter(0.);
478  uncalibRecHit.setJitterError(0.);
479  }
480  }
481 
482  // set flags if gain switch has occurred
483  auto& uncalibRecHit = result.back();
484  if (((EcalDataFrame)(*itdg)).hasSwitchToGain6())
485  uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kHasSwitchToGain6);
486  if (((EcalDataFrame)(*itdg)).hasSwitchToGain1())
487  uncalibRecHit.setFlagBit(EcalUncalibratedRecHit::kHasSwitchToGain1);
488  }
489 }
490 
491 edm::ParameterSetDescription EcalUncalibRecHitWorkerMultiFit::getAlgoDescription() {
492  edm::ParameterSetDescription psd0;
493  psd0.addNode((edm::ParameterDescription<std::vector<double>>("EBPulseShapeTemplate",
494  {1.13979e-02,
495  7.58151e-01,
496  1.00000e+00,
497  8.87744e-01,
498  6.73548e-01,
499  4.74332e-01,
500  3.19561e-01,
501  2.15144e-01,
502  1.47464e-01,
503  1.01087e-01,
504  6.93181e-02,
505  4.75044e-02},
506  true) and
507  edm::ParameterDescription<std::vector<double>>("EEPulseShapeTemplate",
508  {1.16442e-01,
509  7.56246e-01,
510  1.00000e+00,
511  8.97182e-01,
512  6.86831e-01,
513  4.91506e-01,
514  3.44111e-01,
515  2.45731e-01,
516  1.74115e-01,
517  1.23361e-01,
518  8.74288e-02,
519  6.19570e-02},
520  true)));
521 
522  psd0.addNode((edm::ParameterDescription<std::string>("EEdigiCollection", "", true) and
523  edm::ParameterDescription<std::string>("EBdigiCollection", "", true) and
524  edm::ParameterDescription<std::string>("ESdigiCollection", "", true) and
525  edm::ParameterDescription<bool>("UseLCcorrection", true, false) and
526  edm::ParameterDescription<std::vector<double>>(
527  "EBCorrNoiseMatrixG12",
528  {1.00000, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481},
529  true) and
530  edm::ParameterDescription<std::vector<double>>(
531  "EECorrNoiseMatrixG12",
532  {1.00000, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098},
533  true) and
534  edm::ParameterDescription<std::vector<double>>(
535  "EBCorrNoiseMatrixG06",
536  {1.00000, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055},
537  true) and
538  edm::ParameterDescription<std::vector<double>>(
539  "EECorrNoiseMatrixG06",
540  {1.00000, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443},
541  true) and
542  edm::ParameterDescription<std::vector<double>>(
543  "EBCorrNoiseMatrixG01",
544  {1.00000, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409},
545  true) and
546  edm::ParameterDescription<std::vector<double>>(
547  "EECorrNoiseMatrixG01",
548  {1.00000, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265},
549  true) and
550  edm::ParameterDescription<bool>("EcalPreMixStage1", false, true) and
551  edm::ParameterDescription<bool>("EcalPreMixStage2", false, true)));
552 
553  psd0.addOptionalNode(
554  (edm::ParameterDescription<std::vector<double>>(
555  "EBPulseShapeCovariance",
556  {3.001e-06, 1.233e-05, 0.000e+00, -4.416e-06, -4.571e-06, -3.614e-06, -2.636e-06, -1.286e-06, -8.410e-07,
557  -5.296e-07, 0.000e+00, 0.000e+00, 1.233e-05, 6.154e-05, 0.000e+00, -2.200e-05, -2.309e-05, -1.838e-05,
558  -1.373e-05, -7.334e-06, -5.088e-06, -3.745e-06, -2.428e-06, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
559  0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
560  -4.416e-06, -2.200e-05, 0.000e+00, 8.319e-06, 8.545e-06, 6.792e-06, 5.059e-06, 2.678e-06, 1.816e-06,
561  1.223e-06, 8.245e-07, 5.589e-07, -4.571e-06, -2.309e-05, 0.000e+00, 8.545e-06, 9.182e-06, 7.219e-06,
562  5.388e-06, 2.853e-06, 1.944e-06, 1.324e-06, 9.083e-07, 6.335e-07, -3.614e-06, -1.838e-05, 0.000e+00,
563  6.792e-06, 7.219e-06, 6.016e-06, 4.437e-06, 2.385e-06, 1.636e-06, 1.118e-06, 7.754e-07, 5.556e-07,
564  -2.636e-06, -1.373e-05, 0.000e+00, 5.059e-06, 5.388e-06, 4.437e-06, 3.602e-06, 1.917e-06, 1.322e-06,
565  9.079e-07, 6.529e-07, 4.752e-07, -1.286e-06, -7.334e-06, 0.000e+00, 2.678e-06, 2.853e-06, 2.385e-06,
566  1.917e-06, 1.375e-06, 9.100e-07, 6.455e-07, 4.693e-07, 3.657e-07, -8.410e-07, -5.088e-06, 0.000e+00,
567  1.816e-06, 1.944e-06, 1.636e-06, 1.322e-06, 9.100e-07, 9.115e-07, 6.062e-07, 4.436e-07, 3.422e-07,
568  -5.296e-07, -3.745e-06, 0.000e+00, 1.223e-06, 1.324e-06, 1.118e-06, 9.079e-07, 6.455e-07, 6.062e-07,
569  7.217e-07, 4.862e-07, 3.768e-07, 0.000e+00, -2.428e-06, 0.000e+00, 8.245e-07, 9.083e-07, 7.754e-07,
570  6.529e-07, 4.693e-07, 4.436e-07, 4.862e-07, 6.509e-07, 4.418e-07, 0.000e+00, 0.000e+00, 0.000e+00,
571  5.589e-07, 6.335e-07, 5.556e-07, 4.752e-07, 3.657e-07, 3.422e-07, 3.768e-07, 4.418e-07, 6.142e-07},
572  true) and
573  edm::ParameterDescription<std::vector<double>>(
574  "EEPulseShapeCovariance",
575  {3.941e-05, 3.333e-05, 0.000e+00, -1.449e-05, -1.661e-05, -1.424e-05, -1.183e-05, -6.842e-06, -4.915e-06,
576  -3.411e-06, 0.000e+00, 0.000e+00, 3.333e-05, 2.862e-05, 0.000e+00, -1.244e-05, -1.431e-05, -1.233e-05,
577  -1.032e-05, -5.883e-06, -4.154e-06, -2.902e-06, -2.128e-06, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
578  0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
579  -1.449e-05, -1.244e-05, 0.000e+00, 5.840e-06, 6.649e-06, 5.720e-06, 4.812e-06, 2.708e-06, 1.869e-06,
580  1.330e-06, 9.186e-07, 6.446e-07, -1.661e-05, -1.431e-05, 0.000e+00, 6.649e-06, 7.966e-06, 6.898e-06,
581  5.794e-06, 3.157e-06, 2.184e-06, 1.567e-06, 1.084e-06, 7.575e-07, -1.424e-05, -1.233e-05, 0.000e+00,
582  5.720e-06, 6.898e-06, 6.341e-06, 5.347e-06, 2.859e-06, 1.991e-06, 1.431e-06, 9.839e-07, 6.886e-07,
583  -1.183e-05, -1.032e-05, 0.000e+00, 4.812e-06, 5.794e-06, 5.347e-06, 4.854e-06, 2.628e-06, 1.809e-06,
584  1.289e-06, 9.020e-07, 6.146e-07, -6.842e-06, -5.883e-06, 0.000e+00, 2.708e-06, 3.157e-06, 2.859e-06,
585  2.628e-06, 1.863e-06, 1.296e-06, 8.882e-07, 6.108e-07, 4.283e-07, -4.915e-06, -4.154e-06, 0.000e+00,
586  1.869e-06, 2.184e-06, 1.991e-06, 1.809e-06, 1.296e-06, 1.217e-06, 8.669e-07, 5.751e-07, 3.882e-07,
587  -3.411e-06, -2.902e-06, 0.000e+00, 1.330e-06, 1.567e-06, 1.431e-06, 1.289e-06, 8.882e-07, 8.669e-07,
588  9.522e-07, 6.717e-07, 4.293e-07, 0.000e+00, -2.128e-06, 0.000e+00, 9.186e-07, 1.084e-06, 9.839e-07,
589  9.020e-07, 6.108e-07, 5.751e-07, 6.717e-07, 7.911e-07, 5.493e-07, 0.000e+00, 0.000e+00, 0.000e+00,
590  6.446e-07, 7.575e-07, 6.886e-07, 6.146e-07, 4.283e-07, 3.882e-07, 4.293e-07, 5.493e-07, 7.027e-07},
591  true)),
592  true);
593 
594  edm::ParameterSetDescription psd;
595  psd.addNode(
596  edm::ParameterDescription<std::vector<int>>("activeBXs", {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4}, true) and
597  edm::ParameterDescription<bool>("ampErrorCalculation", true, true) and
598  edm::ParameterDescription<bool>("useLumiInfoRunHeader", true, true) and
599  edm::ParameterDescription<int>("bunchSpacing", 0, true) and
600  edm::ParameterDescription<bool>("doPrefitEB", false, true) and
601  edm::ParameterDescription<bool>("doPrefitEE", false, true) and
602  edm::ParameterDescription<double>("prefitMaxChiSqEB", 25., true) and
603  edm::ParameterDescription<double>("prefitMaxChiSqEE", 10., true) and
604  edm::ParameterDescription<bool>("dynamicPedestalsEB", false, true) and
605  edm::ParameterDescription<bool>("dynamicPedestalsEE", false, true) and
606  edm::ParameterDescription<bool>("mitigateBadSamplesEB", false, true) and
607  edm::ParameterDescription<bool>("mitigateBadSamplesEE", false, true) and
608  edm::ParameterDescription<bool>("gainSwitchUseMaxSampleEB", false, true) and
609  edm::ParameterDescription<bool>("gainSwitchUseMaxSampleEE", false, true) and
610  edm::ParameterDescription<bool>("selectiveBadSampleCriteriaEB", false, true) and
611  edm::ParameterDescription<bool>("selectiveBadSampleCriteriaEE", false, true) and
612  edm::ParameterDescription<double>("addPedestalUncertaintyEB", 0., true) and
613  edm::ParameterDescription<double>("addPedestalUncertaintyEE", 0., true) and
614  edm::ParameterDescription<bool>("simplifiedNoiseModelForGainSwitch", true, true) and
615  edm::ParameterDescription<std::string>("timealgo", "RatioMethod", true) and
616  edm::ParameterDescription<std::vector<double>>("EBtimeFitParameters",
617  {-2.015452e+00,
618  3.130702e+00,
619  -1.234730e+01,
620  4.188921e+01,
621  -8.283944e+01,
622  9.101147e+01,
623  -5.035761e+01,
624  1.105621e+01},
625  true) and
626  edm::ParameterDescription<std::vector<double>>("EEtimeFitParameters",
627  {-2.390548e+00,
628  3.553628e+00,
629  -1.762341e+01,
630  6.767538e+01,
631  -1.332130e+02,
632  1.407432e+02,
633  -7.541106e+01,
634  1.620277e+01},
635  true) and
636  edm::ParameterDescription<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652}, true) and
637  edm::ParameterDescription<std::vector<double>>("EEamplitudeFitParameters", {1.890, 1.400}, true) and
638  edm::ParameterDescription<double>("EBtimeFitLimits_Lower", 0.2, true) and
639  edm::ParameterDescription<double>("EBtimeFitLimits_Upper", 1.4, true) and
640  edm::ParameterDescription<double>("EEtimeFitLimits_Lower", 0.2, true) and
641  edm::ParameterDescription<double>("EEtimeFitLimits_Upper", 1.4, true) and
642  edm::ParameterDescription<double>("EBtimeConstantTerm", .6, true) and
643  edm::ParameterDescription<double>("EEtimeConstantTerm", 1.0, true) and
644  edm::ParameterDescription<double>("EBtimeNconst", 28.5, true) and
645  edm::ParameterDescription<double>("EEtimeNconst", 31.8, true) and
646  edm::ParameterDescription<double>("outOfTimeThresholdGain12pEB", 5, true) and
647  edm::ParameterDescription<double>("outOfTimeThresholdGain12mEB", 5, true) and
648  edm::ParameterDescription<double>("outOfTimeThresholdGain61pEB", 5, true) and
649  edm::ParameterDescription<double>("outOfTimeThresholdGain61mEB", 5, true) and
650  edm::ParameterDescription<double>("outOfTimeThresholdGain12pEE", 1000, true) and
651  edm::ParameterDescription<double>("outOfTimeThresholdGain12mEE", 1000, true) and
652  edm::ParameterDescription<double>("outOfTimeThresholdGain61pEE", 1000, true) and
653  edm::ParameterDescription<double>("outOfTimeThresholdGain61mEE", 1000, true) and
654  edm::ParameterDescription<double>("amplitudeThresholdEB", 10, true) and
655  edm::ParameterDescription<double>("amplitudeThresholdEE", 10, true) and
656  edm::ParameterDescription<double>("ebSpikeThreshold", 1.042, true) and
657  edm::ParameterDescription<std::vector<double>>(
658  "ebPulseShape", {5.2e-05, -5.26e-05, 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and
659  edm::ParameterDescription<std::vector<double>>(
660  "eePulseShape", {5.2e-05, -5.26e-05, 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and
661  edm::ParameterDescription<bool>("kPoorRecoFlagEB", true, true) and
662  edm::ParameterDescription<bool>("kPoorRecoFlagEE", false, true) and
663  edm::ParameterDescription<double>("chi2ThreshEB_", 65.0, true) and
664  edm::ParameterDescription<double>("chi2ThreshEE_", 50.0, true) and
665  edm::ParameterDescription<edm::ParameterSetDescription>("EcalPulseShapeParameters", psd0, true));
666 
667  return psd;
668 }
669 
670 #include "FWCore/Framework/interface/MakerMacros.h"
671 #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h"
672 DEFINE_EDM_PLUGIN(EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerMultiFit, "EcalUncalibRecHitWorkerMultiFit");
673 #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h"
674 DEFINE_EDM_PLUGIN(EcalUncalibRecHitFillDescriptionWorkerFactory,
675  EcalUncalibRecHitWorkerMultiFit,
676  "EcalUncalibRecHitWorkerMultiFit");
EcalDataFrame::MAXSAMPLES
static constexpr int MAXSAMPLES
Definition: EcalDataFrame.h:48
ConfigurationDescriptions.h
EcalUncalibratedRecHit::kHasSwitchToGain6
Definition: EcalUncalibratedRecHit.h:18
EcalUncalibRecHitWorkerMultiFit::ampErrorCalculation_
bool ampErrorCalculation_
Definition: EcalUncalibRecHitWorkerMultiFit.h:68
EcalUncalibRecHitRatioMethodAlgo::computeAmplitude
void computeAmplitude(std::vector< double > &amplitudeFitParameters)
Definition: EcalUncalibRecHitRatioMethodAlgo.h:527
EcalUncalibRecHitWorkerMultiFit::set
void set(const edm::EventSetup &es) override
Definition: EcalUncalibRecHitWorkerMultiFit.cc:109
EBDetId::hashedIndex
int hashedIndex() const
get a compact index for arrays
Definition: EBDetId.h:82
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
EcalTimeOffsetConstantRcd
Definition: EcalTimeOffsetConstantRcd.h:5
EcalTBWeights::getMap
const EcalTBWeightMap & getMap() const
Definition: EcalTBWeights.h:28
EcalUncalibRecHitWorkerMultiFit::EEtimeNconst_
double EEtimeNconst_
Definition: EcalUncalibRecHitWorkerMultiFit.h:118
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG12pEE_
double outOfTimeThreshG12pEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:123
EcalPulseCovariance::covval
float covval[EcalPulseShape::TEMPLATESAMPLES][EcalPulseShape::TEMPLATESAMPLES]
Definition: EcalPulseCovariances.h:13
mps_fire.i
i
Definition: mps_fire.py:355
EcalUncalibRecHitWorkerMultiFit::amplitudeThreshEB_
double amplitudeThreshEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:127
CustomPhysics_cfi.amplitude
amplitude
Definition: CustomPhysics_cfi.py:12
EcalUncalibRecHitFillDescriptionWorkerFactory.h
Reference_intrackfit_cff.barrel
list barrel
Definition: Reference_intrackfit_cff.py:37
MessageLogger.h
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG12mEB_
double outOfTimeThreshG12mEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:120
EcalPedestal::mean_x6
float mean_x6
Definition: EcalPedestals.h:21
EcalUncalibRecHitWorkerMultiFit::noisecors_
std::array< SampleMatrixGainArray, 2 > noisecors_
Definition: EcalUncalibRecHitWorkerMultiFit.h:66
EcalPulseShape
Definition: EcalPulseShapes.h:8
EcalSamplesCorrelationRcd
Definition: EcalSamplesCorrelationRcd.h:12
EcalUncalibRecHitWorkerMultiFit::addPedestalUncertaintyEE_
double addPedestalUncertaintyEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:101
SampleMatrixGainArray
std::array< SampleMatrix, NGains > SampleMatrixGainArray
Definition: EigenMatrixTypes.h:28
simplePhotonAnalyzer_cfi.sample
sample
Definition: simplePhotonAnalyzer_cfi.py:12
EcalUncalibRecHitWorkerMultiFit::run
void run(const edm::Event &evt, const EcalDigiCollection &digis, EcalUncalibratedRecHitCollection &result) override
Definition: EcalUncalibRecHitWorkerMultiFit.cc:235
EcalUncalibRecHitWorkerMultiFit::timealgo_
TimeAlgo timealgo_
Definition: EcalUncalibRecHitWorkerMultiFit.h:80
EcalUncalibRecHitWorkerMultiFit::EBtimeConstantTerm_
double EBtimeConstantTerm_
Definition: EcalUncalibRecHitWorkerMultiFit.h:115
EBDetId
Definition: EBDetId.h:17
EcalSamplesCorrelation::EEG1SamplesCorrelation
std::vector< double > EEG1SamplesCorrelation
Definition: EcalSamplesCorrelation.h:28
FullSampleMatrix
Eigen::Matrix< double, FullSampleVectorSize, FullSampleVectorSize > FullSampleMatrix
Definition: EigenMatrixTypes.h:18
SampleMatrix
Eigen::Matrix< double, SampleVectorSize, SampleVectorSize > SampleMatrix
Definition: EigenMatrixTypes.h:17
EcalSampleMask
Definition: EcalSampleMask.h:16
EcalTimeBiasCorrectionsRcd
Definition: EcalTimeBiasCorrectionsRcd.h:12
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
EcalTimeOffsetConstant::getEEValue
float getEEValue() const
Definition: EcalTimeOffsetConstant.h:21
EcalPulseShape::pdfval
float pdfval[TEMPLATESAMPLES]
Definition: EcalPulseShapes.h:14
EcalUncalibRecHitWorkerMultiFit::pulsecovariances
edm::ESHandle< EcalPulseCovariances > pulsecovariances
Definition: EcalUncalibRecHitWorkerMultiFit.h:58
EcalUncalibRecHitWorkerMultiFit::weightsMethod_endcap_
EcalUncalibRecHitTimeWeightsAlgo< EEDataFrame > weightsMethod_endcap_
Definition: EcalUncalibRecHitWorkerMultiFit.h:87
EcalUncalibRecHitWorkerMultiFit::sampleMaskHand_
edm::ESHandle< EcalSampleMask > sampleMaskHand_
Definition: EcalUncalibRecHitWorkerMultiFit.h:76
edm::SortedCollection
Definition: SortedCollection.h:49
EcalUncalibRecHitWorkerMultiFit::EEtimeConstantTerm_
double EEtimeConstantTerm_
Definition: EcalUncalibRecHitWorkerMultiFit.h:116
EcalUncalibRecHitWorkerMultiFit::prefitMaxChiSqEB_
double prefitMaxChiSqEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:90
EcalUncalibRecHitWorkerMultiFit::multiFitMethod_
EcalUncalibRecHitMultiFitAlgo multiFitMethod_
Definition: EcalUncalibRecHitWorkerMultiFit.h:70
EcalUncalibRecHitWorkerMultiFit::EBtimeFitLimits_
std::pair< double, double > EBtimeFitLimits_
Definition: EcalUncalibRecHitWorkerMultiFit.h:109
EmptyGroupDescription.h
EcalUncalibRecHitWorkerMultiFit::EEtimeFitLimits_
std::pair< double, double > EEtimeFitLimits_
Definition: EcalUncalibRecHitWorkerMultiFit.h:110
EcalUncalibRecHitWorkerMultiFit::noisecovariances
edm::ESHandle< EcalSamplesCorrelation > noisecovariances
Definition: EcalUncalibRecHitWorkerMultiFit.h:56
EcalTimeOffsetConstant::getEBValue
float getEBValue() const
Definition: EcalTimeOffsetConstant.h:20
EcalUncalibRecHitRatioMethodAlgo::getCalculatedRecHit
CalculatedRecHit getCalculatedRecHit()
Definition: EcalUncalibRecHitRatioMethodAlgo.h:75
EcalUncalibRecHitWorkerMultiFit.h
EcalUncalibRecHitWorkerMultiFit::activeBX
BXVector activeBX
Definition: EcalUncalibRecHitWorkerMultiFit.h:67
EcalUncalibRecHitWorkerMultiFit::kPoorRecoFlagEE_
bool kPoorRecoFlagEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:140
EcalUncalibRecHitWorkerMultiFit::doPrefitEB_
bool doPrefitEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:88
EcalUncalibRecHitWorkerMultiFit::gainSwitchUseMaxSampleEE_
bool gainSwitchUseMaxSampleEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:97
EcalDataFrame
Definition: EcalDataFrame.h:16
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG12pEB_
double outOfTimeThreshG12pEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:119
edm::Handle
Definition: AssociativeIterator.h:50
EcalUncalibRecHitRatioMethodAlgo::computeTime
void computeTime(std::vector< double > &timeFitParameters, std::pair< double, double > &timeFitLimits, std::vector< double > &amplitudeFitParameters)
Definition: EcalUncalibRecHitRatioMethodAlgo.h:211
EcalXtalGroupId
Definition: EcalXtalGroupId.h:11
EcalUncalibRecHitWorkerMultiFit::offtime
edm::ESHandle< EcalTimeOffsetConstant > offtime
Definition: EcalUncalibRecHitWorkerMultiFit.h:134
EcalUncalibRecHitWorkerMultiFit::grps
edm::ESHandle< EcalWeightXtalGroups > grps
Definition: EcalUncalibRecHitWorkerMultiFit.h:83
EcalBarrel
Definition: EcalSubdetector.h:10
EcalTimeBiasCorrections::EETimeCorrAmplitudeBins
std::vector< float > EETimeCorrAmplitudeBins
Definition: EcalTimeBiasCorrections.h:26
EcalTBWeightsRcd
Definition: EcalTBWeightsRcd.h:5
EcalUncalibRecHitWorkerMultiFit::mitigateBadSamplesEE_
bool mitigateBadSamplesEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:95
EcalUncalibRecHitWorkerMultiFit::EcalUncalibRecHitWorkerMultiFit
EcalUncalibRecHitWorkerMultiFit()
Definition: EcalUncalibRecHitWorkerMultiFit.h:42
EcalTimeBiasCorrections::EETimeCorrShiftBins
std::vector< float > EETimeCorrShiftBins
Definition: EcalTimeBiasCorrections.h:27
EcalSamplesCorrelationRcd.h
edm::ParameterSetDescription::addOptionalNode
ParameterDescriptionNode * addOptionalNode(ParameterDescriptionNode const &node, bool writeToCfi)
Definition: ParameterSetDescription.cc:50
HLT_2018_cff.activeBXs
activeBXs
Definition: HLT_2018_cff.py:6866
EcalPedestal::mean_x1
float mean_x1
Definition: EcalPedestals.h:23
EcalWeightSet::EcalWeightMatrix
math::Matrix< 3, 10 >::type EcalWeightMatrix
Definition: EcalWeightSet.h:19
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG61pEB_
double outOfTimeThreshG61pEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:121
EcalSamplesCorrelation::EBG12SamplesCorrelation
std::vector< double > EBG12SamplesCorrelation
Definition: EcalSamplesCorrelation.h:22
DetId
Definition: DetId.h:17
MakerMacros.h
EcalUncalibRecHitMultiFitAlgo::setAddPedestalUncertainty
void setAddPedestalUncertainty(double x)
Definition: EcalUncalibRecHitMultiFitAlgo.h:37
EcalUncalibRecHitWorkerMultiFit::mitigateBadSamplesEB_
bool mitigateBadSamplesEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:94
EcalUncalibRecHitWorkerMultiFit::simplifiedNoiseModelForGainSwitch_
bool simplifiedNoiseModelForGainSwitch_
Definition: EcalUncalibRecHitWorkerMultiFit.h:102
EcalUncalibRecHitWorkerMultiFit::gains
edm::ESHandle< EcalGainRatios > gains
Definition: EcalUncalibRecHitWorkerMultiFit.h:55
EcalUncalibRecHitWorkerMultiFit::doPrefitEE_
bool doPrefitEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:89
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG61mEE_
double outOfTimeThreshG61mEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:126
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
EcalUncalibRecHitTimeWeightsAlgo::time
double time(const C &dataFrame, const std::vector< double > &amplitudes, const EcalPedestals::Item *aped, const EcalMGPAGainRatio *aGain, const FullSampleVector &fullpulse, const EcalWeightSet::EcalWeightMatrix **weights)
Compute time.
Definition: EcalUncalibRecHitTimeWeightsAlgo.h:33
EcalUncalibRecHitWorkerMultiFit
Definition: EcalUncalibRecHitWorkerMultiFit.h:39
EcalUncalibRecHitWorkerMultiFit::ratioMethod_barrel_
EcalUncalibRecHitRatioMethodAlgo< EBDataFrame > ratioMethod_barrel_
Definition: EcalUncalibRecHitWorkerMultiFit.h:112
EcalPedestal::mean_x12
float mean_x12
Definition: EcalPedestals.h:19
EcalUncalibRecHitWorkerMultiFit::chi2ThreshEE_
double chi2ThreshEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:142
EcalSampleMaskRcd
Definition: EcalSampleMaskRcd.h:5
EcalUncalibRecHitWorkerMultiFit::kPoorRecoFlagEB_
bool kPoorRecoFlagEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:139
EcalUncalibratedRecHit::kOutOfTime
Definition: EcalUncalibratedRecHit.h:16
EcalUncalibRecHitWorkerMultiFit::timeCorrection
double timeCorrection(float ampli, const std::vector< float > &amplitudeBins, const std::vector< float > &shiftBins)
Definition: EcalUncalibRecHitWorkerMultiFit.cc:188
edm::DataFrameContainer::empty
bool empty() const
Definition: DataFrameContainer.h:160
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
EcalTimeBiasCorrections::EBTimeCorrAmplitudeBins
std::vector< float > EBTimeCorrAmplitudeBins
Definition: EcalTimeBiasCorrections.h:23
EcalTimeOffsetConstantRcd.h
Run.h
EcalUncalibRecHitWorkerMultiFit::selectiveBadSampleCriteriaEB_
bool selectiveBadSampleCriteriaEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:98
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG12mEE_
double outOfTimeThreshG12mEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:124
EcalPedestal::rms_x12
float rms_x12
Definition: EcalPedestals.h:20
EcalUncalibRecHitWorkerMultiFit::addPedestalUncertaintyEB_
double addPedestalUncertaintyEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:100
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:528
EcalUncalibRecHitWorkerMultiFit::itime
edm::ESHandle< EcalTimeCalibConstants > itime
Definition: EcalUncalibRecHitWorkerMultiFit.h:133
EcalUncalibRecHitMultiFitAlgo::makeRecHit
EcalUncalibratedRecHit makeRecHit(const EcalDataFrame &dataFrame, const EcalPedestals::Item *aped, const EcalMGPAGainRatio *aGain, const SampleMatrixGainArray &noisecors, const FullSampleVector &fullpulse, const FullSampleMatrix &fullpulsecov, const BXVector &activeBX)
compute rechits
Definition: EcalUncalibRecHitMultiFitAlgo.cc:27
ParameterSetDescription.h
EcalUncalibRecHitWorkerMultiFit::dynamicPedestalsEB_
bool dynamicPedestalsEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:92
EcalWeightSet::getWeightsAfterGainSwitch
EcalWeightMatrix & getWeightsAfterGainSwitch()
Definition: EcalWeightSet.h:27
DEFINE_EDM_PLUGIN
#define DEFINE_EDM_PLUGIN(factory, type, name)
Definition: PluginFactory.h:124
EcalPulseCovariancesRcd.h
EcalMGPAGainRatio::gain12Over6
float gain12Over6() const
Definition: EcalMGPAGainRatio.h:19
EEDetId
Definition: EEDetId.h:14
EcalGainRatiosRcd
Definition: EcalGainRatiosRcd.h:5
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
EcalUncalibRecHitRatioMethodAlgo
Definition: EcalUncalibRecHitRatioMethodAlgo.h:32
EcalEndcap
Definition: EcalSubdetector.h:10
EcalSampleMaskRcd.h
EcalUncalibRecHitMultiFitAlgo::setPrefitMaxChiSq
void setPrefitMaxChiSq(double x)
Definition: EcalUncalibRecHitMultiFitAlgo.h:33
EcalWeightSet::getWeightsBeforeGainSwitch
EcalWeightMatrix & getWeightsBeforeGainSwitch()
Definition: EcalWeightSet.h:26
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG61pEE_
double outOfTimeThreshG61pEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:125
EcalUncalibRecHitMultiFitAlgo::setDynamicPedestals
void setDynamicPedestals(bool b)
Definition: EcalUncalibRecHitMultiFitAlgo.h:34
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
EcalTBWeights::EcalTDCId
int EcalTDCId
Definition: EcalTBWeights.h:17
edm::ParameterSet
Definition: ParameterSet.h:36
edm::LogError
Definition: MessageLogger.h:183
Event.h
edmplugin::PluginFactory
Definition: PluginFactory.h:34
EcalUncalibRecHitMultiFitAlgo::setMitigateBadSamples
void setMitigateBadSamples(bool b)
Definition: EcalUncalibRecHitMultiFitAlgo.h:35
EcalUncalibRecHitWorkerMultiFit::dynamicPedestalsEE_
bool dynamicPedestalsEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:93
EEDetId::hashedIndex
int hashedIndex() const
Definition: EEDetId.h:183
EcalUncalibRecHitWorkerMultiFit::ebSpikeThresh_
double ebSpikeThresh_
Definition: EcalUncalibRecHitWorkerMultiFit.h:129
createfilelist.int
int
Definition: createfilelist.py:10
EcalUncalibRecHitWorkerMultiFit::EEamplitudeFitParameters_
std::vector< double > EEamplitudeFitParameters_
Definition: EcalUncalibRecHitWorkerMultiFit.h:108
EcalUncalibRecHitWorkerMultiFit::EBtimeNconst_
double EBtimeNconst_
Definition: EcalUncalibRecHitWorkerMultiFit.h:117
EcalPedestal::rms_x1
float rms_x1
Definition: EcalPedestals.h:24
edm::DataFrameContainer::begin
const_iterator begin() const
The iterator returned can not safely be used across threads.
Definition: DataFrameContainer.h:149
EcalUncalibRecHitWorkerMultiFit::bunchSpacing_
edm::EDGetTokenT< unsigned int > bunchSpacing_
Definition: EcalUncalibRecHitWorkerMultiFit.h:73
EcalSamplesCorrelation::EBG1SamplesCorrelation
std::vector< double > EBG1SamplesCorrelation
Definition: EcalSamplesCorrelation.h:24
EcalCondDBWriter_cfi.pedestal
pedestal
Definition: EcalCondDBWriter_cfi.py:49
edm::EventSetup
Definition: EventSetup.h:57
edm::ParameterSetDescription::addNode
ParameterDescriptionNode * addNode(ParameterDescriptionNode const &node)
Definition: ParameterSetDescription.cc:41
EcalUncalibRecHitWorkerMultiFit::weightsMethod
Definition: EcalUncalibRecHitWorkerMultiFit.h:79
EcalUncalibRecHitMultiFitAlgo::setSelectiveBadSampleCriteria
void setSelectiveBadSampleCriteria(bool b)
Definition: EcalUncalibRecHitMultiFitAlgo.h:36
EcalSamplesCorrelation::EEG12SamplesCorrelation
std::vector< double > EEG12SamplesCorrelation
Definition: EcalSamplesCorrelation.h:26
EcalGainRatiosRcd.h
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
EcalUncalibRecHitWorkerMultiFit::EBamplitudeFitParameters_
std::vector< double > EBamplitudeFitParameters_
Definition: EcalUncalibRecHitWorkerMultiFit.h:107
EcalUncalibRecHitWorkerMultiFit::noisecor
const SampleMatrix & noisecor(bool barrel, int gain) const
Definition: EcalUncalibRecHitWorkerMultiFit.h:62
get
#define get
EcalUncalibRecHitMultiFitAlgo::setDoPrefit
void setDoPrefit(bool b)
Definition: EcalUncalibRecHitMultiFitAlgo.h:32
BXVector::resize
void resize(int bx, unsigned size)
EcalTBWeights::EcalTBWeightMap
std::map< std::pair< EcalXtalGroupId, EcalTDCId >, EcalWeightSet > EcalTBWeightMap
Definition: EcalTBWeights.h:18
FullSampleVector
Eigen::Matrix< double, FullSampleVectorSize, 1 > FullSampleVector
Definition: EigenMatrixTypes.h:13
EcalTimeCalibConstantsRcd
Definition: EcalTimeCalibConstantsRcd.h:5
newFWLiteAna.bin
bin
Definition: newFWLiteAna.py:161
EcalWeightSet
Definition: EcalWeightSet.h:17
EcalUncalibRecHitMultiFitAlgo::disableErrorCalculation
void disableErrorCalculation()
Definition: EcalUncalibRecHitMultiFitAlgo.h:31
EcalUncalibRecHitRatioMethodAlgo::init
void init(const C &dataFrame, const EcalSampleMask &sampleMask, const double *pedestals, const double *pedestalRMSes, const double *gainRatios)
Definition: EcalUncalibRecHitRatioMethodAlgo.h:96
EcalUncalibRecHitWorkerMultiFit::peds
edm::ESHandle< EcalPedestals > peds
Definition: EcalUncalibRecHitWorkerMultiFit.h:54
EcalUncalibRecHitWorkerMultiFit::pulseshapes
edm::ESHandle< EcalPulseShapes > pulseshapes
Definition: EcalUncalibRecHitWorkerMultiFit.h:57
EcalUncalibRecHitMultiFitAlgo::setSimplifiedNoiseModelForGainSwitch
void setSimplifiedNoiseModelForGainSwitch(bool b)
Definition: EcalUncalibRecHitMultiFitAlgo.h:38
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
EcalUncalibRecHitWorkerMultiFit::prefitMaxChiSqEE_
double prefitMaxChiSqEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:91
EcalUncalibRecHitWorkerFactory.h
EcalDigiCollection
Definition: EcalDigiCollections.h:22
EcalUncalibRecHitWorkerMultiFit::eePulseShape_
std::vector< double > eePulseShape_
Definition: EcalUncalibRecHitWorkerMultiFit.h:136
EcalUncalibRecHitWorkerMultiFit::ratioMethod_endcap_
EcalUncalibRecHitRatioMethodAlgo< EEDataFrame > ratioMethod_endcap_
Definition: EcalUncalibRecHitWorkerMultiFit.h:113
EcalUncalibRecHitWorkerMultiFit::weights
const EcalWeightSet::EcalWeightMatrix * weights[2]
Definition: EcalUncalibRecHitWorkerMultiFit.h:85
EcalUncalibRecHitWorkerMultiFit::EBtimeFitParameters_
std::vector< double > EBtimeFitParameters_
Definition: EcalUncalibRecHitWorkerMultiFit.h:105
EcalPulseShapesRcd
Definition: EcalPulseShapesRcd.h:5
EcalMGPAGainRatio::gain6Over1
float gain6Over1() const
Definition: EcalMGPAGainRatio.h:20
EcalUncalibRecHitWorkerMultiFit::outOfTimeThreshG61mEB_
double outOfTimeThreshG61mEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:122
EcalPedestal
Definition: EcalPedestals.h:8
EcalUncalibRecHitWorkerMultiFit::weightsMethod_barrel_
EcalUncalibRecHitTimeWeightsAlgo< EBDataFrame > weightsMethod_barrel_
Definition: EcalUncalibRecHitWorkerMultiFit.h:86
EcalPulseShape::TEMPLATESAMPLES
static const int TEMPLATESAMPLES
Definition: EcalPulseShapes.h:10
EcalUncalibRecHitWorkerMultiFit::selectiveBadSampleCriteriaEE_
bool selectiveBadSampleCriteriaEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:99
EventSetup.h
EcalUncalibratedRecHit::kSaturated
Definition: EcalUncalibratedRecHit.h:15
EcalUncalibRecHitWorkerMultiFit::EEtimeFitParameters_
std::vector< double > EEtimeFitParameters_
Definition: EcalUncalibRecHitWorkerMultiFit.h:106
EcalUncalibRecHitWorkerMultiFit::wgts
edm::ESHandle< EcalTBWeights > wgts
Definition: EcalUncalibRecHitWorkerMultiFit.h:84
BXVector::size
unsigned size(int bx) const
EcalUncalibRecHitRatioMethodAlgo::fixMGPAslew
bool fixMGPAslew(const C &dataFrame)
Definition: EcalUncalibRecHitRatioMethodAlgo.h:179
EcalPedestalsRcd.h
EcalXtalGroupId::id
unsigned int id() const
Definition: EcalXtalGroupId.h:22
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
EcalPulseCovariance
Definition: EcalPulseCovariances.h:9
EcalCondObjectContainer< float >::const_iterator
std::vector< Item >::const_iterator const_iterator
Definition: EcalCondObjectContainer.h:19
EcalUncalibRecHitWorkerMultiFit::chi2ThreshEB_
double chi2ThreshEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:141
mps_fire.result
result
Definition: mps_fire.py:303
EcalUncalibRecHitWorkerMultiFit::timeCorrBias_
edm::ESHandle< EcalTimeBiasCorrections > timeCorrBias_
Definition: EcalUncalibRecHitWorkerMultiFit.h:131
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
EcalUncalibRecHitWorkerMultiFit::ratioMethod
Definition: EcalUncalibRecHitWorkerMultiFit.h:79
EcalPulseCovariancesRcd
Definition: EcalPulseCovariancesRcd.h:5
EcalSamplesCorrelation::EBG6SamplesCorrelation
std::vector< double > EBG6SamplesCorrelation
Definition: EcalSamplesCorrelation.h:23
EcalWeightXtalGroupsRcd
Definition: EcalWeightXtalGroupsRcd.h:5
ecalMGPA::gainId
constexpr int gainId(sample_type sample)
get the gainId (2 bits)
Definition: EcalMGPASample.h:13
ParameterSet.h
EcalUncalibRecHitWorkerMultiFit::ebPulseShape_
std::vector< double > ebPulseShape_
Definition: EcalUncalibRecHitWorkerMultiFit.h:135
EcalTimeCalibConstantsRcd.h
EcalPedestalsRcd
Definition: EcalPedestalsRcd.h:5
EcalTimeBiasCorrections::EBTimeCorrShiftBins
std::vector< float > EBTimeCorrShiftBins
Definition: EcalTimeBiasCorrections.h:24
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
EcalUncalibRecHitWorkerMultiFit::useLumiInfoRunHeader_
bool useLumiInfoRunHeader_
Definition: EcalUncalibRecHitWorkerMultiFit.h:69
EcalUncalibRecHitMultiFitAlgo::setGainSwitchUseMaxSample
void setGainSwitchUseMaxSample(bool b)
Definition: EcalUncalibRecHitMultiFitAlgo.h:39
EcalUncalibratedRecHit::kHasSwitchToGain1
Definition: EcalUncalibratedRecHit.h:19
edm::Event
Definition: Event.h:73
EcalTimeBiasCorrectionsRcd.h
EcalUncalibRecHitWorkerMultiFit::gainSwitchUseMaxSampleEB_
bool gainSwitchUseMaxSampleEB_
Definition: EcalUncalibRecHitWorkerMultiFit.h:96
ecalpyutils::hashedIndex
int hashedIndex(int ieta, int iphi)
Definition: EcalPyUtils.cc:38
edm::ParameterDescription
Definition: ParameterDescription.h:110
EcalSamplesCorrelation::EEG6SamplesCorrelation
std::vector< double > EEG6SamplesCorrelation
Definition: EcalSamplesCorrelation.h:27
EcalUncalibRecHitWorkerMultiFit::getAlgoDescription
edm::ParameterSetDescription getAlgoDescription() override
Definition: EcalUncalibRecHitWorkerMultiFit.cc:491
edm::DataFrameContainer::end
const_iterator end() const
Definition: DataFrameContainer.h:152
EcalWeightXtalGroupsRcd.h
EcalTBWeightsRcd.h
edm::ConsumesCollector
Definition: ConsumesCollector.h:39
EcalUncalibRecHitWorkerMultiFit::bunchSpacingManual_
int bunchSpacingManual_
Definition: EcalUncalibRecHitWorkerMultiFit.h:72
EcalTimeCalibConstant
float EcalTimeCalibConstant
Definition: EcalTimeCalibConstants.h:10
EcalPedestal::rms_x6
float rms_x6
Definition: EcalPedestals.h:22
EcalMGPAGainRatio
Definition: EcalMGPAGainRatio.h:13
EcalPulseShapesRcd.h
EcalUncalibRecHitWorkerMultiFit::amplitudeThreshEE_
double amplitudeThreshEE_
Definition: EcalUncalibRecHitWorkerMultiFit.h:128
edm::DataFrameContainer::size
size_type size() const
Definition: DataFrameContainer.h:162
EcalUncalibRecHitWorkerBaseClass
Definition: EcalUncalibRecHitWorkerBaseClass.h:16
Generated for CMSSW Reference Manual by doxygen 1.8.16