CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
HcalNoiseInfoProducer.cc
Go to the documentation of this file.
1 //
2 // HcalNoiseInfoProducer.cc
3 //
4 // description: Implementation of the producer for the HCAL noise information
5 //
6 // author: J.P. Chou, Brown
7 //
8 //
9 
26 
27 using namespace reco;
28 
29 //
30 // constructors and destructor
31 //
32 
34 {
35  // set the parameters
36  fillDigis_ = iConfig.getParameter<bool>("fillDigis");
37  fillRecHits_ = iConfig.getParameter<bool>("fillRecHits");
38  fillCaloTowers_ = iConfig.getParameter<bool>("fillCaloTowers");
39  fillTracks_ = iConfig.getParameter<bool>("fillTracks");
40 
41  maxProblemRBXs_ = iConfig.getParameter<int>("maxProblemRBXs");
42 
43  maxCaloTowerIEta_ = iConfig.getParameter<int>("maxCaloTowerIEta");
44  maxTrackEta_ = iConfig.getParameter<double>("maxTrackEta");
45  minTrackPt_ = iConfig.getParameter<double>("minTrackPt");
46 
47  digiCollName_ = iConfig.getParameter<std::string>("digiCollName");
48  recHitCollName_ = iConfig.getParameter<std::string>("recHitCollName");
49  caloTowerCollName_ = iConfig.getParameter<std::string>("caloTowerCollName");
50  trackCollName_ = iConfig.getParameter<std::string>("trackCollName");
51 
52  minRecHitE_ = iConfig.getParameter<double>("minRecHitE");
53  minLowHitE_ = iConfig.getParameter<double>("minLowHitE");
54  minHighHitE_ = iConfig.getParameter<double>("minHighHitE");
55 
56  HcalAcceptSeverityLevel_ = iConfig.getParameter<uint32_t>("HcalAcceptSeverityLevel");
57  if (iConfig.exists("HcalRecHitFlagsToBeExcluded"))
58  HcalRecHitFlagsToBeExcluded_ = iConfig.getParameter<std::vector<int> >("HcalRecHitFlagsToBeExcluded");
59  else{
60  edm::LogWarning("MisConfiguration")<<"the module is missing the parameter HcalAcceptSeverityLevel. created empty.";
62  }
63 
64  TS4TS5EnergyThreshold_ = iConfig.getParameter<double>("TS4TS5EnergyThreshold");
65 
66  std::vector<double> TS4TS5UpperThresholdTemp = iConfig.getParameter<std::vector<double> >("TS4TS5UpperThreshold");
67  std::vector<double> TS4TS5UpperCutTemp = iConfig.getParameter<std::vector<double> >("TS4TS5UpperCut");
68  std::vector<double> TS4TS5LowerThresholdTemp = iConfig.getParameter<std::vector<double> >("TS4TS5LowerThreshold");
69  std::vector<double> TS4TS5LowerCutTemp = iConfig.getParameter<std::vector<double> >("TS4TS5LowerCut");
70 
71  for(int i = 0; i < (int)TS4TS5UpperThresholdTemp.size() && i < (int)TS4TS5UpperCutTemp.size(); i++)
72  TS4TS5UpperCut_.push_back(std::pair<double, double>(TS4TS5UpperThresholdTemp[i], TS4TS5UpperCutTemp[i]));
73  sort(TS4TS5UpperCut_.begin(), TS4TS5UpperCut_.end());
74 
75  for(int i = 0; i < (int)TS4TS5LowerThresholdTemp.size() && i < (int)TS4TS5LowerCutTemp.size(); i++)
76  TS4TS5LowerCut_.push_back(std::pair<double, double>(TS4TS5LowerThresholdTemp[i], TS4TS5LowerCutTemp[i]));
77  sort(TS4TS5LowerCut_.begin(), TS4TS5LowerCut_.end());
78 
79  // if digis are filled, then rechits must also be filled
80  if(fillDigis_ && !fillRecHits_) {
81  fillRecHits_=true;
82  edm::LogWarning("HCalNoiseInfoProducer") << " forcing fillRecHits to be true if fillDigis is true.\n";
83  }
84 
85  const float adc2fCTemp[128]={-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5,10.5,11.5,12.5,
86  13.5,15.,17.,19.,21.,23.,25.,27.,29.5,32.5,35.5,38.5,42.,46.,50.,54.5,59.5,
87  64.5,59.5,64.5,69.5,74.5,79.5,84.5,89.5,94.5,99.5,104.5,109.5,114.5,119.5,
88  124.5,129.5,137.,147.,157.,167.,177.,187.,197.,209.5,224.5,239.5,254.5,272.,
89  292.,312.,334.5,359.5,384.5,359.5,384.5,409.5,434.5,459.5,484.5,509.5,534.5,
90  559.5,584.5,609.5,634.5,659.5,684.5,709.5,747.,797.,847.,897.,947.,997.,
91  1047.,1109.5,1184.5,1259.5,1334.5,1422.,1522.,1622.,1734.5,1859.5,1984.5,
92  1859.5,1984.5,2109.5,2234.5,2359.5,2484.5,2609.5,2734.5,2859.5,2984.5,
93  3109.5,3234.5,3359.5,3484.5,3609.5,3797.,4047.,4297.,4547.,4797.,5047.,
94  5297.,5609.5,5984.5,6359.5,6734.5,7172.,7672.,8172.,8734.5,9359.5,9984.5};
95  for(int i = 0; i < 128; i++)
96  adc2fC[i] = adc2fCTemp[i];
97 
98  // we produce a vector of HcalNoiseRBXs
99  produces<HcalNoiseRBXCollection>();
100  // we also produce a noise summary
101  produces<HcalNoiseSummary>();
102 }
103 
104 
106 {
107 }
108 
109 
110 //
111 // member functions
112 //
113 
114 // ------------ method called to produce the data ------------
115 void
117 {
118  // this is what we're going to actually write to the EDM
119  std::auto_ptr<HcalNoiseRBXCollection> result1(new HcalNoiseRBXCollection);
120  std::auto_ptr<HcalNoiseSummary> result2(new HcalNoiseSummary);
121 
122  // define an empty HcalNoiseRBXArray that we're going to fill
123  HcalNoiseRBXArray rbxarray;
124  HcalNoiseSummary &summary=*result2;
125 
126  // fill them with the various components
127  // digi assumes that rechit information is available
128  if(fillRecHits_) fillrechits(iEvent, iSetup, rbxarray, summary);
129  if(fillDigis_) filldigis(iEvent, iSetup, rbxarray);
130  if(fillCaloTowers_) fillcalotwrs(iEvent, iSetup, rbxarray, summary);
131  if(fillTracks_) filltracks(iEvent, iSetup, summary);
132 
134 
135  // select those RBXs which are interesting
136  // also look for the highest energy RBX
137  HcalNoiseRBXArray::iterator maxit=rbxarray.begin();
138  double maxenergy=-999;
139  bool maxwritten=false;
140  for(HcalNoiseRBXArray::iterator rit = rbxarray.begin(); rit!=rbxarray.end(); ++rit) {
141  HcalNoiseRBX &rbx=(*rit);
144 
145  // find the highest energy rbx
146  if(data.energy()>maxenergy) {
147  maxenergy=data.energy();
148  maxit=rit;
149  maxwritten=false;
150  }
151 
152  // find out if the rbx is problematic/noisy/etc.
153  bool writerbx = algo_.isProblematic(data) || !algo_.passLooseNoiseFilter(data) ||
155 
156  // fill variables in the summary object not filled elsewhere
157  fillOtherSummaryVariables(summary, data);
158 
159  if(writerbx) {
160  summary.nproblemRBXs_++;
161  if(summary.nproblemRBXs_<=maxProblemRBXs_) {
162  result1->push_back(rbx);
163  if(maxit==rit) maxwritten=true;
164  }
165  }
166  } // end loop over rbxs
167 
168  // if we still haven't written the maximum energy rbx, write it now
169  if(!maxwritten) {
170  HcalNoiseRBX &rbx=(*maxit);
171 
172  // add the RBX to the event
173  result1->push_back(rbx);
174  }
175 
176  // put the rbxcollection and summary into the EDM
177  iEvent.put(result1);
178  iEvent.put(result2);
179 
180  return;
181 }
182 
183 // ------------ method called once each job just before starting event loop ------------
184 void
186 {
187  return;
188 }
189 
190 // ------------ method called once each job just after ending the event loop ------------
191 void
193 {
194  return;
195 }
196 
197 
198 // ------------ method called once each run just before starting event loop ------------
199 // ------------ fills the pedestals
200 void
202 {
203  return;
204 }
205 
206 // ------------ method called once each job just after ending the event loop ------------
207 void
209 {
210  return;
211 }
212 
213 // ------------ here we fill specific variables in the summary object not already accounted for earlier
214 void
216 {
217  // charge ratio
218  if(algo_.passRatioThreshold(data) && data.validRatio()) {
219  if(data.ratio()<summary.minE2Over10TS()) {
220  summary.mine2ts_ = data.e2ts();
221  summary.mine10ts_ = data.e10ts(); }
222  if(data.ratio()>summary.maxE2Over10TS()) {
223  summary.maxe2ts_ = data.e2ts();
224  summary.maxe10ts_ = data.e10ts();
225  }
226  }
227 
228  // ADC zeros
229  if(algo_.passZerosThreshold(data)) {
230  if(data.numZeros()>summary.maxZeros()) {
231  summary.maxzeros_ = data.numZeros();
232  }
233  }
234 
235  // hits count
236  if(data.numHPDHits() > summary.maxHPDHits()) {
237  summary.maxhpdhits_ = data.numHPDHits();
238  }
239  if(data.numRBXHits() > summary.maxRBXHits()) {
240  summary.maxrbxhits_ = data.numRBXHits();
241  }
242  if(data.numHPDNoOtherHits() > summary.maxHPDNoOtherHits()) {
243  summary.maxhpdhitsnoother_ = data.numHPDNoOtherHits();
244  }
245 
246  // TS4TS5
247  if(data.PassTS4TS5() == false)
248  summary.hasBadRBXTS4TS5_ = true;
249 
250  // hit timing
251  if(data.minLowEHitTime()<summary.min10GeVHitTime()) {
252  summary.min10_ = data.minLowEHitTime();
253  }
254  if(data.maxLowEHitTime()>summary.max10GeVHitTime()) {
255  summary.max10_ = data.maxLowEHitTime();
256  }
257  summary.rms10_ += data.lowEHitTimeSqrd();
258  summary.cnthit10_ += data.numLowEHits();
259  if(data.minHighEHitTime()<summary.min25GeVHitTime()) {
260  summary.min25_ = data.minHighEHitTime();
261  }
262  if(data.maxHighEHitTime()>summary.max25GeVHitTime()) {
263  summary.max25_ = data.maxHighEHitTime();
264  }
265  summary.rms25_ += data.highEHitTimeSqrd();
266  summary.cnthit25_ += data.numHighEHits();
267 
268  // EMF
269  if(algo_.passEMFThreshold(data)) {
270  if(summary.minHPDEMF() > data.HPDEMF()) {
271  summary.minhpdemf_ = data.HPDEMF();
272  }
273  if(summary.minRBXEMF() > data.RBXEMF()) {
274  summary.minrbxemf_ = data.RBXEMF();
275  }
276  }
277 
278  // summary flag
279  if(!algo_.passLooseRatio(data)) summary.filterstatus_ |= 0x1;
280  if(!algo_.passLooseHits(data)) summary.filterstatus_ |= 0x2;
281  if(!algo_.passLooseZeros(data)) summary.filterstatus_ |= 0x4;
282  if(!algo_.passLooseTiming(data)) summary.filterstatus_ |= 0x8;
283 
284  if(!algo_.passTightRatio(data)) summary.filterstatus_ |= 0x100;
285  if(!algo_.passTightHits(data)) summary.filterstatus_ |= 0x200;
286  if(!algo_.passTightZeros(data)) summary.filterstatus_ |= 0x400;
287  if(!algo_.passTightTiming(data)) summary.filterstatus_ |= 0x800;
288 
289  if(!algo_.passHighLevelNoiseFilter(data)) summary.filterstatus_ |= 0x10000;
290 
291  // summary refvectors
293  if(!algo_.passLooseNoiseFilter(data))
294  join(summary.loosenoisetwrs_, data.rbxTowers());
295  if(!algo_.passTightNoiseFilter(data))
296  join(summary.tightnoisetwrs_, data.rbxTowers());
298  join(summary.hlnoisetwrs_, data.rbxTowers());
299 
300  return;
301 }
302 
303 
304 // ------------ fill the array with digi information
305 void
307 {
308  // Some initialization
309  TotalCalibCharge = 0;
310 
311  // get the conditions and channel quality
312  edm::ESHandle<HcalDbService> conditions;
313  iSetup.get<HcalDbRecord>().get(conditions);
314  const HcalQIEShape* shape = conditions->getHcalShape();
316  iSetup.get<HcalChannelQualityRcd>().get(qualhandle);
317  const HcalChannelQuality* myqual = qualhandle.product();
319  iSetup.get<HcalSeverityLevelComputerRcd>().get(mycomputer);
320  const HcalSeverityLevelComputer* mySeverity = mycomputer.product();
321 
322  // get the digis
324  iEvent.getByLabel(digiCollName_, handle);
325  if(!handle.isValid()) {
326  throw edm::Exception(edm::errors::ProductNotFound) << " could not find HBHEDigiCollection named " << digiCollName_ << "\n.";
327  return;
328  }
329 
330  // loop over all of the digi information
331  for(HBHEDigiCollection::const_iterator it=handle->begin(); it!=handle->end(); ++it) {
332  const HBHEDataFrame &digi=(*it);
333  HcalDetId cell = digi.id();
334  DetId detcell=(DetId)cell;
335 
336  // check on cells to be ignored and dropped
337  const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
338  if(mySeverity->dropChannel(mydigistatus->getValue())) continue;
339  if(digi.zsMarkAndPass()) continue;
340 
341  // get the calibrations and coder
342  const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
343  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
344  HcalCoderDb coder (*channelCoder, *shape);
345 
346  // match the digi to an rbx and hpd
347  HcalNoiseRBX &rbx=(*array.findRBX(digi));
348  HcalNoiseHPD &hpd=(*array.findHPD(digi));
349 
350  // determine if the digi is one the highest energy hits in the HPD
351  // this works because the rechits are sorted by energy (see fillrechits() below)
352  bool isBig=false, isBig5=false, isRBX=false;
353  int counter=0;
356  rit!=rechits.end(); ++rit, ++counter) {
357  if((*rit)->id() == digi.id()) {
358  if(counter==0) isBig=isBig5=true; // digi is also the highest energy rechit
359  if(counter<5) isBig5=true; // digi is one of 5 highest energy rechits
360  isRBX=true;
361  }
362  }
363 
364  // loop over each of the digi's time slices
365  int totalzeros=0;
366  CaloSamples tool;
367  coder.adc2fC(digi,tool);
368  for(int ts=0; ts<tool.size(); ++ts) {
369 
370  // count zero's
371  if(digi[ts].adc()==0) {
372  ++hpd.totalZeros_;
373  ++totalzeros;
374  }
375 
376  // get the fC's
377  double corrfc = tool[ts]-calibrations.pedestal(digi[ts].capid());
378 
379  // fill the relevant digi arrays
380  if(isBig) hpd.bigCharge_[ts]+=corrfc;
381  if(isBig5) hpd.big5Charge_[ts]+=corrfc;
382  if(isRBX) rbx.allCharge_[ts]+=corrfc;
383  }
384 
385  // record the maximum number of zero's found
386  if(totalzeros>hpd.maxZeros_)
387  hpd.maxZeros_=totalzeros;
388  }
389 
390  // get the calibration digis
392  iEvent.getByLabel("hcalDigis", hCalib);
393 
394  // get total charge in calibration channels
395  if(hCalib.isValid() == true)
396  {
397  for(HcalCalibDigiCollection::const_iterator digi = hCalib->begin(); digi != hCalib->end(); digi++)
398  {
399  if(digi->id().hcalSubdet() == 0)
400  continue;
401 
402  /*
403  HcalCalibDetId cell = digi->id();
404  DetId detcell = (DetId)cell;
405 
406  const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
407 
408  if(mySeverity->dropChannel(mydigistatus->getValue()))
409  continue;
410  if(digi->zsMarkAndPass())
411  continue;
412 
413  const HcalQIECoder *channelCoder = conditions->getHcalCoder(cell);
414  HcalCoderDb coder(*channelCoder, *shape);
415 
416  CaloSamples tool;
417  coder.adc2fC(*digi, tool);
418 
419  for(int i = 0; i < (int)digi->size(); i++)
420  TotalCalibCharge = TotalCalibCharge + tool[i];
421  */
422 
423  for(int i = 0; i < (int)digi->size(); i++)
424  TotalCalibCharge = TotalCalibCharge + adc2fC[digi->sample(i).adc()&0xff];
425  }
426  }
427 
428  return;
429 }
430 
431 // ------------ fill the array with rec hit information
432 void
434 {
435  // get the HCAL channel status map
437  iSetup.get<HcalChannelQualityRcd>().get( hcalChStatus );
438  const HcalChannelQuality* dbHcalChStatus = hcalChStatus.product();
439 
440  // get the severity level computer
441  edm::ESHandle<HcalSeverityLevelComputer> hcalSevLvlComputerHndl;
442  iSetup.get<HcalSeverityLevelComputerRcd>().get(hcalSevLvlComputerHndl);
443  const HcalSeverityLevelComputer* hcalSevLvlComputer = hcalSevLvlComputerHndl.product();
444 
445  // get the calo geometry
447  iSetup.get<CaloGeometryRecord>().get(pG);
448  const CaloGeometry* geo = pG.product();
449 
450  // get the rechits
452  iEvent.getByLabel(recHitCollName_, handle);
453  if(!handle.isValid()) {
455  << " could not find HBHERecHitCollection named " << recHitCollName_ << "\n.";
456  return;
457  }
458 
459  summary.rechitCount_ = 0;
460  summary.rechitCount15_ = 0;
461  summary.rechitEnergy_ = 0;
462  summary.rechitEnergy15_ = 0;
463 
464  // loop over all of the rechit information
465  for(HBHERecHitCollection::const_iterator it=handle->begin(); it!=handle->end(); ++it) {
466  const HBHERecHit &rechit=(*it);
467 
468  // skip bad rechits (other than those flagged by the isolated noise, triangle, flat, and spike algorithms)
469  const DetId id = rechit.detid();
470  uint32_t recHitFlag = rechit.flags();
471  uint32_t isolbitset = (1 << HcalCaloFlagLabels::HBHEIsolatedNoise);
472  uint32_t flatbitset = (1 << HcalCaloFlagLabels::HBHEFlatNoise);
473  uint32_t spikebitset = (1 << HcalCaloFlagLabels::HBHESpikeNoise);
474  uint32_t trianglebitset = (1 << HcalCaloFlagLabels::HBHETriangleNoise);
475  uint32_t ts4ts5bitset = (1 << HcalCaloFlagLabels::HBHETS4TS5Noise);
476  for(unsigned int i=0; i<HcalRecHitFlagsToBeExcluded_.size(); i++) {
477  uint32_t bitset = (1 << HcalRecHitFlagsToBeExcluded_[i]);
478  recHitFlag = (recHitFlag & bitset) ? recHitFlag-bitset : recHitFlag;
479  }
480  const uint32_t dbStatusFlag = dbHcalChStatus->getValues(id)->getValue();
481  int severityLevel = hcalSevLvlComputer->getSeverityLevel(id, recHitFlag, dbStatusFlag);
482  bool isRecovered = hcalSevLvlComputer->recoveredRecHit(id, recHitFlag);
483  if(severityLevel!=0 && !isRecovered && severityLevel>static_cast<int>(HcalAcceptSeverityLevel_)) continue;
484 
485  // do some rechit counting and energies
486  summary.rechitCount_ = summary.rechitCount_ + 1;
487  summary.rechitEnergy_ = summary.rechitEnergy_ + rechit.energy();
488  if(rechit.energy() > 1.5)
489  {
490  summary.rechitCount15_ = summary.rechitCount15_ + 1;
491  summary.rechitEnergy15_ = summary.rechitEnergy15_ + rechit.energy();
492  }
493 
494  // if it was ID'd as isolated noise, update the summary object
495  if(rechit.flags() & isolbitset) {
496  summary.nisolnoise_++;
497  summary.isolnoisee_ += rechit.energy();
498  GlobalPoint gp = geo->getPosition(rechit.id());
499  double et = rechit.energy()*gp.perp()/gp.mag();
500  summary.isolnoiseet_ += et;
501  }
502 
503  if(rechit.flags() & flatbitset) {
504  summary.nflatnoise_++;
505  summary.flatnoisee_ += rechit.energy();
506  GlobalPoint gp = geo->getPosition(rechit.id());
507  double et = rechit.energy()*gp.perp()/gp.mag();
508  summary.flatnoiseet_ += et;
509  }
510 
511  if(rechit.flags() & spikebitset) {
512  summary.nspikenoise_++;
513  summary.spikenoisee_ += rechit.energy();
514  GlobalPoint gp = geo->getPosition(rechit.id());
515  double et = rechit.energy()*gp.perp()/gp.mag();
516  summary.spikenoiseet_ += et;
517  }
518 
519  if(rechit.flags() & trianglebitset) {
520  summary.ntrianglenoise_++;
521  summary.trianglenoisee_ += rechit.energy();
522  GlobalPoint gp = geo->getPosition(rechit.id());
523  double et = rechit.energy()*gp.perp()/gp.mag();
524  summary.trianglenoiseet_ += et;
525  }
526 
527  if(rechit.flags() & ts4ts5bitset) {
528  summary.nts4ts5noise_++;
529  summary.ts4ts5noisee_ += rechit.energy();
530  GlobalPoint gp = geo->getPosition(rechit.id());
531  double et = rechit.energy()*gp.perp()/gp.mag();
532  summary.ts4ts5noiseet_ += et;
533  }
534 
535  // find the hpd that the rechit is in
536  HcalNoiseHPD& hpd=(*array.findHPD(rechit));
537 
538  // create a persistent reference to the rechit
539  edm::Ref<HBHERecHitCollection> myRef(handle, it-handle->begin());
540 
541  // store it in a place so that it remains sorted by energy
542  hpd.refrechitset_.insert(myRef);
543 
544  } // end loop over rechits
545 
546  // loop over all HPDs and transfer the information from refrechitset_ to rechits_;
547  for(HcalNoiseRBXArray::iterator rbxit=array.begin(); rbxit!=array.end(); ++rbxit) {
548  for(std::vector<HcalNoiseHPD>::iterator hpdit=rbxit->hpds_.begin(); hpdit!=rbxit->hpds_.end(); ++hpdit) {
549 
550  // loop over all of the entries in the set and add them to rechits_
552  it=hpdit->refrechitset_.begin(); it!=hpdit->refrechitset_.end(); ++it) {
553  hpdit->rechits_.push_back(*it);
554  }
555  }
556  }
557  // now the rechits in all the HPDs are sorted by energy!
558 
559  return;
560 }
561 
562 // ------------ fill the array with calo tower information
563 void
565 {
566  // get the calotowers
568  iEvent.getByLabel(caloTowerCollName_, handle);
569  if(!handle.isValid()) {
571  << " could not find CaloTowerCollection named " << caloTowerCollName_ << "\n.";
572  return;
573  }
574 
575  summary.emenergy_ = summary.hadenergy_ = 0.0;
576 
577  // loop over all of the calotower information
578  for(CaloTowerCollection::const_iterator it = handle->begin(); it!=handle->end(); ++it) {
579  const CaloTower& twr=(*it);
580 
581  // create a persistent reference to the tower
582  edm::Ref<CaloTowerCollection> myRef(handle, it-handle->begin());
583 
584  // get all of the hpd's that are pointed to by the calotower
585  std::vector<std::vector<HcalNoiseHPD>::iterator> hpditervec;
586  array.findHPD(twr, hpditervec);
587 
588  // loop over the hpd's and add the reference to the RefVectors
589  for(std::vector<std::vector<HcalNoiseHPD>::iterator>::iterator it=hpditervec.begin();
590  it!=hpditervec.end(); ++it)
591  (*it)->calotowers_.push_back(myRef);
592 
593  // skip over anything with |ieta|>maxCaloTowerIEta
594  if(twr.ietaAbs()>maxCaloTowerIEta_) {
595  summary.emenergy_ += twr.emEnergy();
596  summary.hadenergy_ += twr.hadEnergy();
597  }
598  }
599 
600  return;
601 }
602 
603 // ------------ fill the summary with track information
604 void
606 {
608  iEvent.getByLabel(trackCollName_, handle);
609 
610  // don't throw exception, just return quietly
611  if(!handle.isValid()) {
612  // throw edm::Exception(edm::errors::ProductNotFound)
613  // << " could not find trackCollection named " << trackCollName_ << "\n.";
614  return;
615  }
616 
617  summary.trackenergy_=0.0;
618  for(reco::TrackCollection::const_iterator iTrack = handle->begin(); iTrack!=handle->end(); ++iTrack) {
619  reco::Track trk=*iTrack;
620  if(trk.pt()<minTrackPt_ || fabs(trk.eta())>maxTrackEta_) continue;
621 
622  summary.trackenergy_ += trk.p();
623  }
624 
625  return;
626 }
627 
628 //define this as a plug-in
int adc(sample_type sample)
get the ADC sample (12 bits)
double e10ts(void) const
Definition: HcalNoiseAlgo.h:23
double HPDEMF(void) const
Definition: HcalNoiseAlgo.h:38
double e2ts(void) const
Definition: HcalNoiseAlgo.h:22
double p() const
momentum vector magnitude
Definition: TrackBase.h:129
T getParameter(std::string const &) const
edm::RefVector< CaloTowerCollection > hlnoisetwrs_
int i
Definition: DBlmapReader.cc:9
double lowEHitTimeSqrd(void) const
Definition: HcalNoiseAlgo.h:31
std::vector< HcalNoiseRBX > HcalNoiseRBXCollection
Definition: HcalNoiseRBX.h:26
std::vector< int > HcalRecHitFlagsToBeExcluded_
bool isProblematic(const CommonHcalNoiseRBXData &) const
bool passTightRatio(const CommonHcalNoiseRBXData &) const
bool zsMarkAndPass() const
was ZS MarkAndPass?
Definition: HBHEDataFrame.h:30
double minLowEHitTime(void) const
Definition: HcalNoiseAlgo.h:29
bool passLooseRatio(const CommonHcalNoiseRBXData &) const
void fillrechits(edm::Event &, const edm::EventSetup &, HcalNoiseRBXArray &, HcalNoiseSummary &) const
const DetId & detid() const
Definition: CaloRecHit.h:22
double maxHighEHitTime(void) const
Definition: HcalNoiseAlgo.h:34
bool passTightTiming(const CommonHcalNoiseRBXData &) const
double maxLowEHitTime(void) const
Definition: HcalNoiseAlgo.h:30
int numLowEHits(void) const
Definition: HcalNoiseAlgo.h:32
double ratio(void) const
Definition: HcalNoiseAlgo.h:21
std::vector< std::pair< double, double > > TS4TS5LowerCut_
HcalDetId id() const
get the id
Definition: HBHERecHit.h:21
std::set< edm::Ref< HBHERecHitCollection >, RefHBHERecHitEnergyComparison > refrechitset_
Definition: HcalNoiseHPD.h:142
std::vector< T >::const_iterator const_iterator
std::vector< float > bigCharge_
Definition: HcalNoiseHPD.h:134
float maxE2Over10TS(void) const
edm::RefVector< CaloTowerCollection > loosenoisetwrs_
bool exists(std::string const &parameterName) const
checks if a parameter exists
void fillcalotwrs(edm::Event &, const edm::EventSetup &, HcalNoiseRBXArray &, HcalNoiseSummary &) const
std::vector< float > big5Charge_
Definition: HcalNoiseHPD.h:135
double pedestal(int fCapId) const
get pedestal for capid=0..3
virtual void beginRun(edm::Run &, const edm::EventSetup &)
const_iterator end() const
Termination of iteration.
Definition: RefVector.h:249
float min25GeVHitTime(void) const
bool passHighLevelNoiseFilter(const CommonHcalNoiseRBXData &) const
const_iterator begin() const
Initialize an iterator over the RefVector.
Definition: RefVector.h:244
double RBXEMF(void) const
Definition: HcalNoiseAlgo.h:37
edm::RefVector< HBHERecHitCollection > rechits_
Definition: HcalNoiseHPD.h:138
int numRBXHits(void) const
Definition: HcalNoiseAlgo.h:26
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
float min10GeVHitTime(void) const
HcalNoiseRBXArray::iterator findRBX(int rbxindex)
double highEHitTimeSqrd(void) const
Definition: HcalNoiseAlgo.h:35
int iEvent
Definition: GenABIO.cc:243
float minE2Over10TS(void) const
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:141
bool passLooseZeros(const CommonHcalNoiseRBXData &) const
double emEnergy() const
Definition: CaloTower.h:79
virtual void endRun(edm::Run &, const edm::EventSetup &)
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:85
int maxRBXHits(void) const
float energy() const
Definition: CaloRecHit.h:19
virtual void adc2fC(const HBHEDataFrame &df, CaloSamples &lf) const
Definition: HcalCoderDb.cc:37
bool passTightZeros(const CommonHcalNoiseRBXData &) const
double pt() const
track transverse momentum
Definition: TrackBase.h:131
bool recoveredRecHit(const DetId &myid, const uint32_t &myflag) const
uint32_t flags() const
Definition: CaloRecHit.h:23
int numHighEHits(void) const
Definition: HcalNoiseAlgo.h:36
tuple handle
Definition: patZpeak.py:22
bool passRatioThreshold(const CommonHcalNoiseRBXData &) const
std::vector< HcalNoiseHPD >::iterator findHPD(int hpdindex)
bool dropChannel(const uint32_t &mystatus) const
const GlobalPoint & getPosition(const DetId &id) const
Get the position of a given detector id.
Definition: CaloGeometry.cc:68
int numHPDNoOtherHits(void) const
Definition: HcalNoiseAlgo.h:27
int numZeros(void) const
Definition: HcalNoiseAlgo.h:28
bool isValid() const
Definition: HandleBase.h:76
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:356
bool passZerosThreshold(const CommonHcalNoiseRBXData &) const
std::vector< std::pair< double, double > > TS4TS5UpperCut_
float minHPDEMF(void) const
bool passLooseNoiseFilter(const CommonHcalNoiseRBXData &) const
edm::RefVector< CaloTowerCollection > rbxTowers(void) const
Definition: HcalNoiseAlgo.h:40
double hadEnergy() const
Definition: CaloTower.h:80
std::vector< float > allCharge_
Definition: HcalNoiseRBX.h:105
DEFINE_FWK_MODULE(CosmicTrackingParticleSelector)
Definition: DetId.h:20
bool passLooseHits(const CommonHcalNoiseRBXData &) const
static std::string join(char **cmd)
Definition: RemoteFile.cc:18
int size() const
get the size
Definition: CaloSamples.h:24
int maxZeros(void) const
virtual void produce(edm::Event &, const edm::EventSetup &)
const T & get() const
Definition: EventSetup.h:55
T const * product() const
Definition: ESHandle.h:62
edm::RefVector< CaloTowerCollection > tightnoisetwrs_
int getSeverityLevel(const DetId &myid, const uint32_t &myflag, const uint32_t &mystatus) const
double energy(void) const
Definition: HcalNoiseAlgo.h:20
ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< float >, ROOT::Math::GlobalCoordinateSystemTag > GlobalPoint
point in global coordinate system
Definition: Point3D.h:18
int ietaAbs() const
Definition: CaloTower.h:155
bool passLooseTiming(const CommonHcalNoiseRBXData &) const
bool passTightNoiseFilter(const CommonHcalNoiseRBXData &) const
int maxHPDNoOtherHits(void) const
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
double minHighEHitTime(void) const
Definition: HcalNoiseAlgo.h:33
float minRBXEMF(void) const
const HcalDetId & id() const
Definition: HBHEDataFrame.h:22
bool PassTS4TS5(void) const
Definition: HcalNoiseAlgo.h:39
uint32_t getValue() const
bool passEMFThreshold(const CommonHcalNoiseRBXData &) const
void filltracks(edm::Event &, const edm::EventSetup &, HcalNoiseSummary &) const
HcalNoiseInfoProducer(const edm::ParameterSet &)
const Item * getValues(DetId fId) const
void fillOtherSummaryVariables(HcalNoiseSummary &summary, const CommonHcalNoiseRBXData &data) const
int maxHPDHits(void) const
int numHPDHits(void) const
Definition: HcalNoiseAlgo.h:25
void filldigis(edm::Event &, const edm::EventSetup &, HcalNoiseRBXArray &)
float max25GeVHitTime(void) const
float max10GeVHitTime(void) const
Definition: Run.h:33
bool validRatio(void) const
Definition: HcalNoiseAlgo.h:24
bool passTightHits(const CommonHcalNoiseRBXData &) const
void set(const std::string &name, int value)
set the flag, with a run-time name