CMS 3D CMS Logo
HcalNoiseAlgo.cc
Go to the documentation of this file.
1 #include "RecoMET/METAlgorithms/interface/HcalNoiseAlgo.h"
2 
3 CommonHcalNoiseRBXData::CommonHcalNoiseRBXData(const reco::HcalNoiseRBX& rbx,
4  double minRecHitE,
5  double minLowHitE,
6  double minHighHitE,
7  double TS4TS5EnergyThreshold,
8  std::vector<std::pair<double, double> >& TS4TS5UpperCut,
9  std::vector<std::pair<double, double> >& TS4TS5LowerCut,
10  double minRBXRechitR45E)
11  : r45Count_(0), r45Fraction_(0), r45EnergyFraction_(0) {
12  // energy
13  energy_ = rbx.recHitEnergy(minRecHitE);
14 
15  // ratio
16  e2ts_ = rbx.allChargeHighest2TS();
17  e10ts_ = rbx.allChargeTotal();
18 
19  // TS4TS5
20  TS4TS5Decision_ = true;
21  if (energy_ > TS4TS5EnergyThreshold) // check filter
22  {
23  std::vector<float> AllCharge = rbx.allCharge();
24  double BaseCharge = AllCharge[4] + AllCharge[5];
25  if (BaseCharge < 1)
26  BaseCharge = 1;
27  double TS4TS5 = (AllCharge[4] - AllCharge[5]) / BaseCharge;
28 
29  if (CheckPassFilter(BaseCharge, TS4TS5, TS4TS5UpperCut, 1) == false)
30  TS4TS5Decision_ = false;
31  if (CheckPassFilter(BaseCharge, TS4TS5, TS4TS5LowerCut, -1) == false)
32  TS4TS5Decision_ = false;
33  } else
34  TS4TS5Decision_ = true;
35 
36  // Rechit-wide R45
37  int rbxHitCount = rbx.numRecHits(minRBXRechitR45E);
38  r45Count_ = 0;
39  r45Fraction_ = 0;
40  r45EnergyFraction_ = 0;
41  if (rbxHitCount > 0) {
42  r45Count_ = rbx.numRecHitsFailR45(minRBXRechitR45E);
43  r45Fraction_ = (double)(r45Count_) / (double)(rbxHitCount);
44  r45EnergyFraction_ = rbx.recHitEnergyFailR45(minRBXRechitR45E) / rbx.recHitEnergy(minRBXRechitR45E);
45  }
46 
47  // # of hits
48  numHPDHits_ = 0;
49  for (std::vector<reco::HcalNoiseHPD>::const_iterator it1 = rbx.HPDsBegin(); it1 != rbx.HPDsEnd(); ++it1) {
50  int nhpdhits = it1->numRecHits(minRecHitE);
51  if (numHPDHits_ < nhpdhits)
52  numHPDHits_ = nhpdhits;
53  }
54  numRBXHits_ = rbx.numRecHits(minRecHitE);
55  numHPDNoOtherHits_ = (numHPDHits_ == numRBXHits_) ? numHPDHits_ : 0;
56 
57  // # of ADC zeros
58  numZeros_ = rbx.totalZeros();
59 
60  // timing
61  minLowEHitTime_ = minHighEHitTime_ = 99999.;
62  maxLowEHitTime_ = maxHighEHitTime_ = -99999.;
63  lowEHitTimeSqrd_ = highEHitTimeSqrd_ = 0;
64  numLowEHits_ = numHighEHits_ = 0;
65  for (std::vector<reco::HcalNoiseHPD>::const_iterator it1 = rbx.HPDsBegin(); it1 != rbx.HPDsEnd(); ++it1) {
66  edm::RefVector<HBHERecHitCollection> rechits = it1->recHits();
67  for (edm::RefVector<HBHERecHitCollection>::const_iterator it2 = rechits.begin(); it2 != rechits.end(); ++it2) {
68  float energy = (*it2)->energy();
69  float time = (*it2)->time();
70  if (energy >= minLowHitE) {
71  if (minLowEHitTime_ > time)
72  minLowEHitTime_ = time;
73  if (maxLowEHitTime_ < time)
74  maxLowEHitTime_ = time;
75  lowEHitTimeSqrd_ += time * time;
76  ++numLowEHits_;
77  }
78  if (energy >= minHighHitE) {
79  if (minHighEHitTime_ > time)
80  minHighEHitTime_ = time;
81  if (maxHighEHitTime_ < time)
82  maxHighEHitTime_ = time;
83  highEHitTimeSqrd_ += time * time;
84  ++numHighEHits_;
85  }
86  }
87  }
88 
89  // emf (get the one with minimum value)
90  HPDEMF_ = 999.;
91  for (std::vector<reco::HcalNoiseHPD>::const_iterator it1 = rbx.HPDsBegin(); it1 != rbx.HPDsEnd(); ++it1) {
92  double eme = it1->caloTowerEmE();
93  double hade = it1->recHitEnergy(minRecHitE);
94  double emf = (eme + hade) == 0 ? 999 : eme / (eme + hade);
95  if (HPDEMF_ > emf)
96  HPDEMF_ = emf;
97  }
98  double eme = rbx.caloTowerEmE();
99  RBXEMF_ = (eme + energy_) == 0 ? 999 : eme / (eme + energy_);
100 
101  // calotowers
102  rbxtowers_.clear();
103  JoinCaloTowerRefVectorsWithoutDuplicates join;
104  for (std::vector<reco::HcalNoiseHPD>::const_iterator it1 = rbx.HPDsBegin(); it1 != rbx.HPDsEnd(); ++it1) {
105  join(rbxtowers_, it1->caloTowers());
106  }
107 
108  return;
109 }
110 
111 HcalNoiseAlgo::HcalNoiseAlgo(const edm::ParameterSet& iConfig) {
112  pMinERatio_ = iConfig.getParameter<double>("pMinERatio");
113  pMinEZeros_ = iConfig.getParameter<double>("pMinEZeros");
114  pMinEEMF_ = iConfig.getParameter<double>("pMinEEMF");
115 
116  minERatio_ = iConfig.getParameter<double>("minERatio");
117  minEZeros_ = iConfig.getParameter<double>("minEZeros");
118  minEEMF_ = iConfig.getParameter<double>("minEEMF");
119 
120  pMinE_ = iConfig.getParameter<double>("pMinE");
121  pMinRatio_ = iConfig.getParameter<double>("pMinRatio");
122  pMaxRatio_ = iConfig.getParameter<double>("pMaxRatio");
123  pMinHPDHits_ = iConfig.getParameter<int>("pMinHPDHits");
124  pMinRBXHits_ = iConfig.getParameter<int>("pMinRBXHits");
125  pMinHPDNoOtherHits_ = iConfig.getParameter<int>("pMinHPDNoOtherHits");
126  pMinZeros_ = iConfig.getParameter<int>("pMinZeros");
127  pMinLowEHitTime_ = iConfig.getParameter<double>("pMinLowEHitTime");
128  pMaxLowEHitTime_ = iConfig.getParameter<double>("pMaxLowEHitTime");
129  pMinHighEHitTime_ = iConfig.getParameter<double>("pMinHighEHitTime");
130  pMaxHighEHitTime_ = iConfig.getParameter<double>("pMaxHighEHitTime");
131  pMaxHPDEMF_ = iConfig.getParameter<double>("pMaxHPDEMF");
132  pMaxRBXEMF_ = iConfig.getParameter<double>("pMaxRBXEMF");
133 
134  if (iConfig.existsAs<int>("pMinRBXRechitR45Count"))
135  pMinRBXRechitR45Count_ = iConfig.getParameter<int>("pMinRBXRechitR45Count");
136  else
137  pMinRBXRechitR45Count_ = 0;
138  if (iConfig.existsAs<double>("pMinRBXRechitR45Fraction"))
139  pMinRBXRechitR45Fraction_ = iConfig.getParameter<double>("pMinRBXRechitR45Fraction");
140  else
141  pMinRBXRechitR45Fraction_ = 0;
142  if (iConfig.existsAs<double>("pMinRBXRechitR45EnergyFraction"))
143  pMinRBXRechitR45EnergyFraction_ = iConfig.getParameter<double>("pMinRBXRechitR45EnergyFraction");
144  else
145  pMinRBXRechitR45EnergyFraction_ = 0;
146 
147  lMinRatio_ = iConfig.getParameter<double>("lMinRatio");
148  lMaxRatio_ = iConfig.getParameter<double>("lMaxRatio");
149  lMinHPDHits_ = iConfig.getParameter<int>("lMinHPDHits");
150  lMinRBXHits_ = iConfig.getParameter<int>("lMinRBXHits");
151  lMinHPDNoOtherHits_ = iConfig.getParameter<int>("lMinHPDNoOtherHits");
152  lMinZeros_ = iConfig.getParameter<int>("lMinZeros");
153  lMinLowEHitTime_ = iConfig.getParameter<double>("lMinLowEHitTime");
154  lMaxLowEHitTime_ = iConfig.getParameter<double>("lMaxLowEHitTime");
155  lMinHighEHitTime_ = iConfig.getParameter<double>("lMinHighEHitTime");
156  lMaxHighEHitTime_ = iConfig.getParameter<double>("lMaxHighEHitTime");
157 
158  if (iConfig.existsAs<std::vector<double> >("lRBXRecHitR45Cuts"))
159  lMinRBXRechitR45Cuts_ = iConfig.getParameter<std::vector<double> >("lRBXRecHitR45Cuts");
160  else {
161  double defaultCut[4] = {-999, -999, -999, -999};
162  lMinRBXRechitR45Cuts_ = std::vector<double>(defaultCut, defaultCut + 4);
163  }
164 
165  tMinRatio_ = iConfig.getParameter<double>("tMinRatio");
166  tMaxRatio_ = iConfig.getParameter<double>("tMaxRatio");
167  tMinHPDHits_ = iConfig.getParameter<int>("tMinHPDHits");
168  tMinRBXHits_ = iConfig.getParameter<int>("tMinRBXHits");
169  tMinHPDNoOtherHits_ = iConfig.getParameter<int>("tMinHPDNoOtherHits");
170  tMinZeros_ = iConfig.getParameter<int>("tMinZeros");
171  tMinLowEHitTime_ = iConfig.getParameter<double>("tMinLowEHitTime");
172  tMaxLowEHitTime_ = iConfig.getParameter<double>("tMaxLowEHitTime");
173  tMinHighEHitTime_ = iConfig.getParameter<double>("tMinHighEHitTime");
174  tMaxHighEHitTime_ = iConfig.getParameter<double>("tMaxHighEHitTime");
175 
176  if (iConfig.existsAs<std::vector<double> >("tRBXRecHitR45Cuts"))
177  tMinRBXRechitR45Cuts_ = iConfig.getParameter<std::vector<double> >("tRBXRecHitR45Cuts");
178  else {
179  double defaultCut[4] = {-999, -999, -999, -999};
180  tMinRBXRechitR45Cuts_ = std::vector<double>(defaultCut, defaultCut + 4);
181  }
182 
183  hlMaxHPDEMF_ = iConfig.getParameter<double>("hlMaxHPDEMF");
184  hlMaxRBXEMF_ = iConfig.getParameter<double>("hlMaxRBXEMF");
185 }
186 
187 bool HcalNoiseAlgo::isProblematic(const CommonHcalNoiseRBXData& data) const {
188  if (data.energy() > pMinE_)
189  return true;
190  if (data.validRatio() && data.energy() > pMinERatio_ && data.ratio() < pMinRatio_)
191  return true;
192  if (data.validRatio() && data.energy() > pMinERatio_ && data.ratio() > pMaxRatio_)
193  return true;
194  if (data.numHPDHits() >= pMinHPDHits_)
195  return true;
196  if (data.numRBXHits() >= pMinRBXHits_)
197  return true;
198  if (data.numHPDNoOtherHits() >= pMinHPDNoOtherHits_)
199  return true;
200  if (data.numZeros() >= pMinZeros_ && data.energy() > pMinEZeros_)
201  return true;
202  if (data.minLowEHitTime() < pMinLowEHitTime_)
203  return true;
204  if (data.maxLowEHitTime() > pMaxLowEHitTime_)
205  return true;
206  if (data.minHighEHitTime() < pMinHighEHitTime_)
207  return true;
208  if (data.maxHighEHitTime() > pMaxHighEHitTime_)
209  return true;
210  if (data.HPDEMF() < pMaxHPDEMF_ && data.energy() > pMinEEMF_)
211  return true;
212  if (data.RBXEMF() < pMaxRBXEMF_ && data.energy() > pMinEEMF_)
213  return true;
214  if (data.r45Count() >= pMinRBXRechitR45Count_)
215  return true;
216  if (data.r45Fraction() >= pMinRBXRechitR45Fraction_)
217  return true;
218  if (data.r45EnergyFraction() >= pMinRBXRechitR45EnergyFraction_)
219  return true;
220 
221  return false;
222 }
223 
224 bool HcalNoiseAlgo::passLooseNoiseFilter(const CommonHcalNoiseRBXData& data) const {
225  return (passLooseRatio(data) && passLooseHits(data) && passLooseZeros(data) && passLooseTiming(data) &&
226  passLooseRBXRechitR45(data));
227 }
228 
229 bool HcalNoiseAlgo::passTightNoiseFilter(const CommonHcalNoiseRBXData& data) const {
230  return (passTightRatio(data) && passTightHits(data) && passTightZeros(data) && passTightTiming(data) &&
231  passTightRBXRechitR45(data));
232 }
233 
234 bool HcalNoiseAlgo::passHighLevelNoiseFilter(const CommonHcalNoiseRBXData& data) const {
235  if (passEMFThreshold(data)) {
236  if (data.HPDEMF() < hlMaxHPDEMF_)
237  return false;
238  if (data.RBXEMF() < hlMaxRBXEMF_)
239  return false;
240  }
241  return true;
242 }
243 
244 bool HcalNoiseAlgo::passLooseRatio(const CommonHcalNoiseRBXData& data) const {
245  if (passRatioThreshold(data)) {
246  if (data.validRatio() && data.ratio() < lMinRatio_)
247  return false;
248  if (data.validRatio() && data.ratio() > lMaxRatio_)
249  return false;
250  }
251  return true;
252 }
253 
254 bool HcalNoiseAlgo::passLooseHits(const CommonHcalNoiseRBXData& data) const {
255  if (data.numHPDHits() >= lMinHPDHits_)
256  return false;
257  if (data.numRBXHits() >= lMinRBXHits_)
258  return false;
259  if (data.numHPDNoOtherHits() >= lMinHPDNoOtherHits_)
260  return false;
261  return true;
262 }
263 
264 bool HcalNoiseAlgo::passLooseZeros(const CommonHcalNoiseRBXData& data) const {
265  if (passZerosThreshold(data)) {
266  if (data.numZeros() >= lMinZeros_)
267  return false;
268  }
269  return true;
270 }
271 
272 bool HcalNoiseAlgo::passLooseTiming(const CommonHcalNoiseRBXData& data) const {
273  if (data.minLowEHitTime() < lMinLowEHitTime_)
274  return false;
275  if (data.maxLowEHitTime() > lMaxLowEHitTime_)
276  return false;
277  if (data.minHighEHitTime() < lMinHighEHitTime_)
278  return false;
279  if (data.maxHighEHitTime() > lMaxHighEHitTime_)
280  return false;
281  return true;
282 }
283 
284 bool HcalNoiseAlgo::passLooseRBXRechitR45(const CommonHcalNoiseRBXData& data) const {
285  int Count = data.r45Count();
286  double Fraction = data.r45Fraction();
287  double EnergyFraction = data.r45EnergyFraction();
288 
289  for (int i = 0; i + 3 < (int)lMinRBXRechitR45Cuts_.size(); i = i + 4) {
290  double Value = Count * lMinRBXRechitR45Cuts_[i] + Fraction * lMinRBXRechitR45Cuts_[i + 1] +
291  EnergyFraction * lMinRBXRechitR45Cuts_[i + 2] + lMinRBXRechitR45Cuts_[i + 3];
292  if (Value > 0)
293  return false;
294  }
295 
296  return true;
297 }
298 
299 bool HcalNoiseAlgo::passTightRatio(const CommonHcalNoiseRBXData& data) const {
300  if (passRatioThreshold(data)) {
301  if (data.validRatio() && data.ratio() < tMinRatio_)
302  return false;
303  if (data.validRatio() && data.ratio() > tMaxRatio_)
304  return false;
305  }
306  return true;
307 }
308 
309 bool HcalNoiseAlgo::passTightHits(const CommonHcalNoiseRBXData& data) const {
310  if (data.numHPDHits() >= tMinHPDHits_)
311  return false;
312  if (data.numRBXHits() >= tMinRBXHits_)
313  return false;
314  if (data.numHPDNoOtherHits() >= tMinHPDNoOtherHits_)
315  return false;
316  return true;
317 }
318 
319 bool HcalNoiseAlgo::passTightZeros(const CommonHcalNoiseRBXData& data) const {
320  if (passZerosThreshold(data)) {
321  if (data.numZeros() >= tMinZeros_)
322  return false;
323  }
324  return true;
325 }
326 
327 bool HcalNoiseAlgo::passTightTiming(const CommonHcalNoiseRBXData& data) const {
328  if (data.minLowEHitTime() < tMinLowEHitTime_)
329  return false;
330  if (data.maxLowEHitTime() > tMaxLowEHitTime_)
331  return false;
332  if (data.minHighEHitTime() < tMinHighEHitTime_)
333  return false;
334  if (data.maxHighEHitTime() > tMaxHighEHitTime_)
335  return false;
336  return true;
337 }
338 
339 bool HcalNoiseAlgo::passTightRBXRechitR45(const CommonHcalNoiseRBXData& data) const {
340  int Count = data.r45Count();
341  double Fraction = data.r45Fraction();
342  double EnergyFraction = data.r45EnergyFraction();
343 
344  for (int i = 0; i + 3 < (int)tMinRBXRechitR45Cuts_.size(); i = i + 4) {
345  double Value = Count * tMinRBXRechitR45Cuts_[i] + Fraction * tMinRBXRechitR45Cuts_[i + 1] +
346  EnergyFraction * tMinRBXRechitR45Cuts_[i + 2] + tMinRBXRechitR45Cuts_[i + 3];
347  if (Value > 0)
348  return false;
349  }
350 
351  return true;
352 }
353 
354 bool HcalNoiseAlgo::passRatioThreshold(const CommonHcalNoiseRBXData& data) const {
355  return (data.energy() > minERatio_);
356 }
357 
358 bool HcalNoiseAlgo::passZerosThreshold(const CommonHcalNoiseRBXData& data) const {
359  return (data.energy() > minEZeros_);
360 }
361 
362 bool HcalNoiseAlgo::passEMFThreshold(const CommonHcalNoiseRBXData& data) const { return (data.energy() > minEEMF_); }
363 
364 void JoinCaloTowerRefVectorsWithoutDuplicates::operator()(edm::RefVector<CaloTowerCollection>& v1,
365  const edm::RefVector<CaloTowerCollection>& v2) const {
366  // combines them first into a set to get rid of duplicates and then puts them into the first vector
367 
368  // sorts them first to get rid of duplicates, then puts them into another RefVector
369  twrrefset_t twrrefset;
370  for (edm::RefVector<CaloTowerCollection>::const_iterator it = v1.begin(); it != v1.end(); ++it)
371  twrrefset.insert(*it);
372  for (edm::RefVector<CaloTowerCollection>::const_iterator it = v2.begin(); it != v2.end(); ++it)
373  twrrefset.insert(*it);
374 
375  // clear the original refvector and put them back in
376  v1.clear();
377  for (twrrefset_t::const_iterator it = twrrefset.begin(); it != twrrefset.end(); ++it) {
378  v1.push_back(*it);
379  }
380  return;
381 }
382 
383 bool CommonHcalNoiseRBXData::CheckPassFilter(double Charge,
384  double Discriminant,
385  std::vector<std::pair<double, double> >& Cuts,
386  int Side) {
387  //
388  // Checks whether Discriminant value passes Cuts for the specified Charge. True if pulse is good.
389  //
390  // The "Cuts" pairs are assumed to be sorted in terms of size from small to large,
391  // where each "pair" = (Charge, Discriminant)
392  // "Side" is either positive or negative, which determines whether to discard the pulse if discriminant
393  // is greater or smaller than the cut value
394  //
395 
396  if (Cuts.empty()) // safety check that there are some cuts defined
397  return true;
398 
399  if (Charge <= Cuts[0].first) // too small to cut on
400  return true;
401 
402  int IndexLargerThanCharge = -1; // find the range it is falling in
403  for (int i = 1; i < (int)Cuts.size(); i++) {
404  if (Cuts[i].first > Charge) {
405  IndexLargerThanCharge = i;
406  break;
407  }
408  }
409 
410  double limit = 1000000;
411 
412  if (IndexLargerThanCharge == -1) // if charge is greater than the last entry, assume flat line
413  limit = Cuts[Cuts.size() - 1].second;
414  else // otherwise, do a linear interpolation to find the cut position
415  {
416  double C1 = Cuts[IndexLargerThanCharge].first;
417  double C2 = Cuts[IndexLargerThanCharge - 1].first;
418  double L1 = Cuts[IndexLargerThanCharge].second;
419  double L2 = Cuts[IndexLargerThanCharge - 1].second;
420 
421  limit = (Charge - C1) / (C2 - C1) * (L2 - L1) + L1;
422  }
423 
424  if (Side > 0 && Discriminant > limit)
425  return false;
426  if (Side < 0 && Discriminant < limit)
427  return false;
428 
429  return true;
430 }
HcalNoiseAlgo::pMinRBXRechitR45Fraction_
double pMinRBXRechitR45Fraction_
Definition: HcalNoiseAlgo.h:137
PixelRegions::L1
Definition: PixelRegionContainers.h:27
reco::HcalNoiseRBX::totalZeros
int totalZeros(void) const
Definition: HcalNoiseRBX.cc:61
HcalNoiseAlgo::tMaxLowEHitTime_
double tMaxLowEHitTime_
Definition: HcalNoiseAlgo.h:163
HcalNoiseAlgo::lMaxHighEHitTime_
double lMaxHighEHitTime_
Definition: HcalNoiseAlgo.h:151
edm::RefVector::clear
void clear()
Clear the vector.
Definition: RefVector.h:142
HcalNoiseAlgo::pMaxLowEHitTime_
double pMaxLowEHitTime_
Definition: HcalNoiseAlgo.h:131
HcalNoiseAlgo::pMinLowEHitTime_
double pMinLowEHitTime_
Definition: HcalNoiseAlgo.h:130
HcalNoiseAlgo::tMinHPDHits_
int tMinHPDHits_
Definition: HcalNoiseAlgo.h:158
mps_fire.i
i
Definition: mps_fire.py:355
PixelRegions::L2
Definition: PixelRegionContainers.h:28
HcalNoiseAlgo::pMaxRBXEMF_
double pMaxRBXEMF_
Definition: HcalNoiseAlgo.h:135
HLT_2018_cff.minLowHitE
minLowHitE
Definition: HLT_2018_cff.py:48575
CommonHcalNoiseRBXData::CommonHcalNoiseRBXData
CommonHcalNoiseRBXData(const reco::HcalNoiseRBX &rbx, double minRecHitE, double minLowHitE, double minHighHitE, double TS4TS5EnergyThreshold, std::vector< std::pair< double, double > > &TS4TS5UpperCut, std::vector< std::pair< double, double > > &TS4TS5LowerCut, double MinRBXRechitR45E)
Definition: HcalNoiseAlgo.cc:3
reco::HcalNoiseRBX::numRecHits
int numRecHits(double threshold=1.5) const
Definition: HcalNoiseRBX.cc:110
CommonHcalNoiseRBXData::HPDEMF_
double HPDEMF_
Definition: HcalNoiseAlgo.h:68
CommonHcalNoiseRBXData::r45EnergyFraction_
double r45EnergyFraction_
Definition: HcalNoiseAlgo.h:74
HcalNoiseAlgo::pMaxRatio_
double pMaxRatio_
Definition: HcalNoiseAlgo.h:125
HcalNoiseAlgo::passTightNoiseFilter
bool passTightNoiseFilter(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:229
reco::HcalNoiseRBX::HPDsBegin
std::vector< HcalNoiseHPD >::const_iterator HPDsBegin(void) const
Definition: HcalNoiseRBX.h:57
HLT_2018_cff.minHighHitE
minHighHitE
Definition: HLT_2018_cff.py:48562
CommonHcalNoiseRBXData::r45Count_
int r45Count_
Definition: HcalNoiseAlgo.h:72
reco::HcalNoiseRBX::allChargeHighest2TS
float allChargeHighest2TS(unsigned int firstts=4) const
Definition: HcalNoiseRBX.cc:47
HcalNoiseAlgo::pMinERatio_
double pMinERatio_
Definition: HcalNoiseAlgo.h:112
edm::RefVector::begin
const_iterator begin() const
Initialize an iterator over the RefVector.
Definition: RefVector.h:223
CommonHcalNoiseRBXData::numHPDNoOtherHits_
int numHPDNoOtherHits_
Definition: HcalNoiseAlgo.h:58
join
static std::string join(char **cmd)
Definition: RemoteFile.cc:17
CommonHcalNoiseRBXData::highEHitTimeSqrd_
double highEHitTimeSqrd_
Definition: HcalNoiseAlgo.h:66
HcalNoiseAlgo::pMaxHPDEMF_
double pMaxHPDEMF_
Definition: HcalNoiseAlgo.h:134
HcalNoiseAlgo::passLooseNoiseFilter
bool passLooseNoiseFilter(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:224
HcalNoiseAlgo::passHighLevelNoiseFilter
bool passHighLevelNoiseFilter(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:234
HcalNoiseAlgo::hlMaxRBXEMF_
double hlMaxRBXEMF_
Definition: HcalNoiseAlgo.h:171
HcalNoiseAlgo::lMinHPDNoOtherHits_
int lMinHPDNoOtherHits_
Definition: HcalNoiseAlgo.h:146
reco::HcalNoiseRBX::allChargeTotal
float allChargeTotal(void) const
Definition: HcalNoiseRBX.cc:40
edm::RefVector
Definition: EDProductfwd.h:27
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:160
HcalNoiseAlgo::tMinZeros_
int tMinZeros_
Definition: HcalNoiseAlgo.h:161
reco::HcalNoiseRBX::recHitEnergyFailR45
double recHitEnergyFailR45(double threshold=1.5) const
Definition: HcalNoiseRBX.cc:83
JoinCaloTowerRefVectorsWithoutDuplicates
Definition: HcalNoiseAlgo.h:174
HcalNoiseAlgo::isProblematic
bool isProblematic(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:187
CommonHcalNoiseRBXData::minHighEHitTime_
double minHighEHitTime_
Definition: HcalNoiseAlgo.h:64
dqmdumpme.first
first
Definition: dqmdumpme.py:55
CommonHcalNoiseRBXData::numHPDHits_
int numHPDHits_
Definition: HcalNoiseAlgo.h:56
HcalNoiseAlgo::passLooseRatio
bool passLooseRatio(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:244
HcalNoiseAlgo::pMinRBXRechitR45Count_
int pMinRBXRechitR45Count_
Definition: HcalNoiseAlgo.h:136
HcalNoiseAlgo::passLooseRBXRechitR45
bool passLooseRBXRechitR45(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:284
reco::HcalNoiseRBX::allCharge
const std::vector< float > allCharge(void) const
Definition: HcalNoiseRBX.cc:38
CommonHcalNoiseRBXData::numRBXHits_
int numRBXHits_
Definition: HcalNoiseAlgo.h:57
CommonHcalNoiseRBXData::minLowEHitTime_
double minLowEHitTime_
Definition: HcalNoiseAlgo.h:60
HcalNoiseAlgo::lMinRatio_
double lMinRatio_
Definition: HcalNoiseAlgo.h:142
HcalNoiseAlgo::tMinRBXRechitR45Cuts_
std::vector< double > tMinRBXRechitR45Cuts_
Definition: HcalNoiseAlgo.h:166
CommonHcalNoiseRBXData::maxLowEHitTime_
double maxLowEHitTime_
Definition: HcalNoiseAlgo.h:61
JoinCaloTowerRefVectorsWithoutDuplicates::operator()
void operator()(edm::RefVector< CaloTowerCollection > &v1, const edm::RefVector< CaloTowerCollection > &v2) const
Definition: HcalNoiseAlgo.cc:364
CommonHcalNoiseRBXData::CheckPassFilter
bool CheckPassFilter(double Charge, double Discriminant, std::vector< std::pair< double, double > > &Cuts, int Side)
Definition: HcalNoiseAlgo.cc:383
CommonHcalNoiseRBXData::rbxtowers_
edm::RefVector< CaloTowerCollection > rbxtowers_
Definition: HcalNoiseAlgo.h:71
CommonHcalNoiseRBXData
Definition: HcalNoiseAlgo.h:11
CommonHcalNoiseRBXData::e10ts_
double e10ts_
Definition: HcalNoiseAlgo.h:55
HcalNoiseAlgo::pMinZeros_
int pMinZeros_
Definition: HcalNoiseAlgo.h:129
edm::RefVector::end
const_iterator end() const
Termination of iteration.
Definition: RefVector.h:228
HcalNoiseAlgo::tMinHighEHitTime_
double tMinHighEHitTime_
Definition: HcalNoiseAlgo.h:164
CommonHcalNoiseRBXData::maxHighEHitTime_
double maxHighEHitTime_
Definition: HcalNoiseAlgo.h:65
HLT_FULL_cff.Fraction
Fraction
Definition: HLT_FULL_cff.py:97567
CommonHcalNoiseRBXData::numHighEHits_
int numHighEHits_
Definition: HcalNoiseAlgo.h:67
HcalNoiseAlgo::tMaxRatio_
double tMaxRatio_
Definition: HcalNoiseAlgo.h:157
HcalNoiseAlgo::passLooseTiming
bool passLooseTiming(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:272
CommonHcalNoiseRBXData::RBXEMF_
double RBXEMF_
Definition: HcalNoiseAlgo.h:69
HcalNoiseAlgo::tMinLowEHitTime_
double tMinLowEHitTime_
Definition: HcalNoiseAlgo.h:162
reco::HcalNoiseRBX::caloTowerEmE
double caloTowerEmE(void) const
Definition: HcalNoiseRBX.cc:134
CommonHcalNoiseRBXData::numLowEHits_
int numLowEHits_
Definition: HcalNoiseAlgo.h:63
jetCorrFactors_cfi.emf
emf
the use of emf in the JEC is not yet implemented
Definition: jetCorrFactors_cfi.py:6
HcalNoiseAlgo::pMinRatio_
double pMinRatio_
Definition: HcalNoiseAlgo.h:124
HcalNoiseAlgo::lMinHighEHitTime_
double lMinHighEHitTime_
Definition: HcalNoiseAlgo.h:150
HcalNoiseAlgo::lMinRBXHits_
int lMinRBXHits_
Definition: HcalNoiseAlgo.h:145
edm::ParameterSet
Definition: ParameterSet.h:36
HcalNoiseAlgo::lMaxRatio_
double lMaxRatio_
Definition: HcalNoiseAlgo.h:143
HcalNoiseAlgo::pMaxHighEHitTime_
double pMaxHighEHitTime_
Definition: HcalNoiseAlgo.h:133
TrackInfoProducer_cfi.rechits
rechits
Definition: TrackInfoProducer_cfi.py:9
HcalNoiseAlgo::passLooseZeros
bool passLooseZeros(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:264
HcalNoiseAlgo::pMinEEMF_
double pMinEEMF_
Definition: HcalNoiseAlgo.h:114
HcalNoiseAlgo::passZerosThreshold
bool passZerosThreshold(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:358
HcalNoiseAlgo::minERatio_
double minERatio_
Definition: HcalNoiseAlgo.h:117
HcalNoiseAlgo::pMinHPDHits_
int pMinHPDHits_
Definition: HcalNoiseAlgo.h:126
createfilelist.int
int
Definition: createfilelist.py:10
CommonHcalNoiseRBXData::lowEHitTimeSqrd_
double lowEHitTimeSqrd_
Definition: HcalNoiseAlgo.h:62
CommonHcalNoiseRBXData::e2ts_
double e2ts_
Definition: HcalNoiseAlgo.h:54
HcalNoiseAlgo::minEZeros_
double minEZeros_
Definition: HcalNoiseAlgo.h:118
HcalNoiseAlgo::tMaxHighEHitTime_
double tMaxHighEHitTime_
Definition: HcalNoiseAlgo.h:165
CommonHcalNoiseRBXData::TS4TS5Decision_
bool TS4TS5Decision_
Definition: HcalNoiseAlgo.h:70
CommonHcalNoiseRBXData::energy
double energy(void) const
Definition: HcalNoiseAlgo.h:24
HcalNoiseAlgo::lMinRBXRechitR45Cuts_
std::vector< double > lMinRBXRechitR45Cuts_
Definition: HcalNoiseAlgo.h:152
JoinCaloTowerRefVectorsWithoutDuplicates::twrrefset_t
std::set< edm::Ref< CaloTowerCollection >, twrrefcomp > twrrefset_t
Definition: HcalNoiseAlgo.h:188
HcalNoiseAlgo::pMinHighEHitTime_
double pMinHighEHitTime_
Definition: HcalNoiseAlgo.h:132
edm::RefVector::push_back
void push_back(value_type const &ref)
Add a Ref<C, T> to the RefVector.
Definition: RefVector.h:67
HcalNoiseAlgo::passLooseHits
bool passLooseHits(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:254
HcalNoiseAlgo::lMaxLowEHitTime_
double lMaxLowEHitTime_
Definition: HcalNoiseAlgo.h:149
HcalNoiseAlgo::pMinEZeros_
double pMinEZeros_
Definition: HcalNoiseAlgo.h:113
HcalNoiseAlgo::passTightTiming
bool passTightTiming(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:327
CommonHcalNoiseRBXData::r45Fraction_
double r45Fraction_
Definition: HcalNoiseAlgo.h:73
HcalNoiseAlgo::passRatioThreshold
bool passRatioThreshold(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:354
HcalNoiseAlgo::passTightHits
bool passTightHits(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:309
SurfaceOrientation::Side
Side
Definition: Surface.h:18
HcalNoiseAlgo::tMinHPDNoOtherHits_
int tMinHPDNoOtherHits_
Definition: HcalNoiseAlgo.h:160
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
reco::HcalNoiseRBX::numRecHitsFailR45
int numRecHitsFailR45(double threshold=1.5) const
Definition: HcalNoiseRBX.cc:117
HcalNoiseAlgo::pMinRBXRechitR45EnergyFraction_
double pMinRBXRechitR45EnergyFraction_
Definition: HcalNoiseAlgo.h:138
HcalNoiseAlgo::passTightRatio
bool passTightRatio(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:299
HcalNoiseAlgo::lMinLowEHitTime_
double lMinLowEHitTime_
Definition: HcalNoiseAlgo.h:148
HcalNoiseAlgo::lMinHPDHits_
int lMinHPDHits_
Definition: HcalNoiseAlgo.h:144
remoteMonitoring_LED_IterMethod_cfg.limit
limit
Definition: remoteMonitoring_LED_IterMethod_cfg.py:427
HcalNoiseAlgo::pMinRBXHits_
int pMinRBXHits_
Definition: HcalNoiseAlgo.h:127
HLT_2018_cff.TS4TS5LowerCut
TS4TS5LowerCut
Definition: HLT_2018_cff.py:7043
reco::HcalNoiseRBX
Definition: HcalNoiseRBX.h:32
HcalNoiseAlgo::minEEMF_
double minEEMF_
Definition: HcalNoiseAlgo.h:119
edm::RefVectorIterator
Definition: EDProductfwd.h:33
HcalNoiseAlgo::pMinE_
double pMinE_
Definition: HcalNoiseAlgo.h:123
HLT_2018_cff.TS4TS5EnergyThreshold
TS4TS5EnergyThreshold
Definition: HLT_2018_cff.py:48559
PixelTestBeamValidation_cfi.Charge
Charge
Definition: PixelTestBeamValidation_cfi.py:78
HcalNoiseAlgo::lMinZeros_
int lMinZeros_
Definition: HcalNoiseAlgo.h:147
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
HcalNoiseAlgo::hlMaxHPDEMF_
double hlMaxHPDEMF_
Definition: HcalNoiseAlgo.h:170
HcalNoiseAlgo::tMinRBXHits_
int tMinRBXHits_
Definition: HcalNoiseAlgo.h:159
CommonHcalNoiseRBXData::energy_
double energy_
Definition: HcalNoiseAlgo.h:53
reco::JetExtendedAssociation::Value
reco::JetExtendedAssociation::JetExtendedData Value
Definition: JetExtendedAssociation.h:27
reco::HcalNoiseRBX::recHitEnergy
double recHitEnergy(double theshold=1.5) const
Definition: HcalNoiseRBX.cc:76
HcalNoiseAlgo::passTightRBXRechitR45
bool passTightRBXRechitR45(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:339
HcalNoiseAlgo::passEMFThreshold
bool passEMFThreshold(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:362
reco::HcalNoiseRBX::HPDsEnd
std::vector< HcalNoiseHPD >::const_iterator HPDsEnd(void) const
Definition: HcalNoiseRBX.h:58
CommonHcalNoiseRBXData::numZeros_
int numZeros_
Definition: HcalNoiseAlgo.h:59
ntuplemaker.time
time
Definition: ntuplemaker.py:310
HcalNoiseAlgo.h
HcalNoiseAlgo::tMinRatio_
double tMinRatio_
Definition: HcalNoiseAlgo.h:156
HLT_2018_cff.minRecHitE
minRecHitE
Definition: HLT_2018_cff.py:48549
HcalNoiseAlgo::passTightZeros
bool passTightZeros(const CommonHcalNoiseRBXData &) const
Definition: HcalNoiseAlgo.cc:319
HcalNoiseAlgo::HcalNoiseAlgo
HcalNoiseAlgo(const edm::ParameterSet &iConfig)
Definition: HcalNoiseAlgo.cc:111
HcalNoiseAlgo::pMinHPDNoOtherHits_
int pMinHPDNoOtherHits_
Definition: HcalNoiseAlgo.h:128
HLT_2018_cff.TS4TS5UpperCut
TS4TS5UpperCut
Definition: HLT_2018_cff.py:7059
Generated for CMSSW Reference Manual by doxygen 1.8.16