CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Attributes
EcalRecHitProducer Class Reference

#include <EcalRecHitProducer.h>

Inheritance diagram for EcalRecHitProducer:
edm::stream::EDProducer<>

Public Member Functions

 EcalRecHitProducer (const edm::ParameterSet &ps)
 
void produce (edm::Event &evt, const edm::EventSetup &es) override
 
 ~EcalRecHitProducer () override
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
 EDProducer (const EDProducer &)=delete
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
const EDProducer & operator= (const EDProducer &)=delete
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 

Private Attributes

std::unique_ptr< EcalCleaningAlgo > cleaningAlgo_
 
edm::EDGetTokenT< std::set< EBDetId > > ebDetIdToBeRecoveredToken_
 
edm::EDGetTokenT< std::set< EcalTrigTowerDetId > > ebFEToBeRecoveredToken_
 
std::string ebRechitCollection_
 
edm::EDGetTokenT< EBUncalibratedRecHitCollection > ebUncalibRecHitToken_
 
edm::ESGetToken< EcalChannelStatus, EcalChannelStatusRcd > ecalChannelStatusToken_
 
edm::EDGetTokenT< std::set< EEDetId > > eeDetIdToBeRecoveredToken_
 
edm::EDGetTokenT< std::set< EcalScDetId > > eeFEToBeRecoveredToken_
 
std::string eeRechitCollection_
 
edm::EDGetTokenT< EEUncalibratedRecHitCollection > eeUncalibRecHitToken_
 
bool killDeadChannels_
 
bool recoverEBFE_
 
bool recoverEBIsolatedChannels_
 
bool recoverEBVFE_
 
bool recoverEEFE_
 
bool recoverEEIsolatedChannels_
 
bool recoverEEVFE_
 
std::unique_ptr< EcalRecHitWorkerBaseClass > worker_
 
std::unique_ptr< EcalRecHitWorkerBaseClass > workerRecover_
 

Additional Inherited Members

- Public Types inherited from edm::stream::EDProducer<>
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::RunSummaryCache
 

Detailed Description

produce ECAL rechits from uncalibrated rechits

Author
Shahram Rahatlou, University of Rome & INFN, March 2006

Definition at line 28 of file EcalRecHitProducer.h.

Constructor & Destructor Documentation

◆ EcalRecHitProducer()

EcalRecHitProducer::EcalRecHitProducer ( const edm::ParameterSet &  ps)
explicit

Definition at line 27 of file EcalRecHitProducer.cc.

27  {
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 }

References c, cleaningAlgo_, ebDetIdToBeRecoveredToken_, ebFEToBeRecoveredToken_, ebRechitCollection_, ebUncalibRecHitToken_, ecalChannelStatusToken_, eeDetIdToBeRecoveredToken_, eeFEToBeRecoveredToken_, eeRechitCollection_, eeUncalibRecHitToken_, get, edm::ParameterSet::getParameter(), killDeadChannels_, recoverEBFE_, recoverEBIsolatedChannels_, recoverEBVFE_, recoverEEFE_, recoverEEIsolatedChannels_, recoverEEVFE_, AlCaHLTBitMon_QueryRunRegistry::string, worker_, and workerRecover_.

◆ ~EcalRecHitProducer()

EcalRecHitProducer::~EcalRecHitProducer ( )
overridedefault

Member Function Documentation

◆ fillDescriptions()

void EcalRecHitProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
static

Definition at line 254 of file EcalRecHitProducer.cc.

254  {
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 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, edm::ParameterSetDescription::reserve(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

void EcalRecHitProducer::produce ( edm::Event &  evt,
const edm::EventSetup &  es 
)
override

Definition at line 72 of file EcalRecHitProducer.cc.

72  {
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 }

References edm::SortedCollection< T, SORT >::begin(), cleaningAlgo_, EcalRecHitWorkerBaseClass::EB_FE, EcalRecHitWorkerBaseClass::EB_single, EcalRecHitWorkerBaseClass::EB_VFE, ebDetIdToBeRecoveredToken_, ebFEToBeRecoveredToken_, ebRechitCollection_, ebUncalibRecHitToken_, ecalChannelStatusToken_, EcalRecHitWorkerBaseClass::EE_FE, EcalRecHitWorkerBaseClass::EE_single, EcalRecHitWorkerBaseClass::EE_VFE, eeDetIdToBeRecoveredToken_, eeFEToBeRecoveredToken_, eeRechitCollection_, eeUncalibRecHitToken_, EcalCondObjectContainer< T >::end(), edm::SortedCollection< T, SORT >::end(), EBDetId::ETAPHIMODE, EcalCondObjectContainer< T >::find(), edm::Event::getByToken(), edm::EventSetup::getHandle(), EcalChannelStatusCode::getStatusCode(), LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, EcalChannelStatusCode::kDeadVFE, killDeadChannels_, LogDebug, eostools::move(), edm::Handle< T >::product(), edm::Event::put(), recoverEBFE_, recoverEBIsolatedChannels_, recoverEBVFE_, recoverEEFE_, recoverEEIsolatedChannels_, recoverEEVFE_, edm::SortedCollection< T, SORT >::size(), EEDetId::validDetId(), worker_, and workerRecover_.

Member Data Documentation

◆ cleaningAlgo_

std::unique_ptr<EcalCleaningAlgo> EcalRecHitProducer::cleaningAlgo_
private

Definition at line 50 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ ebDetIdToBeRecoveredToken_

edm::EDGetTokenT<std::set<EBDetId> > EcalRecHitProducer::ebDetIdToBeRecoveredToken_
private

Definition at line 54 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ ebFEToBeRecoveredToken_

edm::EDGetTokenT<std::set<EcalTrigTowerDetId> > EcalRecHitProducer::ebFEToBeRecoveredToken_
private

Definition at line 56 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ ebRechitCollection_

std::string EcalRecHitProducer::ebRechitCollection_
private

Definition at line 36 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ ebUncalibRecHitToken_

edm::EDGetTokenT<EBUncalibratedRecHitCollection> EcalRecHitProducer::ebUncalibRecHitToken_
private

Definition at line 52 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ ecalChannelStatusToken_

edm::ESGetToken<EcalChannelStatus, EcalChannelStatusRcd> EcalRecHitProducer::ecalChannelStatusToken_
private

Definition at line 58 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ eeDetIdToBeRecoveredToken_

edm::EDGetTokenT<std::set<EEDetId> > EcalRecHitProducer::eeDetIdToBeRecoveredToken_
private

Definition at line 55 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ eeFEToBeRecoveredToken_

edm::EDGetTokenT<std::set<EcalScDetId> > EcalRecHitProducer::eeFEToBeRecoveredToken_
private

Definition at line 57 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ eeRechitCollection_

std::string EcalRecHitProducer::eeRechitCollection_
private

Definition at line 37 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ eeUncalibRecHitToken_

edm::EDGetTokenT<EEUncalibratedRecHitCollection> EcalRecHitProducer::eeUncalibRecHitToken_
private

Definition at line 53 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ killDeadChannels_

bool EcalRecHitProducer::killDeadChannels_
private

Definition at line 45 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ recoverEBFE_

bool EcalRecHitProducer::recoverEBFE_
private

Definition at line 43 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ recoverEBIsolatedChannels_

bool EcalRecHitProducer::recoverEBIsolatedChannels_
private

Definition at line 39 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ recoverEBVFE_

bool EcalRecHitProducer::recoverEBVFE_
private

Definition at line 41 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ recoverEEFE_

bool EcalRecHitProducer::recoverEEFE_
private

Definition at line 44 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ recoverEEIsolatedChannels_

bool EcalRecHitProducer::recoverEEIsolatedChannels_
private

Definition at line 40 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ recoverEEVFE_

bool EcalRecHitProducer::recoverEEVFE_
private

Definition at line 42 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ worker_

std::unique_ptr<EcalRecHitWorkerBaseClass> EcalRecHitProducer::worker_
private

Definition at line 47 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

◆ workerRecover_

std::unique_ptr<EcalRecHitWorkerBaseClass> EcalRecHitProducer::workerRecover_
private

Definition at line 48 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

EcalRecHitWorkerBaseClass::EE_VFE
Definition: EcalRecHitWorkerBaseClass.h:15
EcalCondObjectContainer::end
const_iterator end() const
Definition: EcalCondObjectContainer.h:74
EcalRecHitProducer::ecalChannelStatusToken_
edm::ESGetToken< EcalChannelStatus, EcalChannelStatusRcd > ecalChannelStatusToken_
Definition: EcalRecHitProducer.h:58
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
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
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
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
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
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
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:61
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:539
EcalRecHitProducer::recoverEBVFE_
bool recoverEBVFE_
Definition: EcalRecHitProducer.h:41
EEDetId
Definition: EEDetId.h:14
EcalRecHitProducer::eeRechitCollection_
std::string eeRechitCollection_
Definition: EcalRecHitProducer.h:37
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:233
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
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:155
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
get
#define get
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
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
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
EcalCondObjectContainer::const_iterator
std::vector< Item >::const_iterator const_iterator
Definition: EcalCondObjectContainer.h:19
EcalRecHitWorkerBaseClass::EE_single
Definition: EcalRecHitWorkerBaseClass.h:15
c
auto & c
Definition: CAHitNtupletGeneratorKernelsImpl.h:56
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
Generated for CMSSW Reference Manual by doxygen 1.8.16