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