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