CMS 3D CMS Logo
CaloTowersCreator.cc
Go to the documentation of this file.
1 #include "RecoLocalCalo/CaloTowersCreator/src/CaloTowersCreator.h"
2 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
3 #include "FWCore/Framework/interface/ESHandle.h"
4 #include "Geometry/CaloTopology/interface/HcalTopology.h"
5 #include "Geometry/CaloTopology/interface/CaloTowerTopology.h"
6 // severity level for ECAL
7 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgoRcd.h"
8 #include "CommonTools/Utils/interface/StringToEnumValue.h"
9 
10 //#define EDM_ML_DEBUG
11 
12 CaloTowersCreator::CaloTowersCreator(const edm::ParameterSet& conf)
13  : algo_(conf.getParameter<double>("EBThreshold"),
14  conf.getParameter<double>("EEThreshold"),
15 
16  conf.getParameter<bool>("UseEtEBTreshold"),
17  conf.getParameter<bool>("UseEtEETreshold"),
18  conf.getParameter<bool>("UseSymEBTreshold"),
19  conf.getParameter<bool>("UseSymEETreshold"),
20 
21  conf.getParameter<double>("HcalThreshold"),
22  conf.getParameter<double>("HBThreshold"),
23  conf.getParameter<double>("HBThreshold1"),
24  conf.getParameter<double>("HBThreshold2"),
25  conf.getParameter<double>("HESThreshold"),
26  conf.getParameter<double>("HESThreshold1"),
27  conf.getParameter<double>("HEDThreshold"),
28  conf.getParameter<double>("HEDThreshold1"),
29  conf.getParameter<double>("HOThreshold0"),
30  conf.getParameter<double>("HOThresholdPlus1"),
31  conf.getParameter<double>("HOThresholdMinus1"),
32  conf.getParameter<double>("HOThresholdPlus2"),
33  conf.getParameter<double>("HOThresholdMinus2"),
34  conf.getParameter<double>("HF1Threshold"),
35  conf.getParameter<double>("HF2Threshold"),
36  conf.getParameter<std::vector<double> >("EBGrid"),
37  conf.getParameter<std::vector<double> >("EBWeights"),
38  conf.getParameter<std::vector<double> >("EEGrid"),
39  conf.getParameter<std::vector<double> >("EEWeights"),
40  conf.getParameter<std::vector<double> >("HBGrid"),
41  conf.getParameter<std::vector<double> >("HBWeights"),
42  conf.getParameter<std::vector<double> >("HESGrid"),
43  conf.getParameter<std::vector<double> >("HESWeights"),
44  conf.getParameter<std::vector<double> >("HEDGrid"),
45  conf.getParameter<std::vector<double> >("HEDWeights"),
46  conf.getParameter<std::vector<double> >("HOGrid"),
47  conf.getParameter<std::vector<double> >("HOWeights"),
48  conf.getParameter<std::vector<double> >("HF1Grid"),
49  conf.getParameter<std::vector<double> >("HF1Weights"),
50  conf.getParameter<std::vector<double> >("HF2Grid"),
51  conf.getParameter<std::vector<double> >("HF2Weights"),
52  conf.getParameter<double>("EBWeight"),
53  conf.getParameter<double>("EEWeight"),
54  conf.getParameter<double>("HBWeight"),
55  conf.getParameter<double>("HESWeight"),
56  conf.getParameter<double>("HEDWeight"),
57  conf.getParameter<double>("HOWeight"),
58  conf.getParameter<double>("HF1Weight"),
59  conf.getParameter<double>("HF2Weight"),
60  conf.getParameter<double>("EcutTower"),
61  conf.getParameter<double>("EBSumThreshold"),
62  conf.getParameter<double>("EESumThreshold"),
63  conf.getParameter<bool>("UseHO"),
64  // (for momentum reconstruction algorithm)
65  conf.getParameter<int>("MomConstrMethod"),
66  conf.getParameter<double>("MomHBDepth"),
67  conf.getParameter<double>("MomHEDepth"),
68  conf.getParameter<double>("MomEBDepth"),
69  conf.getParameter<double>("MomEEDepth"),
70  conf.getParameter<int>("HcalPhase")),
71 
72  ecalLabels_(conf.getParameter<std::vector<edm::InputTag> >("ecalInputs")),
73  allowMissingInputs_(conf.getParameter<bool>("AllowMissingInputs")),
74 
75  theHcalAcceptSeverityLevel_(conf.getParameter<unsigned int>("HcalAcceptSeverityLevel")),
76 
77  theRecoveredHcalHitsAreUsed_(conf.getParameter<bool>("UseHcalRecoveredHits")),
78  theRecoveredEcalHitsAreUsed_(conf.getParameter<bool>("UseEcalRecoveredHits")),
79 
80  // paramaters controlling the use of rejected hits
81 
82  useRejectedHitsOnly_(conf.getParameter<bool>("UseRejectedHitsOnly")),
83 
84  theHcalAcceptSeverityLevelForRejectedHit_(
85  conf.getParameter<unsigned int>("HcalAcceptSeverityLevelForRejectedHit")),
86 
87  useRejectedRecoveredHcalHits_(conf.getParameter<bool>("UseRejectedRecoveredHcalHits")),
88  useRejectedRecoveredEcalHits_(conf.getParameter<bool>("UseRejectedRecoveredEcalHits"))
89 
90 {
91  algo_.setMissingHcalRescaleFactorForEcal(conf.getParameter<double>("missingHcalRescaleFactorForEcal"));
92 
93  // register for data access
94  tok_hbhe_ = consumes<HBHERecHitCollection>(conf.getParameter<edm::InputTag>("hbheInput"));
95  tok_ho_ = consumes<HORecHitCollection>(conf.getParameter<edm::InputTag>("hoInput"));
96  tok_hf_ = consumes<HFRecHitCollection>(conf.getParameter<edm::InputTag>("hfInput"));
97  tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
98  tok_topo_ = esConsumes<HcalTopology, HcalRecNumberingRecord>();
99  tok_cttopo_ = esConsumes<CaloTowerTopology, HcalRecNumberingRecord>();
100  tok_ctmap_ = esConsumes<CaloTowerConstituentsMap, CaloGeometryRecord>();
101  tok_ecalChStatus_ = esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
102  tok_hcalChStatus_ = esConsumes<HcalChannelQuality, HcalChannelQualityRcd>(edm::ESInputTag("", "withTopo"));
103  tok_hcalSevComputer_ = esConsumes<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd>();
104  tok_ecalSevAlgo_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>();
105 
106  const unsigned nLabels = ecalLabels_.size();
107  for (unsigned i = 0; i != nLabels; i++)
108  toks_ecal_.push_back(consumes<EcalRecHitCollection>(ecalLabels_[i]));
109 
110  EBEScale = eScales_.EBScale;
111  EEEScale = eScales_.EEScale;
112  HBEScale = eScales_.HBScale;
113  HESEScale = eScales_.HESScale;
114  HEDEScale = eScales_.HEDScale;
115  HOEScale = eScales_.HOScale;
116  HF1EScale = eScales_.HF1Scale;
117  HF2EScale = eScales_.HF2Scale;
118 
119  // get the Ecal severities to be excluded
120  const std::vector<std::string> severitynames =
121  conf.getParameter<std::vector<std::string> >("EcalRecHitSeveritiesToBeExcluded");
122 
123  theEcalSeveritiesToBeExcluded_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynames);
124 
125  // get the Ecal severities to be used for bad towers
126  theEcalSeveritiesToBeUsedInBadTowers_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(
127  conf.getParameter<std::vector<std::string> >("EcalSeveritiesToBeUsedInBadTowers"));
128 
129  if (eScales_.instanceLabel.empty())
130  produces<CaloTowerCollection>();
131  else
132  produces<CaloTowerCollection>(eScales_.instanceLabel);
133 
134 #ifdef EDM_ML_DEBUG
135  std::cout << "VI Producer " << (useRejectedHitsOnly_ ? "use rejectOnly " : " ")
136  << (allowMissingInputs_ ? "allowMissing " : " ") << nLabels << ' ' << severitynames.size() << std::endl;
137 #endif
138 }
139 
140 void CaloTowersCreator::produce(edm::Event& e, const edm::EventSetup& c) {
141  // get the necessary event setup objects...
142  edm::ESHandle<CaloGeometry> pG = c.getHandle(tok_geom_);
143  edm::ESHandle<HcalTopology> htopo = c.getHandle(tok_topo_);
144  edm::ESHandle<CaloTowerTopology> cttopo = c.getHandle(tok_cttopo_);
145  edm::ESHandle<CaloTowerConstituentsMap> ctmap = c.getHandle(tok_ctmap_);
146 
147  // ECAL channel status map ****************************************
148  edm::ESHandle<EcalChannelStatus> ecalChStatus = c.getHandle(tok_ecalChStatus_);
149  const EcalChannelStatus* dbEcalChStatus = ecalChStatus.product();
150 
151  // HCAL channel status map ****************************************
152  edm::ESHandle<HcalChannelQuality> hcalChStatus = c.getHandle(tok_hcalChStatus_);
153 
154  const HcalChannelQuality* dbHcalChStatus = hcalChStatus.product();
155 
156  // Assignment of severity levels **********************************
157  edm::ESHandle<HcalSeverityLevelComputer> hcalSevLvlComputerHndl = c.getHandle(tok_hcalSevComputer_);
158  const HcalSeverityLevelComputer* hcalSevLvlComputer = hcalSevLvlComputerHndl.product();
159 
160  edm::ESHandle<EcalSeverityLevelAlgo> ecalSevLvlAlgoHndl = c.getHandle(tok_ecalSevAlgo_);
161  const EcalSeverityLevelAlgo* ecalSevLvlAlgo = ecalSevLvlAlgoHndl.product();
162 
163  algo_.setEBEScale(EBEScale);
164  algo_.setEEEScale(EEEScale);
165  algo_.setHBEScale(HBEScale);
166  algo_.setHESEScale(HESEScale);
167  algo_.setHEDEScale(HEDEScale);
168  algo_.setHOEScale(HOEScale);
169  algo_.setHF1EScale(HF1EScale);
170  algo_.setHF2EScale(HF2EScale);
171  algo_.setGeometry(cttopo.product(), ctmap.product(), htopo.product(), pG.product());
172 
173  // for treatment of problematic and anomalous cells
174 
175  algo_.setHcalChStatusFromDB(dbHcalChStatus);
176  algo_.setEcalChStatusFromDB(dbEcalChStatus);
177 
178  algo_.setHcalAcceptSeverityLevel(theHcalAcceptSeverityLevel_);
179  algo_.setEcalSeveritiesToBeExcluded(theEcalSeveritiesToBeExcluded_);
180 
181  algo_.setRecoveredHcalHitsAreUsed(theRecoveredHcalHitsAreUsed_);
182  algo_.setRecoveredEcalHitsAreUsed(theRecoveredEcalHitsAreUsed_);
183 
184  algo_.setHcalSevLvlComputer(hcalSevLvlComputer);
185  algo_.setEcalSevLvlAlgo(ecalSevLvlAlgo);
186 
187  algo_.setUseRejectedHitsOnly(useRejectedHitsOnly_);
188 
189  algo_.setHcalAcceptSeverityLevelForRejectedHit(theHcalAcceptSeverityLevelForRejectedHit_);
190  algo_.SetEcalSeveritiesToBeUsedInBadTowers(theEcalSeveritiesToBeUsedInBadTowers_);
191 
192  algo_.setUseRejectedRecoveredHcalHits(useRejectedRecoveredHcalHits_);
193  algo_.setUseRejectedRecoveredEcalHits(useRejectedRecoveredEcalHits_);
194 
195 #ifdef EDM_ML_DEBUG
196  std::cout << "VI Produce: " << (useRejectedHitsOnly_ ? "use rejectOnly " : " ")
197  << (allowMissingInputs_ ? "allowMissing " : " ")
198  << (theRecoveredEcalHitsAreUsed_ ? "use RecoveredEcal " : " ") << toks_ecal_.size() << ' '
199  << theEcalSeveritiesToBeExcluded_.size() << ' ' << theEcalSeveritiesToBeUsedInBadTowers_.size()
200  << std::endl;
201 #endif
202 
203  algo_.begin(); // clear the internal buffer
204 
205  // can't chain these in a big OR statement, or else it'll
206  // get triggered for each of the first three events
207  bool check1 = hcalSevLevelWatcher_.check(c);
208  bool check2 = hcalChStatusWatcher_.check(c);
209  bool check3 = caloTowerConstituentsWatcher_.check(c);
210  if (check1 || check2 || check3) {
211  algo_.makeHcalDropChMap();
212  }
213 
214  // check ecal SevLev
215  if (ecalSevLevelWatcher_.check(c))
216  algo_.makeEcalBadChs();
217 
218  // ----------------------------------------------------------
219  // For ecal error handling need to
220  // have access to the EB and EE collections at the end of
221  // tower reconstruction.
222 
223  edm::Handle<EcalRecHitCollection> ebHandle;
224  edm::Handle<EcalRecHitCollection> eeHandle;
225 
226  for (std::vector<edm::EDGetTokenT<EcalRecHitCollection> >::const_iterator i = toks_ecal_.begin();
227  i != toks_ecal_.end();
228  i++) {
229  edm::Handle<EcalRecHitCollection> ec_tmp;
230 
231  if (!e.getByToken(*i, ec_tmp))
232  continue;
233  if (ec_tmp->empty())
234  continue;
235 
236  // check if this is EB or EE
237  if ((ec_tmp->begin()->detid()).subdetId() == EcalBarrel) {
238  ebHandle = ec_tmp;
239  } else if ((ec_tmp->begin()->detid()).subdetId() == EcalEndcap) {
240  eeHandle = ec_tmp;
241  }
242  }
243 
244  algo_.setEbHandle(ebHandle);
245  algo_.setEeHandle(eeHandle);
246 
247  //-----------------------------------------------------------
248 
249  bool present;
250 
251  // Step A/C: Get Inputs and process (repeatedly)
252  edm::Handle<HBHERecHitCollection> hbhe;
253  present = e.getByToken(tok_hbhe_, hbhe);
254  if (present || !allowMissingInputs_)
255  algo_.process(*hbhe);
256 
257  edm::Handle<HORecHitCollection> ho;
258  present = e.getByToken(tok_ho_, ho);
259  if (present || !allowMissingInputs_)
260  algo_.process(*ho);
261 
262  edm::Handle<HFRecHitCollection> hf;
263  present = e.getByToken(tok_hf_, hf);
264  if (present || !allowMissingInputs_)
265  algo_.process(*hf);
266 
267  std::vector<edm::EDGetTokenT<EcalRecHitCollection> >::const_iterator i;
268  for (i = toks_ecal_.begin(); i != toks_ecal_.end(); i++) {
269  edm::Handle<EcalRecHitCollection> ec;
270  present = e.getByToken(*i, ec);
271  if (present || !allowMissingInputs_)
272  algo_.process(*ec);
273  }
274 
275  // Step B: Create empty output
276  auto prod = std::make_unique<CaloTowerCollection>();
277 
278  // Step C: Process
279  algo_.finish(*prod);
280 
281 #ifdef EDM_ML_DEBUG
282  int totc = 0;
283  float totE = 0;
284  reco::LeafCandidate::LorentzVector totP4;
285  for (auto const& tw : (*prod)) {
286  totc += tw.constituents().size();
287  totE += tw.energy();
288  totP4 += tw.p4();
289  std::cout << "CaloTowerCreator: " << tw.id() << " with E " << tw.energy() << " and " << tw.constituents().size()
290  << " constituents\n";
291  }
292  std::cout << "VI " << (*prod).size() << " " << totc << " " << totE << " " << totP4 << std::endl;
293 #endif
294 
295  // Step D: Put into the event
296  if (eScales_.instanceLabel.empty())
297  e.put(std::move(prod));
298  else
299  e.put(std::move(prod), eScales_.instanceLabel);
300 }
301 
302 void CaloTowersCreator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
303  edm::ParameterSetDescription desc;
304  desc.add<double>("EBSumThreshold", 0.2);
305  desc.add<double>("HF2Weight", 1.0);
306  desc.add<double>("EBWeight", 1.0);
307  desc.add<double>("EESumThreshold", 0.45);
308  desc.add<double>("HOThreshold0", 1.1);
309  desc.add<double>("HOThresholdPlus1", 3.5);
310  desc.add<double>("HOThresholdMinus1", 3.5);
311  desc.add<double>("HOThresholdPlus2", 3.5);
312  desc.add<double>("HOThresholdMinus2", 3.5);
313  desc.add<double>("HBThreshold", 0.7);
314  desc.add<double>("HBThreshold1", 0.7);
315  desc.add<double>("HBThreshold2", 0.7);
316  desc.add<double>("HF1Threshold", 0.5);
317  desc.add<double>("HEDWeight", 1.0);
318  desc.add<double>("EEWeight", 1.0);
319  desc.add<double>("HESWeight", 1.0);
320  desc.add<double>("HF1Weight", 1.0);
321  desc.add<double>("HOWeight", 1.0);
322  desc.add<double>("EBThreshold", 0.07);
323  desc.add<double>("EEThreshold", 0.3);
324  desc.add<double>("HcalThreshold", -1000.0);
325  desc.add<double>("HF2Threshold", 0.85);
326  desc.add<double>("HESThreshold", 0.8);
327  desc.add<double>("HESThreshold1", 0.8);
328  desc.add<double>("HEDThreshold", 0.8);
329  desc.add<double>("HEDThreshold1", 0.8);
330  desc.add<double>("EcutTower", -1000.0);
331  desc.add<double>("HBWeight", 1.0);
332  desc.add<double>("MomHBDepth", 0.2);
333  desc.add<double>("MomHEDepth", 0.4);
334  desc.add<double>("MomEBDepth", 0.3);
335  desc.add<double>("MomEEDepth", 0.0);
336  desc.add<bool>("UseHO", true);
337  desc.add<bool>("UseEtEBTreshold", false);
338  desc.add<bool>("UseSymEBTreshold", true);
339  desc.add<bool>("UseEtEETreshold", false);
340  desc.add<bool>("UseSymEETreshold", true);
341  desc.add<bool>("UseHcalRecoveredHits", true);
342  desc.add<bool>("UseEcalRecoveredHits", false);
343  desc.add<bool>("UseRejectedHitsOnly", false);
344  desc.add<bool>("UseRejectedRecoveredHcalHits", true);
345  desc.add<bool>("UseRejectedRecoveredEcalHits", false);
346  desc.add<double>("missingHcalRescaleFactorForEcal", 0.0);
347  desc.add<bool>("AllowMissingInputs", false);
348  desc.add<std::vector<double> >("HBGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
349  desc.add<std::vector<double> >("EEWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
350  desc.add<std::vector<double> >("HF2Weights", {1.0, 1.0, 1.0, 1.0, 1.0});
351  desc.add<std::vector<double> >("HOWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
352  desc.add<std::vector<double> >("EEGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
353  desc.add<std::vector<double> >("HBWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
354  desc.add<std::vector<double> >("HF2Grid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
355  desc.add<std::vector<double> >("HEDWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
356  desc.add<std::vector<double> >("HF1Grid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
357  desc.add<std::vector<double> >("EBWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
358  desc.add<std::vector<double> >("HF1Weights", {1.0, 1.0, 1.0, 1.0, 1.0});
359  desc.add<std::vector<double> >("HESGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
360  desc.add<std::vector<double> >("HESWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
361  desc.add<std::vector<double> >("HEDGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
362  desc.add<std::vector<double> >("HOGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
363  desc.add<std::vector<double> >("EBGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
364  desc.add<edm::InputTag>("hfInput", edm::InputTag("hfreco"));
365  desc.add<edm::InputTag>("hbheInput", edm::InputTag("hbhereco"));
366  desc.add<edm::InputTag>("hoInput", edm::InputTag("horeco"));
367  desc.add<std::vector<edm::InputTag> >(
368  "ecalInputs", {edm::InputTag("ecalRecHit", "EcalRecHitsEB"), edm::InputTag("ecalRecHit", "EcalRecHitsEE")});
369  desc.add<int>("MomConstrMethod", 1);
370  desc.add<unsigned int>("HcalAcceptSeverityLevel", 9);
371  desc.add<std::vector<std::string> >("EcalRecHitSeveritiesToBeExcluded", {"kTime", "kWeird", "kBad"});
372  desc.add<unsigned int>("HcalAcceptSeverityLevelForRejectedHit", 9999);
373  desc.add<std::vector<std::string> >("EcalSeveritiesToBeUsedInBadTowers", {});
374  desc.add<int>("HcalPhase", 0);
375 
376  descriptions.addDefault(desc);
377 }
edm::ESWatcher::check
bool check(const edm::EventSetup &iSetup)
Definition: ESWatcher.h:52
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
EcalSeverityLevelAlgo
Definition: EcalSeverityLevelAlgo.h:33
CaloTowersCreator::hcalSevLevelWatcher_
edm::ESWatcher< HcalSeverityLevelComputerRcd > hcalSevLevelWatcher_
Definition: CaloTowersCreator.h:80
CaloTowersCreator::produce
void produce(edm::Event &e, const edm::EventSetup &c) override
Definition: CaloTowersCreator.cc:140
CaloTowersCreationAlgo::setEcalChStatusFromDB
void setEcalChStatusFromDB(const EcalChannelStatus *s)
Definition: CaloTowersCreationAlgo.h:164
electrons_cff.bool
bool
Definition: electrons_cff.py:393
mps_fire.i
i
Definition: mps_fire.py:428
CaloTowersCreationAlgo::setHF1EScale
void setHF1EScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1383
edm::ESInputTag
Definition: ESInputTag.h:87
CaloTowersCreator::theRecoveredHcalHitsAreUsed_
bool theRecoveredHcalHitsAreUsed_
Definition: CaloTowersCreator.h:62
CaloTowersCreationAlgo::setRecoveredHcalHitsAreUsed
void setRecoveredHcalHitsAreUsed(bool flag)
Definition: CaloTowersCreationAlgo.h:209
CaloTowersCreator::EEEScale
double EEEScale
Definition: CaloTowersCreator.h:33
ESHandle.h
CaloTowersCreationAlgo::setGeometry
void setGeometry(const CaloTowerTopology *cttopo, const CaloTowerConstituentsMap *ctmap, const HcalTopology *htopo, const CaloGeometry *geo)
Definition: CaloTowersCreationAlgo.cc:354
CaloTowersCreationAlgo::finish
void finish(CaloTowerCollection &destCollection)
Definition: CaloTowersCreationAlgo.cc:404
CaloTowersCreationAlgo::setHOEScale
void setHOEScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1376
EcalSeverityLevelAlgoRcd.h
CaloTowersCreator::ecalSevLevelWatcher_
edm::ESWatcher< EcalSeverityLevelAlgoRcd > ecalSevLevelWatcher_
Definition: CaloTowersCreator.h:83
edm::EDGetTokenT
Definition: EDGetToken.h:33
CaloTowersCreator::eScales_
EScales eScales_
Definition: CaloTowersCreator.h:84
CaloTowersCreator::useRejectedRecoveredEcalHits_
bool useRejectedRecoveredEcalHits_
Definition: CaloTowersCreator.h:78
CaloTowersCreationAlgo::setEcalSevLvlAlgo
void setEcalSevLvlAlgo(const EcalSeverityLevelAlgo *a)
Definition: CaloTowersCreationAlgo.h:216
edm
HLT enums.
Definition: AlignableModifier.h:19
EScales::instanceLabel
std::string instanceLabel
Definition: EScales.h:21
CaloTowersCreator::tok_ecalSevAlgo_
edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd > tok_ecalSevAlgo_
Definition: CaloTowersCreator.h:54
CaloTowersCreator::CaloTowersCreator
CaloTowersCreator(const edm::ParameterSet &ps)
Definition: CaloTowersCreator.cc:12
CaloTowersCreator::EBEScale
double EBEScale
Definition: CaloTowersCreator.h:33
gather_cfg.cout
cout
Definition: gather_cfg.py:144
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89353
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
CaloTowersCreator::tok_topo_
edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > tok_topo_
Definition: CaloTowersCreator.h:48
CaloTowersCreationAlgo::setHF2EScale
void setHF2EScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1390
HcalChannelQuality
Definition: HcalChannelQuality.h:17
CaloTowersCreator::algo_
CaloTowersCreationAlgo algo_
Definition: CaloTowersCreator.h:39
CaloTowersCreator::tok_hcalChStatus_
edm::ESGetToken< HcalChannelQuality, HcalChannelQualityRcd > tok_hcalChStatus_
Definition: CaloTowersCreator.h:52
CaloTowersCreator::tok_ecalChStatus_
edm::ESGetToken< EcalChannelStatus, EcalChannelStatusRcd > tok_ecalChStatus_
Definition: CaloTowersCreator.h:51
EcalCondObjectContainer
Definition: EcalCondObjectContainer.h:13
edm::Handle
Definition: AssociativeIterator.h:50
CaloTowersCreationAlgo::setUseRejectedRecoveredEcalHits
void setUseRejectedRecoveredEcalHits(bool flag)
Definition: CaloTowersCreationAlgo.h:233
EcalBarrel
Definition: EcalSubdetector.h:10
EScales::HBScale
double HBScale
Definition: EScales.h:15
CaloTowersCreationAlgo::setHBEScale
void setHBEScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1355
CaloTowersCreator::HEDEScale
double HEDEScale
Definition: CaloTowersCreator.h:34
CaloTowersCreator::HESEScale
double HESEScale
Definition: CaloTowersCreator.h:33
CaloTowersCreationAlgo::begin
void begin()
Definition: CaloTowersCreationAlgo.cc:368
CaloTowersCreator::theEcalSeveritiesToBeExcluded_
std::vector< int > theEcalSeveritiesToBeExcluded_
Definition: CaloTowersCreator.h:59
EScales::HESScale
double HESScale
Definition: EScales.h:16
photonIsolationHIProducer_cfi.hf
hf
Definition: photonIsolationHIProducer_cfi.py:9
EScales::EBScale
double EBScale
Definition: EScales.h:13
CaloTowersCreationAlgo::makeEcalBadChs
void makeEcalBadChs()
Definition: CaloTowersCreationAlgo.cc:1710
CaloTowersCreator::tok_hbhe_
edm::EDGetTokenT< HBHERecHitCollection > tok_hbhe_
Definition: CaloTowersCreator.h:40
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:262
CaloTowersCreator::tok_ctmap_
edm::ESGetToken< CaloTowerConstituentsMap, CaloGeometryRecord > tok_ctmap_
Definition: CaloTowersCreator.h:50
CaloTowersCreationAlgo::setEeHandle
void setEeHandle(const edm::Handle< EcalRecHitCollection > ee)
Definition: CaloTowersCreationAlgo.h:241
CaloTowersCreator::tok_ho_
edm::EDGetTokenT< HORecHitCollection > tok_ho_
Definition: CaloTowersCreator.h:41
HcalSeverityLevelComputer
Definition: HcalSeverityLevelComputer.h:24
dumpMFGeometry_cfg.prod
prod
Definition: dumpMFGeometry_cfg.py:24
edm::ESHandle< CaloGeometry >
CaloTowersCreationAlgo::SetEcalSeveritiesToBeUsedInBadTowers
void SetEcalSeveritiesToBeUsedInBadTowers(const std::vector< int > &ecalSev)
Definition: CaloTowersCreationAlgo.h:228
CaloTowersCreator::HF1EScale
double HF1EScale
Definition: CaloTowersCreator.h:34
StringToEnumValue.h
CaloTowersCreationAlgo::setEcalSeveritiesToBeExcluded
void setEcalSeveritiesToBeExcluded(const std::vector< int > &ecalSev)
Definition: CaloTowersCreationAlgo.h:206
CaloTowerTopology.h
CaloTowersCreationAlgo::setHcalChStatusFromDB
void setHcalChStatusFromDB(const HcalChannelQuality *s)
Definition: CaloTowersCreationAlgo.h:163
CaloTowersCreator::toks_ecal_
std::vector< edm::EDGetTokenT< EcalRecHitCollection > > toks_ecal_
Definition: CaloTowersCreator.h:44
CaloTowersCreator::useRejectedHitsOnly_
bool useRejectedHitsOnly_
Definition: CaloTowersCreator.h:67
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
EcalEndcap
Definition: EcalSubdetector.h:10
CaloTowersCreator::tok_hcalSevComputer_
edm::ESGetToken< HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd > tok_hcalSevComputer_
Definition: CaloTowersCreator.h:53
CaloTowersCreationAlgo::setHEDEScale
void setHEDEScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1369
CaloTowersCreationAlgo::setHcalSevLvlComputer
void setHcalSevLvlComputer(const HcalSeverityLevelComputer *c)
Definition: CaloTowersCreationAlgo.h:213
EScales::HF2Scale
double HF2Scale
Definition: EScales.h:20
CaloTowersCreationAlgo::setRecoveredEcalHitsAreUsed
void setRecoveredEcalHitsAreUsed(bool flag)
Definition: CaloTowersCreationAlgo.h:210
CaloTowersCreationAlgo::setEEEScale
void setEEEScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1348
CaloTowersCreator::tok_geom_
edm::ESGetToken< CaloGeometry, CaloGeometryRecord > tok_geom_
Definition: CaloTowersCreator.h:47
edm::ParameterSet
Definition: ParameterSet.h:47
EScales::EEScale
double EEScale
Definition: EScales.h:14
CaloTowersCreationAlgo::setHcalAcceptSeverityLevel
void setHcalAcceptSeverityLevel(unsigned int level)
Definition: CaloTowersCreationAlgo.h:205
CaloTowersCreationAlgo::process
void process(const HBHERecHitCollection &hbhe)
Definition: CaloTowersCreationAlgo.cc:374
CaloTowersCreationAlgo::makeHcalDropChMap
void makeHcalDropChMap()
Definition: CaloTowersCreationAlgo.cc:1649
createfilelist.int
int
Definition: createfilelist.py:10
CaloTowersCreationAlgo::setHcalAcceptSeverityLevelForRejectedHit
void setHcalAcceptSeverityLevelForRejectedHit(unsigned int level)
Definition: CaloTowersCreationAlgo.h:224
trackerHitRTTI::vector
Definition: trackerHitRTTI.h:21
photonIsolationHIProducer_cfi.ho
ho
Definition: photonIsolationHIProducer_cfi.py:10
CaloTowersCreator::HBEScale
double HBEScale
Definition: CaloTowersCreator.h:33
edm::EventSetup
Definition: EventSetup.h:57
CaloTowersCreator::hcalChStatusWatcher_
edm::ESWatcher< HcalChannelQualityRcd > hcalChStatusWatcher_
Definition: CaloTowersCreator.h:81
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
CaloTowersCreator::useRejectedRecoveredHcalHits_
bool useRejectedRecoveredHcalHits_
Definition: CaloTowersCreator.h:77
photonIsolationHIProducer_cfi.hbhe
hbhe
Definition: photonIsolationHIProducer_cfi.py:8
CaloTowersCreationAlgo::setMissingHcalRescaleFactorForEcal
void setMissingHcalRescaleFactorForEcal(float factor)
Definition: CaloTowersCreationAlgo.h:234
CaloTowersCreationAlgo::setEbHandle
void setEbHandle(const edm::Handle< EcalRecHitCollection > eb)
Definition: CaloTowersCreationAlgo.h:240
CaloTowersCreator.h
CaloTowersCreator::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: CaloTowersCreator.cc:302
HcalTopology.h
CaloTowersCreator::theHcalAcceptSeverityLevel_
unsigned int theHcalAcceptSeverityLevel_
Definition: CaloTowersCreator.h:58
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
CaloTowersCreator::caloTowerConstituentsWatcher_
edm::ESWatcher< IdealGeometryRecord > caloTowerConstituentsWatcher_
Definition: CaloTowersCreator.h:82
eostools.move
def move(src, dest)
Definition: eostools.py:511
std
Definition: JetResolutionObject.h:76
CaloTowersCreator::HF2EScale
double HF2EScale
Definition: CaloTowersCreator.h:34
CaloTowersCreator::theHcalAcceptSeverityLevelForRejectedHit_
unsigned int theHcalAcceptSeverityLevelForRejectedHit_
Definition: CaloTowersCreator.h:68
EScales::HF1Scale
double HF1Scale
Definition: EScales.h:19
CaloTowersCreator::allowMissingInputs_
bool allowMissingInputs_
Definition: CaloTowersCreator.h:45
CaloGeometry.h
CaloTowersCreationAlgo::setEBEScale
void setEBEScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1341
EScales::HEDScale
double HEDScale
Definition: EScales.h:17
CaloTowersCreator::tok_hf_
edm::EDGetTokenT< HFRecHitCollection > tok_hf_
Definition: CaloTowersCreator.h:42
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
CaloTowersCreationAlgo::setUseRejectedHitsOnly
void setUseRejectedHitsOnly(bool flag)
Definition: CaloTowersCreationAlgo.h:222
CaloTowersCreator::theEcalSeveritiesToBeUsedInBadTowers_
std::vector< int > theEcalSeveritiesToBeUsedInBadTowers_
Definition: CaloTowersCreator.h:70
CaloTowersCreationAlgo::setHESEScale
void setHESEScale(double scale)
Definition: CaloTowersCreationAlgo.cc:1362
EScales::HOScale
double HOScale
Definition: EScales.h:18
CaloTowersCreationAlgo::setUseRejectedRecoveredHcalHits
void setUseRejectedRecoveredHcalHits(bool flag)
Definition: CaloTowersCreationAlgo.h:232
edm::Event
Definition: Event.h:73
edm::ConfigurationDescriptions::addDefault
void addDefault(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:99
CaloTowersCreator::ecalLabels_
std::vector< edm::InputTag > ecalLabels_
Definition: CaloTowersCreator.h:43
edm::InputTag
Definition: InputTag.h:15
CaloTowersCreator::HOEScale
double HOEScale
Definition: CaloTowersCreator.h:34
CaloTowersCreator::tok_cttopo_
edm::ESGetToken< CaloTowerTopology, HcalRecNumberingRecord > tok_cttopo_
Definition: CaloTowersCreator.h:49
CaloTowersCreator::theRecoveredEcalHitsAreUsed_
bool theRecoveredEcalHitsAreUsed_
Definition: CaloTowersCreator.h:63
reco::LeafCandidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: LeafCandidate.h:23
edm::SortedCollection::empty
bool empty() const
Definition: SortedCollection.h:210
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Generated for CMSSW Reference Manual by doxygen 1.8.16