CMS 3D CMS Logo
EcalRecHitProducer.cc
Go to the documentation of this file.
1 
7 #include "RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducer.h"
8 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalCleaningAlgo.h"
9 #include "DataFormats/Common/interface/Handle.h"
10 #include "FWCore/Framework/interface/ESHandle.h"
11 
12 #include "FWCore/MessageLogger/interface/MessageLogger.h"
13 
14 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
15 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
16 #include "DataFormats/EcalDetId/interface/EBDetId.h"
17 #include "DataFormats/EcalDetId/interface/EEDetId.h"
18 #include "DataFormats/EcalDetId/interface/EcalElectronicsId.h"
19 #include "DataFormats/EcalDetId/interface/EcalTrigTowerDetId.h"
20 #include "DataFormats/EcalDetId/interface/EcalScDetId.h"
21 
22 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
23 #include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
24 
25 #include "RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerFactory.h"
26 
27 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
28 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
29 
30 EcalRecHitProducer::EcalRecHitProducer(const edm::ParameterSet& ps) {
31  ebRechitCollection_ = ps.getParameter<std::string>("EBrechitCollection");
32  eeRechitCollection_ = ps.getParameter<std::string>("EErechitCollection");
33 
34  recoverEBIsolatedChannels_ = ps.getParameter<bool>("recoverEBIsolatedChannels");
35  recoverEEIsolatedChannels_ = ps.getParameter<bool>("recoverEEIsolatedChannels");
36  recoverEBVFE_ = ps.getParameter<bool>("recoverEBVFE");
37  recoverEEVFE_ = ps.getParameter<bool>("recoverEEVFE");
38  recoverEBFE_ = ps.getParameter<bool>("recoverEBFE");
39  recoverEEFE_ = ps.getParameter<bool>("recoverEEFE");
40  killDeadChannels_ = ps.getParameter<bool>("killDeadChannels");
41 
42  produces<EBRecHitCollection>(ebRechitCollection_);
43  produces<EERecHitCollection>(eeRechitCollection_);
44 
45  ebUncalibRecHitToken_ =
46  consumes<EBUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EBuncalibRecHitCollection"));
47 
48  eeUncalibRecHitToken_ =
49  consumes<EEUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EEuncalibRecHitCollection"));
50 
51  ebDetIdToBeRecoveredToken_ = consumes<std::set<EBDetId>>(ps.getParameter<edm::InputTag>("ebDetIdToBeRecovered"));
52 
53  eeDetIdToBeRecoveredToken_ = consumes<std::set<EEDetId>>(ps.getParameter<edm::InputTag>("eeDetIdToBeRecovered"));
54 
55  ebFEToBeRecoveredToken_ = consumes<std::set<EcalTrigTowerDetId>>(ps.getParameter<edm::InputTag>("ebFEToBeRecovered"));
56 
57  eeFEToBeRecoveredToken_ = consumes<std::set<EcalScDetId>>(ps.getParameter<edm::InputTag>("eeFEToBeRecovered"));
58 
59  std::string componentType = ps.getParameter<std::string>("algo");
60  edm::ConsumesCollector c{consumesCollector()};
61  worker_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
62 
63  // to recover problematic channels
64  componentType = ps.getParameter<std::string>("algoRecover");
65  workerRecover_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
66 
67  edm::ParameterSet cleaningPs = ps.getParameter<edm::ParameterSet>("cleaningConfig");
68  cleaningAlgo_ = std::make_unique<EcalCleaningAlgo>(cleaningPs);
69 }
70 
71 EcalRecHitProducer::~EcalRecHitProducer() = default;
72 
73 void EcalRecHitProducer::produce(edm::Event& evt, const edm::EventSetup& es) {
74  using namespace edm;
75 
76  Handle<EBUncalibratedRecHitCollection> pEBUncalibRecHits;
77  Handle<EEUncalibratedRecHitCollection> pEEUncalibRecHits;
78 
79  const EBUncalibratedRecHitCollection* ebUncalibRecHits = nullptr;
80  const EEUncalibratedRecHitCollection* eeUncalibRecHits = nullptr;
81 
82  // get the barrel uncalib rechit collection
83 
84  evt.getByToken(ebUncalibRecHitToken_, pEBUncalibRecHits);
85  ebUncalibRecHits = pEBUncalibRecHits.product();
86  LogDebug("EcalRecHitDebug") << "total # EB uncalibrated rechits: " << ebUncalibRecHits->size();
87 
88  evt.getByToken(eeUncalibRecHitToken_, pEEUncalibRecHits);
89  eeUncalibRecHits = pEEUncalibRecHits.product(); // get a ptr to the product
90  LogDebug("EcalRecHitDebug") << "total # EE uncalibrated rechits: " << eeUncalibRecHits->size();
91 
92  // collection of rechits to put in the event
93  auto ebRecHits = std::make_unique<EBRecHitCollection>();
94  auto eeRecHits = std::make_unique<EERecHitCollection>();
95 
96  worker_->set(es);
97 
98  if (recoverEBIsolatedChannels_ || recoverEEIsolatedChannels_ || recoverEBFE_ || recoverEEFE_ || recoverEBVFE_ ||
99  recoverEEVFE_ || killDeadChannels_) {
100  workerRecover_->set(es);
101  }
102 
103  if (ebUncalibRecHits) {
104  // loop over uncalibrated rechits to make calibrated ones
105  for (EBUncalibratedRecHitCollection::const_iterator it = ebUncalibRecHits->begin(); it != ebUncalibRecHits->end();
106  ++it) {
107  worker_->run(evt, *it, *ebRecHits);
108  }
109  }
110 
111  if (eeUncalibRecHits) {
112  // loop over uncalibrated rechits to make calibrated ones
113  for (EEUncalibratedRecHitCollection::const_iterator it = eeUncalibRecHits->begin(); it != eeUncalibRecHits->end();
114  ++it) {
115  worker_->run(evt, *it, *eeRecHits);
116  }
117  }
118 
119  // sort collections before attempting recovery, to avoid insertion of double recHits
120  ebRecHits->sort();
121  eeRecHits->sort();
122 
123  if (recoverEBIsolatedChannels_ || recoverEBFE_ || killDeadChannels_) {
124  edm::Handle<std::set<EBDetId>> pEBDetId;
125  const std::set<EBDetId>* detIds = nullptr;
126  evt.getByToken(ebDetIdToBeRecoveredToken_, pEBDetId);
127  detIds = pEBDetId.product();
128 
129  if (detIds) {
130  edm::ESHandle<EcalChannelStatus> chStatus;
131  es.get<EcalChannelStatusRcd>().get(chStatus);
132  for (std::set<EBDetId>::const_iterator it = detIds->begin(); it != detIds->end(); ++it) {
133  // get channel status map to treat dead VFE separately
134  EcalChannelStatusMap::const_iterator chit = chStatus->find(*it);
135  EcalChannelStatusCode chStatusCode;
136  if (chit != chStatus->end()) {
137  chStatusCode = *chit;
138  } else {
139  edm::LogError("EcalRecHitProducerError") << "No channel status found for xtal " << (*it).rawId()
140  << "! something wrong with EcalChannelStatus in your DB? ";
141  }
142  EcalUncalibratedRecHit urh;
143  if (chStatusCode.getStatusCode() == EcalChannelStatusCode::kDeadVFE) { // dead VFE (from DB info)
144  // uses the EcalUncalibratedRecHit to pass the DetId info
145  urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_VFE);
146  if (recoverEBVFE_ || killDeadChannels_)
147  workerRecover_->run(evt, urh, *ebRecHits);
148  } else {
149  // uses the EcalUncalibratedRecHit to pass the DetId info
150  urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_single);
151  if (recoverEBIsolatedChannels_ || killDeadChannels_)
152  workerRecover_->run(evt, urh, *ebRecHits);
153  }
154  }
155  }
156  }
157 
158  if (recoverEEIsolatedChannels_ || recoverEEVFE_ || killDeadChannels_) {
159  edm::Handle<std::set<EEDetId>> pEEDetId;
160  const std::set<EEDetId>* detIds = nullptr;
161 
162  evt.getByToken(eeDetIdToBeRecoveredToken_, pEEDetId);
163  detIds = pEEDetId.product();
164 
165  if (detIds) {
166  edm::ESHandle<EcalChannelStatus> chStatus;
167  es.get<EcalChannelStatusRcd>().get(chStatus);
168  for (std::set<EEDetId>::const_iterator it = detIds->begin(); it != detIds->end(); ++it) {
169  // get channel status map to treat dead VFE separately
170  EcalChannelStatusMap::const_iterator chit = chStatus->find(*it);
171  EcalChannelStatusCode chStatusCode;
172  if (chit != chStatus->end()) {
173  chStatusCode = *chit;
174  } else {
175  edm::LogError("EcalRecHitProducerError") << "No channel status found for xtal " << (*it).rawId()
176  << "! something wrong with EcalChannelStatus in your DB? ";
177  }
178  EcalUncalibratedRecHit urh;
179  if (chStatusCode.getStatusCode() == EcalChannelStatusCode::kDeadVFE) { // dead VFE (from DB info)
180  // uses the EcalUncalibratedRecHit to pass the DetId info
181  urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_VFE);
182  if (recoverEEVFE_ || killDeadChannels_)
183  workerRecover_->run(evt, urh, *eeRecHits);
184  } else {
185  // uses the EcalUncalibratedRecHit to pass the DetId info
186  urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_single);
187  if (recoverEEIsolatedChannels_ || killDeadChannels_)
188  workerRecover_->run(evt, urh, *eeRecHits);
189  }
190  }
191  }
192  }
193 
194  if (recoverEBFE_ || killDeadChannels_) {
195  edm::Handle<std::set<EcalTrigTowerDetId>> pEBFEId;
196  const std::set<EcalTrigTowerDetId>* ttIds = nullptr;
197 
198  evt.getByToken(ebFEToBeRecoveredToken_, pEBFEId);
199  ttIds = pEBFEId.product();
200 
201  if (ttIds) {
202  for (std::set<EcalTrigTowerDetId>::const_iterator it = ttIds->begin(); it != ttIds->end(); ++it) {
203  // uses the EcalUncalibratedRecHit to pass the DetId info
204  int ieta = (((*it).ietaAbs() - 1) * 5 + 1) * (*it).zside(); // from EcalTrigTowerConstituentsMap
205  int iphi = (((*it).iphi() - 1) * 5 + 11) % 360; // from EcalTrigTowerConstituentsMap
206  if (iphi <= 0)
207  iphi += 360; // from EcalTrigTowerConstituentsMap
208  EcalUncalibratedRecHit urh(
209  EBDetId(ieta, iphi, EBDetId::ETAPHIMODE), 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_FE);
210  workerRecover_->run(evt, urh, *ebRecHits);
211  }
212  }
213  }
214 
215  if (recoverEEFE_ || killDeadChannels_) {
216  edm::Handle<std::set<EcalScDetId>> pEEFEId;
217  const std::set<EcalScDetId>* scIds = nullptr;
218 
219  evt.getByToken(eeFEToBeRecoveredToken_, pEEFEId);
220  scIds = pEEFEId.product();
221 
222  if (scIds) {
223  for (std::set<EcalScDetId>::const_iterator it = scIds->begin(); it != scIds->end(); ++it) {
224  // uses the EcalUncalibratedRecHit to pass the DetId info
225  if (EEDetId::validDetId(((*it).ix() - 1) * 5 + 1, ((*it).iy() - 1) * 5 + 1, (*it).zside())) {
226  EcalUncalibratedRecHit urh(EEDetId(((*it).ix() - 1) * 5 + 1, ((*it).iy() - 1) * 5 + 1, (*it).zside()),
227  0,
228  0,
229  0,
230  0,
231  EcalRecHitWorkerBaseClass::EE_FE);
232  workerRecover_->run(evt, urh, *eeRecHits);
233  }
234  }
235  }
236  }
237 
238  // without re-sorting, find (used below in cleaning) will lead
239  // to undefined results
240  ebRecHits->sort();
241  eeRecHits->sort();
242 
243  // apply spike cleaning
244  if (cleaningAlgo_) {
245  cleaningAlgo_->setFlags(*ebRecHits);
246  cleaningAlgo_->setFlags(*eeRecHits);
247  }
248 
249  // put the collection of recunstructed hits in the event
250  LogInfo("EcalRecHitInfo") << "total # EB calibrated rechits: " << ebRecHits->size();
251  LogInfo("EcalRecHitInfo") << "total # EE calibrated rechits: " << eeRecHits->size();
252 
253  evt.put(std::move(ebRecHits), ebRechitCollection_);
254  evt.put(std::move(eeRecHits), eeRechitCollection_);
255 }
256 
257 void EcalRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
258  edm::ParameterSetDescription desc;
259  desc.add<bool>("recoverEEVFE", false);
260  desc.add<std::string>("EErechitCollection", "EcalRecHitsEE");
261  desc.add<bool>("recoverEBIsolatedChannels", false);
262  desc.add<bool>("recoverEBVFE", false);
263  desc.add<bool>("laserCorrection", true);
264  desc.add<double>("EBLaserMIN", 0.5);
265  desc.add<bool>("killDeadChannels", true);
266  {
267  std::vector<int> temp1;
268  temp1.reserve(3);
269  temp1.push_back(14);
270  temp1.push_back(78);
271  temp1.push_back(142);
272  desc.add<std::vector<int>>("dbStatusToBeExcludedEB", temp1);
273  }
274  desc.add<edm::InputTag>("EEuncalibRecHitCollection",
275  edm::InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEE"));
276  {
277  std::vector<int> temp1;
278  temp1.reserve(3);
279  temp1.push_back(14);
280  temp1.push_back(78);
281  temp1.push_back(142);
282  desc.add<std::vector<int>>("dbStatusToBeExcludedEE", temp1);
283  }
284  desc.add<double>("EELaserMIN", 0.5);
285  desc.add<edm::InputTag>("ebFEToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "ebFE"));
286  {
287  edm::ParameterSetDescription psd0;
288  psd0.add<double>("e6e2thresh", 0.04);
289  psd0.add<double>("tightenCrack_e6e2_double", 3);
290  psd0.add<double>("e4e1Threshold_endcap", 0.3);
291  psd0.add<double>("tightenCrack_e4e1_single", 3);
292  psd0.add<double>("tightenCrack_e1_double", 2);
293  psd0.add<double>("cThreshold_barrel", 4);
294  psd0.add<double>("e4e1Threshold_barrel", 0.08);
295  psd0.add<double>("tightenCrack_e1_single", 2);
296  psd0.add<double>("e4e1_b_barrel", -0.024);
297  psd0.add<double>("e4e1_a_barrel", 0.04);
298  psd0.add<double>("ignoreOutOfTimeThresh", 1000000000.0);
299  psd0.add<double>("cThreshold_endcap", 15);
300  psd0.add<double>("e4e1_b_endcap", -0.0125);
301  psd0.add<double>("e4e1_a_endcap", 0.02);
302  psd0.add<double>("cThreshold_double", 10);
303  desc.add<edm::ParameterSetDescription>("cleaningConfig", psd0);
304  }
305  desc.add<double>("logWarningEtThreshold_EE_FE", 50);
306  desc.add<edm::InputTag>("eeDetIdToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "eeDetId"));
307  desc.add<bool>("recoverEBFE", true);
308  desc.add<edm::InputTag>("eeFEToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "eeFE"));
309  desc.add<edm::InputTag>("ebDetIdToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "ebDetId"));
310  desc.add<double>("singleChannelRecoveryThreshold", 8);
311  desc.add<double>("sum8ChannelRecoveryThreshold", 0.);
312  desc.add<edm::FileInPath>("bdtWeightFileNoCracks",
313  edm::FileInPath("RecoLocalCalo/EcalDeadChannelRecoveryAlgos/data/BDTWeights/"
314  "bdtgAllRH_8GT700MeV_noCracks_ZskimData2017_v1.xml"));
315  desc.add<edm::FileInPath>("bdtWeightFileCracks",
316  edm::FileInPath("RecoLocalCalo/EcalDeadChannelRecoveryAlgos/data/BDTWeights/"
317  "bdtgAllRH_8GT700MeV_onlyCracks_ZskimData2017_v1.xml"));
318  {
319  std::vector<std::string> temp1;
320  temp1.reserve(9);
321  temp1.push_back("kNoisy");
322  temp1.push_back("kNNoisy");
323  temp1.push_back("kFixedG6");
324  temp1.push_back("kFixedG1");
325  temp1.push_back("kFixedG0");
326  temp1.push_back("kNonRespondingIsolated");
327  temp1.push_back("kDeadVFE");
328  temp1.push_back("kDeadFE");
329  temp1.push_back("kNoDataNoTP");
330  desc.add<std::vector<std::string>>("ChannelStatusToBeExcluded", temp1);
331  }
332  desc.add<std::string>("EBrechitCollection", "EcalRecHitsEB");
333  desc.add<edm::InputTag>("triggerPrimitiveDigiCollection", edm::InputTag("ecalDigis", "EcalTriggerPrimitives"));
334  desc.add<bool>("recoverEEFE", true);
335  desc.add<std::string>("singleChannelRecoveryMethod", "NeuralNetworks");
336  desc.add<double>("EBLaserMAX", 3.0);
337  {
338  edm::ParameterSetDescription psd0;
339  {
340  std::vector<std::string> temp2;
341  temp2.reserve(4);
342  temp2.push_back("kOk");
343  temp2.push_back("kDAC");
344  temp2.push_back("kNoLaser");
345  temp2.push_back("kNoisy");
346  psd0.add<std::vector<std::string>>("kGood", temp2);
347  }
348  {
349  std::vector<std::string> temp2;
350  temp2.reserve(3);
351  temp2.push_back("kFixedG0");
352  temp2.push_back("kNonRespondingIsolated");
353  temp2.push_back("kDeadVFE");
354  psd0.add<std::vector<std::string>>("kNeighboursRecovered", temp2);
355  }
356  {
357  std::vector<std::string> temp2;
358  temp2.reserve(1);
359  temp2.push_back("kNoDataNoTP");
360  psd0.add<std::vector<std::string>>("kDead", temp2);
361  }
362  {
363  std::vector<std::string> temp2;
364  temp2.reserve(3);
365  temp2.push_back("kNNoisy");
366  temp2.push_back("kFixedG6");
367  temp2.push_back("kFixedG1");
368  psd0.add<std::vector<std::string>>("kNoisy", temp2);
369  }
370  {
371  std::vector<std::string> temp2;
372  temp2.reserve(1);
373  temp2.push_back("kDeadFE");
374  psd0.add<std::vector<std::string>>("kTowerRecovered", temp2);
375  }
376  desc.add<edm::ParameterSetDescription>("flagsMapDBReco", psd0);
377  }
378  desc.add<edm::InputTag>("EBuncalibRecHitCollection",
379  edm::InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEB"));
380  desc.add<std::string>("algoRecover", "EcalRecHitWorkerRecover");
381  desc.add<std::string>("algo", "EcalRecHitWorkerSimple");
382  desc.add<double>("EELaserMAX", 8.0);
383  desc.add<double>("logWarningEtThreshold_EB_FE", 50);
384  desc.add<bool>("recoverEEIsolatedChannels", false);
385  desc.add<bool>("skipTimeCalib", false);
386  descriptions.add("ecalRecHit", desc);
387 }
388 
389 #include "FWCore/Framework/interface/MakerMacros.h"
390 DEFINE_FWK_MODULE(EcalRecHitProducer);
ConfigurationDescriptions.h
EcalRecHitWorkerBaseClass::EE_VFE
Definition: EcalRecHitWorkerBaseClass.h:15
EcalCondObjectContainer::end
const_iterator end() const
Definition: EcalCondObjectContainer.h:76
EcalRecHitProducer::produce
void produce(edm::Event &evt, const edm::EventSetup &es) override
Definition: EcalRecHitProducer.cc:73
Handle.h
EcalElectronicsId.h
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
EcalChannelStatusCode
Definition: EcalChannelStatusCode.h:18
edm::SortedCollection::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: SortedCollection.h:80
MessageLogger.h
EcalRecHitProducer::eeDetIdToBeRecoveredToken_
edm::EDGetTokenT< std::set< EEDetId > > eeDetIdToBeRecoveredToken_
Definition: EcalRecHitProducer.h:53
EcalRecHitProducer::recoverEEIsolatedChannels_
bool recoverEEIsolatedChannels_
Definition: EcalRecHitProducer.h:38
edm::Handle::product
T const * product() const
Definition: Handle.h:70
ESHandle.h
EcalRecHitProducer::ebUncalibRecHitToken_
edm::EDGetTokenT< EBUncalibratedRecHitCollection > ebUncalibRecHitToken_
Definition: EcalRecHitProducer.h:50
EcalRecHitProducer::recoverEEFE_
bool recoverEEFE_
Definition: EcalRecHitProducer.h:42
EBDetId
Definition: EBDetId.h:17
edm
HLT enums.
Definition: AlignableModifier.h:19
EcalRecHitProducer::recoverEEVFE_
bool recoverEEVFE_
Definition: EcalRecHitProducer.h:40
EcalRecHitWorkerBaseClass::EB_single
Definition: EcalRecHitWorkerBaseClass.h:15
EBDetId.h
EEDetId.h
edm::LogInfo
Definition: MessageLogger.h:254
EcalRecHitProducer::ebDetIdToBeRecoveredToken_
edm::EDGetTokenT< std::set< EBDetId > > ebDetIdToBeRecoveredToken_
Definition: EcalRecHitProducer.h:52
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
EcalRecHitProducer::ebRechitCollection_
std::string ebRechitCollection_
Definition: EcalRecHitProducer.h:34
edm::SortedCollection
Definition: SortedCollection.h:49
EcalRecHitProducer
Definition: EcalRecHitProducer.h:26
edm::SortedCollection::size
size_type size() const
Definition: SortedCollection.h:215
edm::Handle
Definition: AssociativeIterator.h:50
EcalRecHitCollections.h
EcalRecHitProducer::worker_
std::unique_ptr< EcalRecHitWorkerBaseClass > worker_
Definition: EcalRecHitProducer.h:45
EcalRecHitProducer::cleaningAlgo_
std::unique_ptr< EcalCleaningAlgo > cleaningAlgo_
Definition: EcalRecHitProducer.h:48
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
EcalRecHitWorkerBaseClass::EB_FE
Definition: EcalRecHitWorkerBaseClass.h:15
edm::FileInPath
Definition: FileInPath.h:64
MakerMacros.h
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:262
EcalRecHitProducer::recoverEBFE_
bool recoverEBFE_
Definition: EcalRecHitProducer.h:41
edm::ESHandle
Definition: DTSurvey.h:22
EcalCondObjectContainer::find
const_iterator find(uint32_t rawId) const
Definition: EcalCondObjectContainer.h:53
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:528
EcalRecHitProducer::recoverEBVFE_
bool recoverEBVFE_
Definition: EcalRecHitProducer.h:39
ParameterSetDescription.h
EEDetId
Definition: EEDetId.h:14
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
EcalRecHitProducer::eeRechitCollection_
std::string eeRechitCollection_
Definition: EcalRecHitProducer.h:35
EcalRecHitProducer.h
EcalTrigTowerDetId.h
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
EcalRecHitProducer::killDeadChannels_
bool killDeadChannels_
Definition: EcalRecHitProducer.h:43
EBDetId::ETAPHIMODE
static const int ETAPHIMODE
Definition: EBDetId.h:158
EcalRecHitProducer::eeFEToBeRecoveredToken_
edm::EDGetTokenT< std::set< EcalScDetId > > eeFEToBeRecoveredToken_
Definition: EcalRecHitProducer.h:55
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
EcalRecHitProducer::ebFEToBeRecoveredToken_
edm::EDGetTokenT< std::set< EcalTrigTowerDetId > > ebFEToBeRecoveredToken_
Definition: EcalRecHitProducer.h:54
edm::ParameterSet
Definition: ParameterSet.h:36
edm::LogError
Definition: MessageLogger.h:183
EcalChannelStatusRcd
Definition: EcalChannelStatusRcd.h:5
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:267
EcalChannelStatusCode::getStatusCode
Code getStatusCode() const
return decoded status
Definition: EcalChannelStatusCode.h:47
EcalRecHitProducer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: EcalRecHitProducer.cc:257
edm::ParameterSetDescription::reserve
void reserve(SetDescriptionEntries::size_type n)
Definition: ParameterSetDescription.h:301
EcalRecHitWorkerBaseClass::EE_FE
Definition: EcalRecHitWorkerBaseClass.h:15
edm::Event::put
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:132
edm::EventSetup
Definition: EventSetup.h:57
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
get
#define get
EcalCleaningAlgo.h
EcalUncalibratedRecHit
Definition: EcalUncalibratedRecHit.h:8
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
eostools.move
def move(src, dest)
Definition: eostools.py:511
EcalRecHitProducer::recoverEBIsolatedChannels_
bool recoverEBIsolatedChannels_
Definition: EcalRecHitProducer.h:37
EcalRecHitProducer::eeUncalibRecHitToken_
edm::EDGetTokenT< EEUncalibratedRecHitCollection > eeUncalibRecHitToken_
Definition: EcalRecHitProducer.h:51
EcalScDetId.h
EcalChannelStatusCode::kDeadVFE
Definition: EcalChannelStatusCode.h:33
EcalRecHitWorkerBaseClass::EB_VFE
Definition: EcalRecHitWorkerBaseClass.h:15
EcalRecHitProducer::workerRecover_
std::unique_ptr< EcalRecHitWorkerBaseClass > workerRecover_
Definition: EcalRecHitProducer.h:46
EEDetId::validDetId
static bool validDetId(int crystal_ix, int crystal_iy, int iz)
Definition: EEDetId.h:248
EcalRecHitProducer::~EcalRecHitProducer
~EcalRecHitProducer() override
EcalCondObjectContainer< EcalChannelStatusCode >::const_iterator
std::vector< Item >::const_iterator const_iterator
Definition: EcalCondObjectContainer.h:19
EcalRecHitProducer::EcalRecHitProducer
EcalRecHitProducer(const edm::ParameterSet &ps)
Definition: EcalRecHitProducer.cc:30
EcalRecHitWorkerBaseClass::EE_single
Definition: EcalRecHitWorkerBaseClass.h:15
EcalRecHitWorkerFactory.h
edm::Event
Definition: Event.h:73
EcalChannelStatus.h
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:39
EcalChannelStatusRcd.h
Generated for CMSSW Reference Manual by doxygen 1.8.16