CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
HcalHitReconstructor.cc
Go to the documentation of this file.
1 #include "HcalHitReconstructor.h"
2 #include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
3 #include "DataFormats/Common/interface/EDCollection.h"
4 #include "DataFormats/Common/interface/Handle.h"
5 #include "FWCore/Framework/interface/ESHandle.h"
6 #include "FWCore/Framework/interface/EventSetup.h"
7 #include "CalibFormats/HcalObjects/interface/HcalCoderDb.h"
8 #include "CalibFormats/HcalObjects/interface/HcalDbRecord.h"
9 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSeverityLevelComputer.h"
10 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSeverityLevelComputerRcd.h"
11 #include "CalibCalorimetry/HcalAlgos/interface/HcalDbASCIIIO.h"
12 #include "Geometry/CaloTopology/interface/HcalTopology.h"
13 #include "Geometry/Records/interface/IdealGeometryRecord.h"
14 #include "CondFormats/DataRecord/interface/HcalOOTPileupCorrectionRcd.h"
15 #include "CondFormats/DataRecord/interface/HcalOOTPileupCompatibilityRcd.h"
16 #include "CondFormats/DataRecord/interface/HBHENegativeEFilterRcd.h"
17 #include "CondFormats/HcalObjects/interface/OOTPileupCorrectionColl.h"
18 #include "CondFormats/HcalObjects/interface/OOTPileupCorrData.h"
19 #include <iostream>
20 #include <fstream>
21 
22 
23 /* Hcal Hit reconstructor allows for CaloRecHits with status words */
24 
25 HcalHitReconstructor::HcalHitReconstructor(edm::ParameterSet const& conf):
26  reco_(conf.getParameter<bool>("correctForTimeslew"),
27  conf.getParameter<bool>("correctForPhaseContainment"),
28  conf.getParameter<double>("correctionPhaseNS")),
29  det_(DetId::Hcal),
30  inputLabel_(conf.getParameter<edm::InputTag>("digiLabel")),
31  correctTiming_(conf.getParameter<bool>("correctTiming")),
32  setNoiseFlags_(conf.getParameter<bool>("setNoiseFlags")),
33  setHSCPFlags_(conf.getParameter<bool>("setHSCPFlags")),
34  setSaturationFlags_(conf.getParameter<bool>("setSaturationFlags")),
35  setTimingTrustFlags_(conf.getParameter<bool>("setTimingTrustFlags")),
36  setPulseShapeFlags_(conf.getParameter<bool>("setPulseShapeFlags")),
37  setNegativeFlags_(false),
38  dropZSmarkedPassed_(conf.getParameter<bool>("dropZSmarkedPassed")),
39  firstAuxTS_(conf.getParameter<int>("firstAuxTS")),
40  firstSample_(conf.getParameter<int>("firstSample")),
41  samplesToAdd_(conf.getParameter<int>("samplesToAdd")),
42  tsFromDB_(conf.getParameter<bool>("tsFromDB")),
43  useLeakCorrection_(conf.getParameter<bool>("useLeakCorrection")),
44  dataOOTCorrectionName_(""),
45  dataOOTCorrectionCategory_("Data"),
46  mcOOTCorrectionName_(""),
47  mcOOTCorrectionCategory_("MC"),
48  setPileupCorrection_(0),
49  paramTS(0),
50  puCorrMethod_(conf.existsAs<int>("puCorrMethod") ? conf.getParameter<int>("puCorrMethod") : 0),
51  cntprtCorrMethod_(0),
52  first_(true)
53 
54 {
55  // register for data access
56  tok_hbhe_ = consumes<HBHEDigiCollection>(inputLabel_);
57  tok_ho_ = consumes<HODigiCollection>(inputLabel_);
58  tok_hf_ = consumes<HFDigiCollection>(inputLabel_);
59  tok_calib_ = consumes<HcalCalibDigiCollection>(inputLabel_);
60 
61  std::string subd=conf.getParameter<std::string>("Subdetector");
62  //Set all FlagSetters to 0
63  /* Important to do this! Otherwise, if the setters are turned off,
64  the "if (XSetter_) delete XSetter_;" commands can crash
65  */
66 
67  recoParamsFromDB_ = conf.getParameter<bool>("recoParamsFromDB");
68  // recoParamsFromDB_ = false ; // trun off for now.
69 
70  // std::cout<<" HcalHitReconstructor recoParamsFromDB_ "<<recoParamsFromDB_<<std::endl;
71 
72  if (conf.existsAs<bool>("setNegativeFlags"))
73  setNegativeFlags_ = conf.getParameter<bool>("setNegativeFlags");
74 
75  hbheFlagSetter_ = 0;
76  hbheHSCPFlagSetter_ = 0;
77  hbhePulseShapeFlagSetter_ = 0;
78  hbheNegativeFlagSetter_ = 0;
79  hbheTimingShapedFlagSetter_ = 0;
80  hfdigibit_ = 0;
81 
82  hfS9S1_ = 0;
83  hfS8S1_ = 0;
84  hfPET_ = 0;
85  saturationFlagSetter_ = 0;
86  HFTimingTrustFlagSetter_ = 0;
87  digiTimeFromDB_ = false; // only need for HF
88 
89  if (setSaturationFlags_)
90  {
91  const edm::ParameterSet& pssat = conf.getParameter<edm::ParameterSet>("saturationParameters");
92  saturationFlagSetter_ = new HcalADCSaturationFlag(pssat.getParameter<int>("maxADCvalue"));
93  }
94 
95  if (!strcasecmp(subd.c_str(),"HBHE")) {
96  subdet_=HcalBarrel;
97 
98  setPileupCorrection_ = 0;
99  if(puCorrMethod_ == 1) setPileupCorrection_ = &HcalSimpleRecAlgo::setHBHEPileupCorrection;
100 
101  bool timingShapedCutsFlags = conf.getParameter<bool>("setTimingShapedCutsFlags");
102  if (timingShapedCutsFlags)
103  {
104  const edm::ParameterSet& psTshaped = conf.getParameter<edm::ParameterSet>("timingshapedcutsParameters");
105  hbheTimingShapedFlagSetter_ = new HBHETimingShapedFlagSetter(psTshaped.getParameter<std::vector<double> >("tfilterEnvelope"),
106  psTshaped.getParameter<bool>("ignorelowest"),
107  psTshaped.getParameter<bool>("ignorehighest"),
108  psTshaped.getParameter<double>("win_offset"),
109  psTshaped.getParameter<double>("win_gain"));
110  }
111 
112  if (setNoiseFlags_)
113  {
114  const edm::ParameterSet& psdigi =conf.getParameter<edm::ParameterSet>("flagParameters");
115  hbheFlagSetter_=new HBHEStatusBitSetter(psdigi.getParameter<double>("nominalPedestal"),
116  psdigi.getParameter<double>("hitEnergyMinimum"),
117  psdigi.getParameter<int>("hitMultiplicityThreshold"),
118  psdigi.getParameter<std::vector<edm::ParameterSet> >("pulseShapeParameterSets")
119  );
120  } // if (setNoiseFlags_)
121  if (setHSCPFlags_)
122  {
123  const edm::ParameterSet& psHSCP = conf.getParameter<edm::ParameterSet>("hscpParameters");
124  hbheHSCPFlagSetter_ = new HBHETimeProfileStatusBitSetter(psHSCP.getParameter<double>("r1Min"),
125  psHSCP.getParameter<double>("r1Max"),
126  psHSCP.getParameter<double>("r2Min"),
127  psHSCP.getParameter<double>("r2Max"),
128  psHSCP.getParameter<double>("fracLeaderMin"),
129  psHSCP.getParameter<double>("fracLeaderMax"),
130  psHSCP.getParameter<double>("slopeMin"),
131  psHSCP.getParameter<double>("slopeMax"),
132  psHSCP.getParameter<double>("outerMin"),
133  psHSCP.getParameter<double>("outerMax"),
134  psHSCP.getParameter<double>("TimingEnergyThreshold"));
135  } // if (setHSCPFlags_)
136  if (setPulseShapeFlags_)
137  {
138  const edm::ParameterSet &psPulseShape = conf.getParameter<edm::ParameterSet>("pulseShapeParameters");
139  hbhePulseShapeFlagSetter_ = new HBHEPulseShapeFlagSetter(
140  psPulseShape.getParameter<double>("MinimumChargeThreshold"),
141  psPulseShape.getParameter<double>("TS4TS5ChargeThreshold"),
142  psPulseShape.getParameter<unsigned int>("TrianglePeakTS"),
143  psPulseShape.getParameter<std::vector<double> >("LinearThreshold"),
144  psPulseShape.getParameter<std::vector<double> >("LinearCut"),
145  psPulseShape.getParameter<std::vector<double> >("RMS8MaxThreshold"),
146  psPulseShape.getParameter<std::vector<double> >("RMS8MaxCut"),
147  psPulseShape.getParameter<std::vector<double> >("LeftSlopeThreshold"),
148  psPulseShape.getParameter<std::vector<double> >("LeftSlopeCut"),
149  psPulseShape.getParameter<std::vector<double> >("RightSlopeThreshold"),
150  psPulseShape.getParameter<std::vector<double> >("RightSlopeCut"),
151  psPulseShape.getParameter<std::vector<double> >("RightSlopeSmallThreshold"),
152  psPulseShape.getParameter<std::vector<double> >("RightSlopeSmallCut"),
153  psPulseShape.getParameter<std::vector<double> >("TS4TS5LowerThreshold"),
154  psPulseShape.getParameter<std::vector<double> >("TS4TS5LowerCut"),
155  psPulseShape.getParameter<std::vector<double> >("TS4TS5UpperThreshold"),
156  psPulseShape.getParameter<std::vector<double> >("TS4TS5UpperCut"),
157  psPulseShape.getParameter<bool>("UseDualFit"),
158  psPulseShape.getParameter<bool>("TriangleIgnoreSlow"));
159  } // if (setPulseShapeFlags_)
160  if (setNegativeFlags_)
161  hbheNegativeFlagSetter_ = new HBHENegativeFlagSetter();
162 
163  produces<HBHERecHitCollection>();
164  } else if (!strcasecmp(subd.c_str(),"HO")) {
165  subdet_=HcalOuter;
166  setPileupCorrection_ = &HcalSimpleRecAlgo::setHOPileupCorrection;
167  setPileupCorrection_ = 0;
168  produces<HORecHitCollection>();
169  } else if (!strcasecmp(subd.c_str(),"HF")) {
170  subdet_=HcalForward;
171  setPileupCorrection_ = &HcalSimpleRecAlgo::setHFPileupCorrection;
172  setPileupCorrection_ = 0;
173  digiTimeFromDB_=conf.getParameter<bool>("digiTimeFromDB");
174 
175  if (setTimingTrustFlags_) {
176 
177  const edm::ParameterSet& pstrust = conf.getParameter<edm::ParameterSet>("hfTimingTrustParameters");
178  HFTimingTrustFlagSetter_=new HFTimingTrustFlag(pstrust.getParameter<int>("hfTimingTrustLevel1"),
179  pstrust.getParameter<int>("hfTimingTrustLevel2"));
180  }
181 
182  if (setNoiseFlags_)
183  {
184  const edm::ParameterSet& psdigi =conf.getParameter<edm::ParameterSet>("digistat");
185  const edm::ParameterSet& psTimeWin =conf.getParameter<edm::ParameterSet>("HFInWindowStat");
186  hfdigibit_=new HcalHFStatusBitFromDigis(psdigi,psTimeWin);
187 
188  const edm::ParameterSet& psS9S1 = conf.getParameter<edm::ParameterSet>("S9S1stat");
189  hfS9S1_ = new HcalHF_S9S1algorithm(psS9S1.getParameter<std::vector<double> >("short_optimumSlope"),
190  psS9S1.getParameter<std::vector<double> >("shortEnergyParams"),
191  psS9S1.getParameter<std::vector<double> >("shortETParams"),
192  psS9S1.getParameter<std::vector<double> >("long_optimumSlope"),
193  psS9S1.getParameter<std::vector<double> >("longEnergyParams"),
194  psS9S1.getParameter<std::vector<double> >("longETParams"),
195  psS9S1.getParameter<int>("HcalAcceptSeverityLevel"),
196  psS9S1.getParameter<bool>("isS8S1")
197  );
198 
199  const edm::ParameterSet& psS8S1 = conf.getParameter<edm::ParameterSet>("S8S1stat");
200  hfS8S1_ = new HcalHF_S9S1algorithm(psS8S1.getParameter<std::vector<double> >("short_optimumSlope"),
201  psS8S1.getParameter<std::vector<double> >("shortEnergyParams"),
202  psS8S1.getParameter<std::vector<double> >("shortETParams"),
203  psS8S1.getParameter<std::vector<double> >("long_optimumSlope"),
204  psS8S1.getParameter<std::vector<double> >("longEnergyParams"),
205  psS8S1.getParameter<std::vector<double> >("longETParams"),
206  psS8S1.getParameter<int>("HcalAcceptSeverityLevel"),
207  psS8S1.getParameter<bool>("isS8S1")
208  );
209 
210  const edm::ParameterSet& psPET = conf.getParameter<edm::ParameterSet>("PETstat");
211  hfPET_ = new HcalHF_PETalgorithm(psPET.getParameter<std::vector<double> >("short_R"),
212  psPET.getParameter<std::vector<double> >("shortEnergyParams"),
213  psPET.getParameter<std::vector<double> >("shortETParams"),
214  psPET.getParameter<std::vector<double> >("long_R"),
215  psPET.getParameter<std::vector<double> >("longEnergyParams"),
216  psPET.getParameter<std::vector<double> >("longETParams"),
217  psPET.getParameter<int>("HcalAcceptSeverityLevel"),
218  psPET.getParameter<std::vector<double> >("short_R_29"),
219  psPET.getParameter<std::vector<double> >("long_R_29")
220  );
221  }
222  produces<HFRecHitCollection>();
223  } else if (!strcasecmp(subd.c_str(),"ZDC")) {
224  det_=DetId::Calo;
225  subdet_=HcalZDCDetId::SubdetectorId;
226  produces<ZDCRecHitCollection>();
227  } else if (!strcasecmp(subd.c_str(),"CALIB")) {
228  subdet_=HcalOther;
229  subdetOther_=HcalCalibration;
230  produces<HcalCalibRecHitCollection>();
231  } else {
232  edm::LogWarning("Configuration") << "HcalHitReconstructor is not associated with a specific subdetector!" << std::endl;
233  }
234 
235  // If no valid OOT pileup correction name specified,
236  // disable the correction
237  if (conf.existsAs<std::string>("dataOOTCorrectionName"))
238  dataOOTCorrectionName_ = conf.getParameter<std::string>("dataOOTCorrectionName");
239  if (conf.existsAs<std::string>("dataOOTCorrectionCategory"))
240  dataOOTCorrectionCategory_ = conf.getParameter<std::string>("dataOOTCorrectionCategory");
241  if (conf.existsAs<std::string>("mcOOTCorrectionName"))
242  mcOOTCorrectionName_ = conf.getParameter<std::string>("mcOOTCorrectionName");
243  if (conf.existsAs<std::string>("mcOOTCorrectionCategory"))
244  mcOOTCorrectionCategory_ = conf.getParameter<std::string>("mcOOTCorrectionCategory");
245  if (dataOOTCorrectionName_.empty() && mcOOTCorrectionName_.empty())
246  setPileupCorrection_ = 0;
247 
248  reco_.setpuCorrMethod(puCorrMethod_);
249  if(puCorrMethod_ == 2) {
250  reco_.setpuCorrParams(
251  conf.getParameter<bool> ("applyPedConstraint"),
252  conf.getParameter<bool> ("applyTimeConstraint"),
253  conf.getParameter<bool> ("applyPulseJitter"),
254  conf.getParameter<bool> ("applyUnconstrainedFit"),
255  conf.getParameter<bool> ("applyTimeSlew"),
256  conf.getParameter<double>("ts4Min"),
257  conf.getParameter<double>("ts4Max"),
258  conf.getParameter<double>("pulseJitter"),
259  conf.getParameter<double>("meanTime"),
260  conf.getParameter<double>("timeSigma"),
261  conf.getParameter<double>("meanPed"),
262  conf.getParameter<double>("pedSigma"),
263  conf.getParameter<double>("noise"),
264  conf.getParameter<double>("timeMin"),
265  conf.getParameter<double>("timeMax"),
266  conf.getParameter<double>("ts3chi2"),
267  conf.getParameter<double>("ts4chi2"),
268  conf.getParameter<double>("ts345chi2"),
269  conf.getParameter<double>("chargeMax"), //For the unconstrained Fit
270  conf.getParameter<int> ("fitTimes")
271  );
272  }
273  if(puCorrMethod_ == 3) {
274  reco_.setMeth3Params(
275  conf.getParameter<int> ("pedestalSubtractionType"),
276  conf.getParameter<double> ("pedestalUpperLimit"),
277  conf.getParameter<int> ("timeSlewParsType"),
278  conf.getParameter<std::vector<double> >("timeSlewPars"),
279  conf.getParameter<double> ("respCorrM3")
280  );
281  }
282 
283 }
284 
285 void HcalHitReconstructor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
286  edm::ParameterSetDescription desc;
287  desc.setAllowAnything();
288  desc.add<int>("pedestalSubtractionType", 1);
289  desc.add<double>("pedestalUpperLimit", 2.7);
290  desc.add<int>("timeSlewParsType",3);
291  desc.add<std::vector<double>>("timeSlewPars", {15.5, -3.2, 32, 15.5, -3.2, 32, 15.5, -3.2, 32});
292  desc.add<double>("respCorrM3", 0.95);
293  descriptions.add("hltHbhereco",desc);
294 }
295 
296 HcalHitReconstructor::~HcalHitReconstructor() {
297  delete hbheFlagSetter_;
298  delete hbheHSCPFlagSetter_;
299  delete hbhePulseShapeFlagSetter_;
300  delete hbheNegativeFlagSetter_;
301  delete hbheTimingShapedFlagSetter_;
302  delete hfdigibit_;
303 
304  delete hfS9S1_;
305  delete hfS8S1_;
306  delete hfPET_;
307  delete saturationFlagSetter_;
308  delete HFTimingTrustFlagSetter_;
309 
310  delete paramTS;
311 }
312 
313 void HcalHitReconstructor::beginRun(edm::Run const&r, edm::EventSetup const & es){
314 
315  edm::ESHandle<HcalTopology> htopo;
316  es.get<IdealGeometryRecord>().get(htopo);
317 
318  if ( tsFromDB_== true || recoParamsFromDB_ == true )
319  {
320  edm::ESHandle<HcalRecoParams> p;
321  es.get<HcalRecoParamsRcd>().get(p);
322  paramTS = new HcalRecoParams(*p.product());
323  paramTS->setTopo(htopo.product());
324 
325 
326 
327 
328  // std::cout<<" skdump in HcalHitReconstructor::beginRun dupm RecoParams "<<std::endl;
329  // std::ofstream skfile("skdumpRecoParamsNewFormat.txt");
330  // HcalDbASCIIIO::dumpObject(skfile, (*paramTS) );
331  }
332 
333  if (digiTimeFromDB_==true)
334  {
335  edm::ESHandle<HcalFlagHFDigiTimeParams> p;
336  es.get<HcalFlagHFDigiTimeParamsRcd>().get(p);
337  HFDigiTimeParams.reset( new HcalFlagHFDigiTimeParams( *p ) );
338 
339  edm::ESHandle<HcalTopology> htopo;
340  es.get<IdealGeometryRecord>().get(htopo);
341  HFDigiTimeParams->setTopo(htopo.product());
342 
343  }
344 
345  reco_.beginRun(es);
346 }
347 
348 void HcalHitReconstructor::endRun(edm::Run const&r, edm::EventSetup const & es){
349  if (tsFromDB_==true)
350  {
351  delete paramTS; paramTS=0;
352  }
353  if (digiTimeFromDB_==true)
354  {
355  //DL delete HFDigiTimeParams; HFDigiTimeParams = 0;
356  }
357  reco_.endRun();
358 }
359 
360 void HcalHitReconstructor::produce(edm::Event& e, const edm::EventSetup& eventSetup)
361 {
362 
363  // get conditions
364  edm::ESHandle<HcalTopology> topo;
365  eventSetup.get<IdealGeometryRecord>().get(topo);
366 
367  edm::ESHandle<HcalDbService> conditions;
368  eventSetup.get<HcalDbRecord>().get(conditions);
369 
370  // HACK related to HB- corrections
371  if ( first_ ) {
372  const bool isData = e.isRealData();
373  if (isData) reco_.setForData(e.run()); else reco_.setForData(0);
374  corrName_ = isData ? dataOOTCorrectionName_ : mcOOTCorrectionName_;
375  cat_ = isData ? dataOOTCorrectionCategory_ : mcOOTCorrectionCategory_;
376  first_=false;
377  }
378  if (useLeakCorrection_) reco_.setLeakCorrection();
379 
380  edm::ESHandle<HcalChannelQuality> p;
381  eventSetup.get<HcalChannelQualityRcd>().get("withTopo",p);
382  const HcalChannelQuality* myqual = p.product();
383 
384  edm::ESHandle<HcalSeverityLevelComputer> mycomputer;
385  eventSetup.get<HcalSeverityLevelComputerRcd>().get(mycomputer);
386  const HcalSeverityLevelComputer* mySeverity = mycomputer.product();
387 
388  // Configure OOT pileup corrections
389  bool isMethod1Set = false;
390  if (!corrName_.empty())
391  {
392  edm::ESHandle<OOTPileupCorrectionColl> pileupCorrections;
393  if (eventSetup.find(edm::eventsetup::EventSetupRecordKey::makeKey<HcalOOTPileupCorrectionRcd>()))
394  eventSetup.get<HcalOOTPileupCorrectionRcd>().get(pileupCorrections);
395  else
396  eventSetup.get<HcalOOTPileupCompatibilityRcd>().get(pileupCorrections);
397 
398  if( setPileupCorrection_ ){
399  const OOTPileupCorrData * testMethod1Ptr = dynamic_cast<OOTPileupCorrData*>((pileupCorrections->get(corrName_, cat_)).get());
400  if( testMethod1Ptr ) isMethod1Set = true;
401  (reco_.*setPileupCorrection_)(pileupCorrections->get(corrName_, cat_));
402  }
403  }
404 
405  // Configure the negative energy filter
406  edm::ESHandle<HBHENegativeEFilter> negEhandle;
407  if (hbheNegativeFlagSetter_)
408  {
409  eventSetup.get<HBHENegativeEFilterRcd>().get(negEhandle);
410  hbheNegativeFlagSetter_->configFilter(negEhandle.product());
411  }
412 
413  // Only for HBHE
414  if( subdet_ == HcalBarrel ) {
415  if( !cntprtCorrMethod_ ) {
416  cntprtCorrMethod_++;
417  if( puCorrMethod_ == 2 ) LogTrace("HcalPUcorrMethod") << "Using Hcal OOTPU method 2" << std::endl;
418  else if( puCorrMethod_ == 1 ){
419  if( isMethod1Set ) LogTrace("HcalPUcorrMethod") << "Using Hcal OOTPU method 1" << std::endl;
420  else edm::LogWarning("HcalPUcorrMethod") <<"puCorrMethod_ set to be 1 but method 1 is NOT activated (method 0 used instead)!\n"
421  <<"Please check GlobalTag usage or method 1 separately disabled by dataOOTCorrectionName & mcOOTCorrectionName?" << std::endl;
422  } else if (puCorrMethod_ == 3) {
423  LogTrace("HcalPUcorrMethod") << "Using Hcal Deterministic Fit Method!" << std::endl;
424  } else LogTrace("HcalPUcorrMethod") << "Using Hcal OOTPU method 0" << std::endl;
425  }
426  }
427 
428  // GET THE BEAM CROSSING INFO HERE, WHEN WE UNDERSTAND HOW THINGS WORK.
429  // Then, call "setBXInfo" method of the reco_ object.
430  // Also remember to call SetBXInfo in the negative energy flag setter.
431 
432  if (det_==DetId::Hcal) {
433 
434  // HBHE -------------------------------------------------------------------
435  if (subdet_==HcalBarrel || subdet_==HcalEndcap) {
436  edm::Handle<HBHEDigiCollection> digi;
437 
438  e.getByToken(tok_hbhe_,digi);
439 
440  // create empty output
441  std::auto_ptr<HBHERecHitCollection> rec(new HBHERecHitCollection);
442  rec->reserve(digi->size());
443  // run the algorithm
444  if (setNoiseFlags_) hbheFlagSetter_->Clear();
445  HBHEDigiCollection::const_iterator i;
446  std::vector<HBHEDataFrame> HBDigis;
447  std::vector<int> RecHitIndex;
448 
449  // Vote on majority TS0 CapId
450  int favorite_capid = 0;
451  if (correctTiming_) {
452  long capid_votes[4] = {0,0,0,0};
453  for (i=digi->begin(); i!=digi->end(); i++) {
454  capid_votes[(*i)[0].capid()]++;
455  }
456  for (int k = 0; k < 4; k++)
457  if (capid_votes[k] > capid_votes[favorite_capid])
458  favorite_capid = k;
459  }
460 
461  for (i=digi->begin(); i!=digi->end(); i++) {
462  HcalDetId cell = i->id();
463  DetId detcell=(DetId)cell;
464 
465  if(tsFromDB_ || recoParamsFromDB_) {
466  const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
467  if(tsFromDB_) {
468  firstSample_ = param_ts->firstSample();
469  samplesToAdd_ = param_ts->samplesToAdd();
470  }
471  if(recoParamsFromDB_) {
472  bool correctForTimeslew=param_ts->correctForTimeslew();
473  bool correctForPhaseContainment= param_ts->correctForPhaseContainment();
474  float phaseNS=param_ts->correctionPhaseNS();
475  useLeakCorrection_= param_ts->useLeakCorrection();
476  correctTiming_ = param_ts->correctTiming();
477  firstAuxTS_ = param_ts->firstAuxTS();
478  int pileupCleaningID = param_ts->pileupCleaningID();
479 
480  /*
481  int sub = cell.subdet();
482  int depth = cell.depth();
483  int inteta = cell.ieta();
484  int intphi = cell.iphi();
485 
486  std::cout << "HcalHitReconstructor::produce cell:"
487  << " sub, ieta, iphi, depth = "
488  << sub << " " << inteta << " " << intphi
489  << " " << depth << std::endl
490  << " first, toadd = " << firstSample_ << ", "
491  << samplesToAdd_ << std::endl
492  << " correctForTimeslew " << correctForTimeslew
493  << std::endl
494  << " correctForPhaseContainment "
495  << correctForPhaseContainment << std::endl
496  << " phaseNS " << phaseNS << std::endl
497  << " useLeakCorrection " << useLeakCorrection_
498  << std::endl
499  << " correctTiming " << correctTiming_ << std::endl
500  << " firstAuxTS " << firstAuxTS_ << std::endl
501  << " pileupCleaningID " << pileupCleaningID
502  << std::endl;
503  */
504 
505  reco_.setRecoParams(correctForTimeslew,correctForPhaseContainment,useLeakCorrection_,pileupCleaningID,phaseNS);
506  }
507  }
508 
509  int first = firstSample_;
510  int toadd = samplesToAdd_;
511 
512  // check on cells to be ignored and dropped: (rof,20.Feb.09)
513  const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
514  if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
515  if (dropZSmarkedPassed_)
516  if (i->zsMarkAndPass()) continue;
517 
518  const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
519  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
520  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
521  HcalCoderDb coder (*channelCoder, *shape);
522 
523  rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
524 
525  // Fill first auxiliary word
526  unsigned int auxflag=0;
527  int fTS = firstAuxTS_;
528  if (fTS<0) fTS=0; // silly protection against time slice <0
529  for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx) {
530  int adcv = i->sample(xx).adc();
531  auxflag+=((adcv&0x7F)<<(7*(xx-fTS))); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
532  // bits 28 and 29 are reserved for capid of the first time slice saved in aux
533  }
534  auxflag+=((i->sample(fTS).capid())<<28);
535  (rec->back()).setAux(auxflag);
536 
537  // Fill second auxiliary word
538  auxflag=0;
539  int fTS2 = (firstAuxTS_-4 < 0) ? 0 : firstAuxTS_-4;
540  for (int xx = fTS2; xx < fTS2+4 && xx<i->size(); ++xx) {
541  int adcv = i->sample(xx).adc();
542  auxflag+=((adcv&0x7F)<<(7*(xx-fTS2)));
543  }
544  auxflag+=((i->sample(fTS2).capid())<<28);
545  (rec->back()).setAuxHBHE(auxflag);
546 
547  (rec->back()).setFlags(0); // this sets all flag bits to 0
548  // Set presample flag
549  if (fTS>0)
550  (rec->back()).setFlagField((i->sample(fTS-1).adc()), HcalCaloFlagLabels::PresampleADC,7);
551 
552  if (hbheTimingShapedFlagSetter_!=0)
553  hbheTimingShapedFlagSetter_->SetTimingShapedFlags(rec->back());
554  if (setNoiseFlags_)
555  hbheFlagSetter_->SetFlagsFromDigi(&(*topo),rec->back(),*i,coder,calibrations,first,toadd);
556  if (setPulseShapeFlags_)
557  hbhePulseShapeFlagSetter_->SetPulseShapeFlags(rec->back(), *i, coder, calibrations);
558  if (setNegativeFlags_)
559  hbheNegativeFlagSetter_->setPulseShapeFlags(rec->back(), *i, coder, calibrations);
560  if (setSaturationFlags_)
561  saturationFlagSetter_->setSaturationFlag(rec->back(),*i);
562  if (correctTiming_)
563  HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
564  if (setHSCPFlags_ && i->id().ietaAbs()<16)
565  {
566  double DigiEnergy=0;
567  for(int j=0; j!=i->size(); DigiEnergy += i->sample(j++).nominal_fC());
568  if(DigiEnergy > hbheHSCPFlagSetter_->EnergyThreshold())
569  {
570  HBDigis.push_back(*i);
571  RecHitIndex.push_back(rec->size()-1);
572  }
573 
574  } // if (set HSCPFlags_ && |ieta|<16)
575  } // loop over HBHE digis
576 
577 
578  if (setNoiseFlags_) hbheFlagSetter_->SetFlagsFromRecHits(&(*topo),*rec);
579  if (setHSCPFlags_) hbheHSCPFlagSetter_->hbheSetTimeFlagsFromDigi(rec.get(), HBDigis, RecHitIndex);
580  // return result
581  e.put(rec);
582 
583  // HO ------------------------------------------------------------------
584  } else if (subdet_==HcalOuter) {
585  edm::Handle<HODigiCollection> digi;
586  e.getByToken(tok_ho_,digi);
587 
588  // create empty output
589  std::auto_ptr<HORecHitCollection> rec(new HORecHitCollection);
590  rec->reserve(digi->size());
591  // run the algorithm
592  HODigiCollection::const_iterator i;
593 
594  // Vote on majority TS0 CapId
595  int favorite_capid = 0;
596  if (correctTiming_) {
597  long capid_votes[4] = {0,0,0,0};
598  for (i=digi->begin(); i!=digi->end(); i++) {
599  capid_votes[(*i)[0].capid()]++;
600  }
601  for (int k = 0; k < 4; k++)
602  if (capid_votes[k] > capid_votes[favorite_capid])
603  favorite_capid = k;
604  }
605 
606  for (i=digi->begin(); i!=digi->end(); i++) {
607  HcalDetId cell = i->id();
608  DetId detcell=(DetId)cell;
609  // firstSample & samplesToAdd
610  if(tsFromDB_ || recoParamsFromDB_) {
611  const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
612  if(tsFromDB_) {
613  firstSample_ = param_ts->firstSample();
614  samplesToAdd_ = param_ts->samplesToAdd();
615  }
616  if(recoParamsFromDB_) {
617  bool correctForTimeslew=param_ts->correctForTimeslew();
618  bool correctForPhaseContainment= param_ts->correctForPhaseContainment();
619  float phaseNS=param_ts->correctionPhaseNS();
620  useLeakCorrection_= param_ts->useLeakCorrection();
621  correctTiming_ = param_ts->correctTiming();
622  firstAuxTS_ = param_ts->firstAuxTS();
623  int pileupCleaningID = param_ts->pileupCleaningID();
624  reco_.setRecoParams(correctForTimeslew,correctForPhaseContainment,useLeakCorrection_,pileupCleaningID,phaseNS);
625  }
626  }
627 
628  int first = firstSample_;
629  int toadd = samplesToAdd_;
630 
631  // check on cells to be ignored and dropped: (rof,20.Feb.09)
632  const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
633  if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
634  if (dropZSmarkedPassed_)
635  if (i->zsMarkAndPass()) continue;
636 
637  const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
638  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
639  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
640  HcalCoderDb coder (*channelCoder, *shape);
641 
642  rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
643 
644  // Set auxiliary flag
645  int auxflag=0;
646  int fTS = firstAuxTS_;
647  if (fTS<0) fTS=0; //silly protection against negative time slice values
648  for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
649  auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
650  // bits 28 and 29 are reserved for capid of the first time slice saved in aux
651  auxflag+=((i->sample(fTS).capid())<<28);
652  (rec->back()).setAux(auxflag);
653  (rec->back()).setFlags(0);
654  // Fill Presample ADC flag
655  if (fTS>0)
656  (rec->back()).setFlagField((i->sample(fTS-1).adc()), HcalCaloFlagLabels::PresampleADC,7);
657 
658  if (setSaturationFlags_)
659  saturationFlagSetter_->setSaturationFlag(rec->back(),*i);
660  if (correctTiming_)
661  HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
662  }
663  // return result
664  e.put(rec);
665 
666  // HF -------------------------------------------------------------------
667  } else if (subdet_==HcalForward) {
668  edm::Handle<HFDigiCollection> digi;
669  e.getByToken(tok_hf_,digi);
670 
671 
673  // create empty output
674  std::auto_ptr<HFRecHitCollection> rec(new HFRecHitCollection);
675  rec->reserve(digi->size());
676  // run the algorithm
677  HFDigiCollection::const_iterator i;
678 
679  // Vote on majority TS0 CapId
680  int favorite_capid = 0;
681  if (correctTiming_) {
682  long capid_votes[4] = {0,0,0,0};
683  for (i=digi->begin(); i!=digi->end(); i++) {
684  capid_votes[(*i)[0].capid()]++;
685  }
686  for (int k = 0; k < 4; k++)
687  if (capid_votes[k] > capid_votes[favorite_capid])
688  favorite_capid = k;
689  }
690 
691  for (i=digi->begin(); i!=digi->end(); i++) {
692  HcalDetId cell = i->id();
693  DetId detcell=(DetId)cell;
694 
695  if(tsFromDB_ || recoParamsFromDB_) {
696  const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
697  if(tsFromDB_) {
698  firstSample_ = param_ts->firstSample();
699  samplesToAdd_ = param_ts->samplesToAdd();
700  }
701  if(recoParamsFromDB_) {
702  bool correctForTimeslew=param_ts->correctForTimeslew();
703  bool correctForPhaseContainment= param_ts->correctForPhaseContainment();
704  float phaseNS=param_ts->correctionPhaseNS();
705  useLeakCorrection_= param_ts->useLeakCorrection();
706  correctTiming_ = param_ts->correctTiming();
707  firstAuxTS_ = param_ts->firstAuxTS();
708  int pileupCleaningID = param_ts->pileupCleaningID();
709  reco_.setRecoParams(correctForTimeslew,correctForPhaseContainment,useLeakCorrection_,pileupCleaningID,phaseNS);
710  }
711  }
712 
713  int first = firstSample_;
714  int toadd = samplesToAdd_;
715 
716  // check on cells to be ignored and dropped: (rof,20.Feb.09)
717  const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
718  if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
719  if (dropZSmarkedPassed_)
720  if (i->zsMarkAndPass()) continue;
721 
722  const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
723  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
724  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
725  HcalCoderDb coder (*channelCoder, *shape);
726 
727  // Set HFDigiTime flag values from digiTimeFromDB_
728  if (digiTimeFromDB_==true && hfdigibit_!=0)
729  {
730  const HcalFlagHFDigiTimeParam* hfDTparam = HFDigiTimeParams->getValues(detcell.rawId());
731  hfdigibit_->resetParamsFromDB(hfDTparam->HFdigiflagFirstSample(),
732  hfDTparam->HFdigiflagSamplesToAdd(),
733  hfDTparam->HFdigiflagExpectedPeak(),
734  hfDTparam->HFdigiflagMinEThreshold(),
735  hfDTparam->HFdigiflagCoefficients()
736  );
737  }
738 
739  //std::cout << "TOADDHF " << toadd << " " << first << " " << std::endl;
740  rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
741 
742  // Set auxiliary flag
743  int auxflag=0;
744  int fTS = firstAuxTS_;
745  if (fTS<0) fTS=0; // silly protection against negative time slice values
746  for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
747  auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
748  // bits 28 and 29 are reserved for capid of the first time slice saved in aux
749  auxflag+=((i->sample(fTS).capid())<<28);
750  (rec->back()).setAux(auxflag);
751 
752  // Clear flags
753  (rec->back()).setFlags(0);
754 
755  // Fill Presample ADC flag
756  if (fTS>0)
757  (rec->back()).setFlagField((i->sample(fTS-1).adc()), HcalCaloFlagLabels::PresampleADC,7);
758 
759  // This calls the code for setting the HF noise bit determined from digi shape
760  if (setNoiseFlags_)
761  hfdigibit_->hfSetFlagFromDigi(rec->back(),*i,coder,calibrations);
762  if (setSaturationFlags_)
763  saturationFlagSetter_->setSaturationFlag(rec->back(),*i);
764  if (setTimingTrustFlags_)
765  HFTimingTrustFlagSetter_->setHFTimingTrustFlag(rec->back(),*i);
766  if (correctTiming_)
767  HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
768  } // for (i=digi->begin(); i!=digi->end(); i++) -- loop on all HF digis
769 
770  // The following flags require the full set of rechits
771  // These need to be set consecutively, so an energy check should be the first
772  // test performed on these hits (to minimize the loop time)
773  if (setNoiseFlags_)
774  {
775  // Step 1: Set PET flag (short fibers of |ieta|==29)
776  // Neighbor/partner channels that are flagged by Pulse Shape algorithm (HFDigiTime)
777  // won't be considered in these calculations
778  for (HFRecHitCollection::iterator i = rec->begin();i!=rec->end();++i)
779  {
780  int depth=i->id().depth();
781  int ieta=i->id().ieta();
782  // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
783  if (depth==2 || abs(ieta)==29 )
784  hfPET_->HFSetFlagFromPET(*i,*rec,myqual,mySeverity);
785  }
786 
787  // Step 2: Set S8S1 flag (short fibers or |ieta|==29)
788  for (HFRecHitCollection::iterator i = rec->begin();i!=rec->end();++i)
789  {
790  int depth=i->id().depth();
791  int ieta=i->id().ieta();
792  // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
793  if (depth==2 || abs(ieta)==29 )
794  hfS8S1_->HFSetFlagFromS9S1(*i,*rec,myqual,mySeverity);
795  }
796 
797  // Set 3: Set S9S1 flag (long fibers)
798  for (HFRecHitCollection::iterator i = rec->begin();i!=rec->end();++i)
799  {
800  int depth=i->id().depth();
801  int ieta=i->id().ieta();
802  // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
803  if (depth==1 && abs(ieta)!=29 )
804  hfS9S1_->HFSetFlagFromS9S1(*i,*rec,myqual, mySeverity);
805  }
806  }
807 
808  // return result
809  e.put(rec);
810  } else if (subdet_==HcalOther && subdetOther_==HcalCalibration) {
811  edm::Handle<HcalCalibDigiCollection> digi;
812  e.getByToken(tok_calib_,digi);
813 
814  // create empty output
815  std::auto_ptr<HcalCalibRecHitCollection> rec(new HcalCalibRecHitCollection);
816  rec->reserve(digi->size());
817  // run the algorithm
818  int first = firstSample_;
819  int toadd = samplesToAdd_;
820 
821  HcalCalibDigiCollection::const_iterator i;
822  for (i=digi->begin(); i!=digi->end(); i++) {
823  HcalCalibDetId cell = i->id();
824  // HcalDetId cellh = i->id();
825  DetId detcell=(DetId)cell;
826  // check on cells to be ignored and dropped: (rof,20.Feb.09)
827  const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
828  if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
829  if (dropZSmarkedPassed_)
830  if (i->zsMarkAndPass()) continue;
831 
832  const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
833  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
834  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
835  HcalCoderDb coder (*channelCoder, *shape);
836 
837  // firstSample & samplesToAdd
838  if(tsFromDB_) {
839  const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
840  first = param_ts->firstSample();
841  toadd = param_ts->samplesToAdd();
842  }
843  rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
844 
845  /*
846  // Flag setting not available for calibration rechits
847  // Set auxiliary flag
848  int auxflag=0;
849  int fTS = firstAuxTS_;
850  for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
851  auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
852  // bits 28 and 29 are reserved for capid of the first time slice saved in aux
853  auxflag+=((i->sample(fTS).capid())<<28);
854  (rec->back()).setAux(auxflag);
855 
856  (rec->back()).setFlags(0); // Not yet implemented for HcalCalibRecHit
857  */
858  }
859  // return result
860  e.put(rec);
861  }
862  }
863  //DL delete myqual;
864 } // void HcalHitReconstructor::produce(...)
HcalHF_S9S1algorithm
Definition: HcalHF_S9S1algorithm.h:22
HcalSimpleRecAlgo::setMeth3Params
void setMeth3Params(int iPedSubMethod, float iPedSubThreshold, int iTimeSlewParsType, std::vector< double > iTimeSlewPars, double irespCorrM3)
Definition: HcalSimpleRecAlgo.cc:73
HcalRecoParam::firstSample
unsigned int firstSample() const
Definition: HcalRecoParam.h:32
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
i
int i
Definition: DBlmapReader.cc:9
HcalHF_S9S1algorithm::HFSetFlagFromS9S1
void HFSetFlagFromS9S1(HFRecHit &hf, HFRecHitCollection &rec, const HcalChannelQuality *myqual, const HcalSeverityLevelComputer *mySeverity)
Definition: HcalHF_S9S1algorithm.cc:86
HcalSimpleRecAlgo::reconstruct
HBHERecHit reconstruct(const HBHEDataFrame &digi, int first, int toadd, const HcalCoder &coder, const HcalCalibrations &calibs) const
Definition: HcalSimpleRecAlgo.cc:527
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:186
HcalHitReconstructor::tok_hbhe_
edm::EDGetTokenT< HBHEDigiCollection > tok_hbhe_
Definition: HcalHitReconstructor.h:76
HBHENegativeFlagSetter::configFilter
void configFilter(const HBHENegativeEFilter *f)
Definition: HBHENegativeFlag.h:19
HFTimingTrustFlag::setHFTimingTrustFlag
void setHFTimingTrustFlag(HFRecHit &rechit, const HFDataFrame &digi)
Definition: HFTimingTrustFlag.cc:131
HcalRecoParam::pileupCleaningID
unsigned int pileupCleaningID() const
Definition: HcalRecoParam.h:44
HcalHitReconstructor::saturationFlagSetter_
HcalADCSaturationFlag * saturationFlagSetter_
Definition: HcalHitReconstructor.h:60
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:457
edm::ParameterSetDescription::setAllowAnything
void setAllowAnything()
allow any parameter label/value pairs
Definition: ParameterSetDescription.cc:46
HcalHitReconstructor::produce
virtual void produce(edm::Event &e, const edm::EventSetup &c) override
Definition: HcalHitReconstructor.cc:360
HcalFlagHFDigiTimeParam::HFdigiflagSamplesToAdd
uint32_t HFdigiflagSamplesToAdd() const
Definition: HcalFlagHFDigiTimeParam.h:56
HcalSimpleRecAlgo::beginRun
void beginRun(edm::EventSetup const &es)
Definition: HcalSimpleRecAlgo.cc:36
HcalRecoParam::correctForPhaseContainment
bool correctForPhaseContainment() const
Definition: HcalRecoParam.h:29
HcalHFStatusBitFromDigis::hfSetFlagFromDigi
void hfSetFlagFromDigi(HFRecHit &hf, const HFDataFrame &digi, const HcalCoder &coder, const HcalCalibrations &calib)
Definition: HcalHFStatusBitFromDigis.cc:76
edm::SortedCollection< HBHEDataFrame >::const_iterator
std::vector< HBHEDataFrame >::const_iterator const_iterator
Definition: SortedCollection.h:82
HcalSimpleRecAlgo::setHOPileupCorrection
void setHOPileupCorrection(boost::shared_ptr< AbsOOTPileupCorrection > corr)
Definition: HcalSimpleRecAlgo.cc:104
HcalCondObjectContainer::getValues
const Item * getValues(DetId fId, bool throwOnFail=true) const
Definition: HcalCondObjectContainer.h:132
HcalHFStatusBitFromDigis::resetParamsFromDB
void resetParamsFromDB(int firstSample, int samplesToAdd, int expectedPeak, double minthreshold, const std::vector< double > &coef)
Definition: HcalHFStatusBitFromDigis.cc:56
HcalHitReconstructor::endRun
virtual void endRun(edm::Run const &r, edm::EventSetup const &es) overridefinal
Definition: HcalHitReconstructor.cc:348
edm::EventBase::isRealData
bool isRealData() const
Definition: EventBase.h:64
HcalHF_PETalgorithm
Definition: HcalHF_PETalgorithm.h:22
HLT_25ns14e33_v1_cff.InputTag
tuple InputTag
Definition: HLT_25ns14e33_v1_cff.py:45333
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
HcalHitReconstructor::setPileupCorrection_
SetCorrectionFcn setPileupCorrection_
Definition: HcalHitReconstructor.h:108
HcalHF_PETalgorithm::HFSetFlagFromPET
void HFSetFlagFromPET(HFRecHit &hf, HFRecHitCollection &rec, const HcalChannelQuality *myqual, const HcalSeverityLevelComputer *mySeverity)
Definition: HcalHF_PETalgorithm.cc:71
edm::EventSetup::find
const eventsetup::EventSetupRecord * find(const eventsetup::EventSetupRecordKey &) const
Definition: EventSetup.cc:90
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
HcalHitReconstructor::dataOOTCorrectionCategory_
std::string dataOOTCorrectionCategory_
Definition: HcalHitReconstructor.h:105
castor_dqm_sourceclient-live_cfg.correctForTimeslew
tuple correctForTimeslew
Definition: castor_dqm_sourceclient-live_cfg.py:150
edm::Event::put
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:115
HcalHitReconstructor::hbheNegativeFlagSetter_
HBHENegativeFlagSetter * hbheNegativeFlagSetter_
Definition: HcalHitReconstructor.h:66
HcalHitReconstructor::HFDigiTimeParams
std::unique_ptr< HcalFlagHFDigiTimeParams > HFDigiTimeParams
Definition: HcalHitReconstructor.h:111
edm::eventsetup::EventSetupRecord::get
void get(HolderT &iHolder) const
Definition: EventSetupRecord.h:93
HcalRecoParam::correctForTimeslew
bool correctForTimeslew() const
Definition: HcalRecoParam.h:38
HcalHitReconstructor::tok_calib_
edm::EDGetTokenT< HcalCalibDigiCollection > tok_calib_
Definition: HcalHitReconstructor.h:79
HcalRecoParam::correctTiming
bool correctTiming() const
Definition: HcalRecoParam.h:40
edm::Event::run
RunNumber_t run() const
Definition: Event.h:87
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
HcalHitReconstructor::hfdigibit_
HcalHFStatusBitFromDigis * hfdigibit_
Definition: HcalHitReconstructor.h:67
j
int j
Definition: DBlmapReader.cc:9
HcalSeverityLevelComputer::dropChannel
bool dropChannel(const uint32_t &mystatus) const
Definition: HcalSeverityLevelComputer.cc:312
HcalFlagHFDigiTimeParam::HFdigiflagExpectedPeak
uint32_t HFdigiflagExpectedPeak() const
Definition: HcalFlagHFDigiTimeParam.h:57
HBHETimeProfileStatusBitSetter::hbheSetTimeFlagsFromDigi
void hbheSetTimeFlagsFromDigi(HBHERecHitCollection *, const std::vector< HBHEDataFrame > &, const std::vector< int > &)
Definition: HBHETimeProfileStatusBitSetter.cc:57
HcalADCSaturationFlag::setSaturationFlag
void setSaturationFlag(HBHERecHit &rechit, const HBHEDataFrame &digi)
Definition: HcalADCSaturationFlag.cc:42
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:89
HcalRecoParam::samplesToAdd
unsigned int samplesToAdd() const
Definition: HcalRecoParam.h:33
HcalHitReconstructor::tok_ho_
edm::EDGetTokenT< HODigiCollection > tok_ho_
Definition: HcalHitReconstructor.h:77
HcalHitReconstructor::HcalHitReconstructor
HcalHitReconstructor(const edm::ParameterSet &ps)
Definition: HcalHitReconstructor.cc:25
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
HcalRecoParam::correctionPhaseNS
float correctionPhaseNS() const
Definition: HcalRecoParam.h:31
castor_dqm_sourceclient-live_cfg.correctForPhaseContainment
tuple correctForPhaseContainment
Definition: castor_dqm_sourceclient-live_cfg.py:149
dbtoconf.conf
tuple conf
Definition: dbtoconf.py:185
HcalHitReconstructor::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: HcalHitReconstructor.cc:285
edm::SortedCollection< HFRecHit >::iterator
std::vector< HFRecHit >::iterator iterator
Definition: SortedCollection.h:83
HLT_25ns14e33_v1_cff.depth
tuple depth
Definition: HLT_25ns14e33_v1_cff.py:6940
HcalFlagHFDigiTimeParam::HFdigiflagCoefficients
std::vector< double > HFdigiflagCoefficients() const
Definition: HcalFlagHFDigiTimeParam.h:59
HcalHitReconstructor::hfPET_
HcalHF_PETalgorithm * hfPET_
Definition: HcalHitReconstructor.h:70
DetId
Definition: DetId.h:18
HcalHitReconstructor::hfS9S1_
HcalHF_S9S1algorithm * hfS9S1_
Definition: HcalHitReconstructor.h:68
HcalHitReconstructor::hbhePulseShapeFlagSetter_
HBHEPulseShapeFlagSetter * hbhePulseShapeFlagSetter_
Definition: HcalHitReconstructor.h:65
HcalZDCDetId::SubdetectorId
static const int SubdetectorId
Definition: HcalZDCDetId.h:20
HcalSimpleRecAlgo::setRecoParams
void setRecoParams(bool correctForTimeslew, bool correctForPulse, bool setLeakCorrection, int pileupCleaningID, float phaseNS)
Definition: HcalSimpleRecAlgo.cc:51
HcalHitReconstructor::beginRun
virtual void beginRun(edm::Run const &r, edm::EventSetup const &es) overridefinal
Definition: HcalHitReconstructor.cc:313
HBHETimingShapedFlagSetter::SetTimingShapedFlags
void SetTimingShapedFlags(HBHERecHit &hbhe)
Definition: HBHETimingShapedFlag.cc:161
HcalFlagHFDigiTimeParam::HFdigiflagFirstSample
uint32_t HFdigiflagFirstSample() const
Definition: HcalFlagHFDigiTimeParam.h:55
HcalSimpleRecAlgo::setHBHEPileupCorrection
void setHBHEPileupCorrection(boost::shared_ptr< AbsOOTPileupCorrection > corr)
Definition: HcalSimpleRecAlgo.cc:92
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
HcalSimpleRecAlgo::setForData
void setForData(int runnum)
Definition: HcalSimpleRecAlgo.cc:79
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:65
HcalHitReconstructor::hbheFlagSetter_
HBHEStatusBitSetter * hbheFlagSetter_
Definition: HcalHitReconstructor.h:62
HcalHitReconstructor::hbheHSCPFlagSetter_
HBHETimeProfileStatusBitSetter * hbheHSCPFlagSetter_
Definition: HcalHitReconstructor.h:63
HcalHitReconstructor::hbheTimingShapedFlagSetter_
HBHETimingShapedFlagSetter * hbheTimingShapedFlagSetter_
Definition: HcalHitReconstructor.h:64
HBHENegativeFlagSetter::setPulseShapeFlags
void setPulseShapeFlags(HBHERecHit &hbhe, const HBHEDataFrame &digi, const HcalCoder &coder, const HcalCalibrations &calib)
Definition: HBHENegativeFlag.cc:5
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
HcalSimpleRecAlgo::setpuCorrMethod
void setpuCorrMethod(int method)
Definition: HcalSimpleRecAlgo.h:82
HcalHitReconstructor::hfS8S1_
HcalHF_S9S1algorithm * hfS8S1_
Definition: HcalHitReconstructor.h:69
HBHEStatusBitSetter::SetFlagsFromRecHits
void SetFlagsFromRecHits(const HcalTopology *topo, HBHERecHitCollection &rec)
Definition: HBHEStatusBitSetter.cc:118
HcalHitReconstructor::subdetOther_
HcalOtherSubdetector subdetOther_
Definition: HcalHitReconstructor.h:74
HcalTimingCorrector::Correct
static void Correct(HBHERecHit &rechit, const HBHEDataFrame &digi, int favorite_capid)
Definition: HcalTimingCorrector.cc:62
HBHEPulseShapeFlagSetter::SetPulseShapeFlags
void SetPulseShapeFlags(HBHERecHit &hbhe, const HBHEDataFrame &digi, const HcalCoder &coder, const HcalCalibrations &calib)
Definition: HBHEPulseShapeFlag.cc:112
HcalRecoParam::firstAuxTS
unsigned int firstAuxTS() const
Definition: HcalRecoParam.h:41
edm::false
volatile std::atomic< bool > shutdown_flag false
Definition: UnixSignalHandlers.cc:22
HcalHitReconstructor::HFTimingTrustFlagSetter_
HFTimingTrustFlag * HFTimingTrustFlagSetter_
Definition: HcalHitReconstructor.h:61
HcalChannelStatus::getValue
uint32_t getValue() const
Definition: HcalChannelStatus.h:65
relval_steps.k
list k
Definition: relval_steps.py:1462
HBHEStatusBitSetter::SetFlagsFromDigi
void SetFlagsFromDigi(const HcalTopology *topo, HBHERecHit &hbhe, const HBHEDataFrame &digi, const HcalCoder &coder, const HcalCalibrations &calib, int firstSample=3, int samplesToAdd=4)
Definition: HBHEStatusBitSetter.cc:51
HcalHitReconstructor::mcOOTCorrectionCategory_
std::string mcOOTCorrectionCategory_
Definition: HcalHitReconstructor.h:107
HcalHitReconstructor::tok_hf_
edm::EDGetTokenT< HFDigiCollection > tok_hf_
Definition: HcalHitReconstructor.h:78
HcalCondObjectContainerBase::setTopo
void setTopo(const HcalTopology *topo)
Definition: HcalCondObjectContainerBase.cc:15
HcalSimpleRecAlgo::setHFPileupCorrection
void setHFPileupCorrection(boost::shared_ptr< AbsOOTPileupCorrection > corr)
Definition: HcalSimpleRecAlgo.cc:98
edm::Run
Definition: Run.h:41
HcalHitReconstructor::reco_
HcalSimpleRecAlgo reco_
Definition: HcalHitReconstructor.h:59
HcalSimpleRecAlgo::setpuCorrParams
void setpuCorrParams(bool iPedestalConstraint, bool iTimeConstraint, bool iAddPulseJitter, bool iUnConstrainedFit, bool iApplyTimeSlew, double iTS4Min, double iTS4Max, double iPulseJitter, double iTimeMean, double iTimeSig, double iPedMean, double iPedSig, double iNoise, double iTMin, double iTMax, double its3Chi2, double its4Chi2, double its345Chi2, double iChargeThreshold, int iFitTimes)
Definition: HcalSimpleRecAlgo.cc:59
HcalFlagHFDigiTimeParam::HFdigiflagMinEThreshold
double HFdigiflagMinEThreshold() const
Definition: HcalFlagHFDigiTimeParam.h:58
HcalRecoParam::useLeakCorrection
bool useLeakCorrection() const
Definition: HcalRecoParam.h:36
Generated for CMSSW Reference Manual by doxygen 1.8.5