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<> edm::stream::EDProducerBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

 EcalRecHitProducer (const edm::ParameterSet &ps)
 
virtual void produce (edm::Event &evt, const edm::EventSetup &es) override
 
 ~EcalRecHitProducer ()
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
- Public Member Functions inherited from edm::stream::EDProducerBase
 EDProducerBase ()
 
ModuleDescription const & moduleDescription () const
 
virtual ~EDProducerBase ()
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
std::vector< edm::ProductResolverIndex > const & indiciesForPutProducts (BranchType iBranchType) const
 
 ProducerBase ()
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription const &)> registrationCallback () const
 used by the fwk to register list of products More...
 
void resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)
 
virtual ~ProducerBase () noexcept(false)
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
virtual ~EDConsumerBase () noexcept(false)
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
- Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 

Private Attributes

EcalCleaningAlgo * cleaningAlgo_
 
edm::EDGetTokenT< std::set< EBDetId > > ebDetIdToBeRecoveredToken_
 
edm::EDGetTokenT< std::set< EcalTrigTowerDetId > > ebFEToBeRecoveredToken_
 
std::string ebRechitCollection_
 
edm::EDGetTokenT< EBUncalibratedRecHitCollection > ebUncalibRecHitToken_
 
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_
 
EcalRecHitWorkerBaseClass * worker_
 
EcalRecHitWorkerBaseClass * workerRecover_
 

Additional Inherited Members

- Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 
- Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase ModuleType
 
- Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Detailed Description

produce ECAL rechits from uncalibrated rechits

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

Definition at line 26 of file EcalRecHitProducer.h.

Constructor & Destructor Documentation

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

Definition at line 30 of file EcalRecHitProducer.cc.

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

31 {
32 
33  ebRechitCollection_ = ps.getParameter<std::string>("EBrechitCollection");
34  eeRechitCollection_ = ps.getParameter<std::string>("EErechitCollection");
35 
36  recoverEBIsolatedChannels_ = ps.getParameter<bool>("recoverEBIsolatedChannels");
37  recoverEEIsolatedChannels_ = ps.getParameter<bool>("recoverEEIsolatedChannels");
38  recoverEBVFE_ = ps.getParameter<bool>("recoverEBVFE");
39  recoverEEVFE_ = ps.getParameter<bool>("recoverEEVFE");
40  recoverEBFE_ = ps.getParameter<bool>("recoverEBFE");
41  recoverEEFE_ = ps.getParameter<bool>("recoverEEFE");
42  killDeadChannels_ = ps.getParameter<bool>("killDeadChannels");
43 
44 
45  produces< EBRecHitCollection >(ebRechitCollection_);
46  produces< EERecHitCollection >(eeRechitCollection_);
47 
48 
49  ebUncalibRecHitToken_ =
50  consumes<EBUncalibratedRecHitCollection>( ps.getParameter<edm::InputTag>("EBuncalibRecHitCollection"));
51 
52  eeUncalibRecHitToken_ =
53  consumes<EEUncalibratedRecHitCollection>( ps.getParameter<edm::InputTag>("EEuncalibRecHitCollection"));
54 
55  ebDetIdToBeRecoveredToken_ =
56  consumes<std::set<EBDetId>>(ps.getParameter<edm::InputTag>("ebDetIdToBeRecovered"));
57 
58  eeDetIdToBeRecoveredToken_=
59  consumes<std::set<EEDetId>>(ps.getParameter<edm::InputTag>("eeDetIdToBeRecovered"));
60 
61  ebFEToBeRecoveredToken_ = consumes<std::set<EcalTrigTowerDetId>>(ps.getParameter<edm::InputTag>("ebFEToBeRecovered"));
62 
63  eeFEToBeRecoveredToken_= consumes<std::set<EcalScDetId>>( ps.getParameter<edm::InputTag>("eeFEToBeRecovered")) ;
64 
65  std::string componentType = ps.getParameter<std::string>("algo");
66  edm::ConsumesCollector c{consumesCollector()};
67  worker_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
68 
69  // to recover problematic channels
70  componentType = ps.getParameter<std::string>("algoRecover");
71  workerRecover_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
72 
73  edm::ParameterSet cleaningPs =
74  ps.getParameter<edm::ParameterSet>("cleaningConfig");
75  cleaningAlgo_ = new EcalCleaningAlgo(cleaningPs);
76 }
EcalRecHitProducer::eeRechitCollection_
std::string eeRechitCollection_
Definition: EcalRecHitProducer.h:36
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
EcalRecHitProducer::worker_
EcalRecHitWorkerBaseClass * worker_
Definition: EcalRecHitProducer.h:47
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:72
EcalRecHitProducer::cleaningAlgo_
EcalCleaningAlgo * cleaningAlgo_
Definition: EcalRecHitProducer.h:50
EcalRecHitProducer::eeUncalibRecHitToken_
edm::EDGetTokenT< EEUncalibratedRecHitCollection > eeUncalibRecHitToken_
Definition: EcalRecHitProducer.h:53
EcalRecHitProducer::eeFEToBeRecoveredToken_
edm::EDGetTokenT< std::set< EcalScDetId > > eeFEToBeRecoveredToken_
Definition: EcalRecHitProducer.h:57
EcalRecHitProducer::ebUncalibRecHitToken_
edm::EDGetTokenT< EBUncalibratedRecHitCollection > ebUncalibRecHitToken_
Definition: EcalRecHitProducer.h:52
EcalRecHitProducer::workerRecover_
EcalRecHitWorkerBaseClass * workerRecover_
Definition: EcalRecHitProducer.h:48
EcalRecHitProducer::ebDetIdToBeRecoveredToken_
edm::EDGetTokenT< std::set< EBDetId > > ebDetIdToBeRecoveredToken_
Definition: EcalRecHitProducer.h:54
EcalRecHitProducer::ebRechitCollection_
std::string ebRechitCollection_
Definition: EcalRecHitProducer.h:35
EcalRecHitProducer::eeDetIdToBeRecoveredToken_
edm::EDGetTokenT< std::set< EEDetId > > eeDetIdToBeRecoveredToken_
Definition: EcalRecHitProducer.h:55
reco::get
T get(const Candidate &c)
Definition: component.h:55
EcalRecHitProducer::ebFEToBeRecoveredToken_
edm::EDGetTokenT< std::set< EcalTrigTowerDetId > > ebFEToBeRecoveredToken_
Definition: EcalRecHitProducer.h:56
EcalRecHitProducer::~EcalRecHitProducer ( )

Definition at line 78 of file EcalRecHitProducer.cc.

References cleaningAlgo_, worker_, and workerRecover_.

79 {
80  delete worker_;
81  delete workerRecover_;
82  delete cleaningAlgo_;
83 }
EcalRecHitProducer::worker_
EcalRecHitWorkerBaseClass * worker_
Definition: EcalRecHitProducer.h:47
EcalRecHitProducer::cleaningAlgo_
EcalCleaningAlgo * cleaningAlgo_
Definition: EcalRecHitProducer.h:50
EcalRecHitProducer::workerRecover_
EcalRecHitWorkerBaseClass * workerRecover_
Definition: EcalRecHitProducer.h:48

Member Function Documentation

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

Definition at line 274 of file EcalRecHitProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), DEFINE_FWK_MODULE, edm::ParameterSetDescription::reserve(), and AlCaHLTBitMon_QueryRunRegistry::string.

274  {
275  edm::ParameterSetDescription desc;
276  desc.add<bool>("recoverEEVFE",false);
277  desc.add<std::string>("EErechitCollection","EcalRecHitsEE");
278  desc.add<bool>("recoverEBIsolatedChannels",false);
279  desc.add<bool>("recoverEBVFE",false);
280  desc.add<bool>("laserCorrection",true);
281  desc.add<double>("EBLaserMIN",0.5);
282  desc.add<bool>("killDeadChannels",true);
283  {
284  std::vector<int> temp1;
285  temp1.reserve(3);
286  temp1.push_back(14);
287  temp1.push_back(78);
288  temp1.push_back(142);
289  desc.add<std::vector<int> >("dbStatusToBeExcludedEB",temp1);
290  }
291  desc.add<edm::InputTag>("EEuncalibRecHitCollection",edm::InputTag("ecalMultiFitUncalibRecHit","EcalUncalibRecHitsEE"));
292  {
293  std::vector<int> temp1;
294  temp1.reserve(3);
295  temp1.push_back(14);
296  temp1.push_back(78);
297  temp1.push_back(142);
298  desc.add<std::vector<int> >("dbStatusToBeExcludedEE",temp1);
299  }
300  desc.add<double>("EELaserMIN",0.5);
301  desc.add<edm::InputTag>("ebFEToBeRecovered",edm::InputTag("ecalDetIdToBeRecovered","ebFE"));
302  {
303  edm::ParameterSetDescription psd0;
304  psd0.add<double>("e6e2thresh",0.04);
305  psd0.add<double>("tightenCrack_e6e2_double",3);
306  psd0.add<double>("e4e1Threshold_endcap",0.3);
307  psd0.add<double>("tightenCrack_e4e1_single",3);
308  psd0.add<double>("tightenCrack_e1_double",2);
309  psd0.add<double>("cThreshold_barrel",4);
310  psd0.add<double>("e4e1Threshold_barrel",0.08);
311  psd0.add<double>("tightenCrack_e1_single",2);
312  psd0.add<double>("e4e1_b_barrel",-0.024);
313  psd0.add<double>("e4e1_a_barrel",0.04);
314  psd0.add<double>("ignoreOutOfTimeThresh",1000000000.0);
315  psd0.add<double>("cThreshold_endcap",15);
316  psd0.add<double>("e4e1_b_endcap",-0.0125);
317  psd0.add<double>("e4e1_a_endcap",0.02);
318  psd0.add<double>("cThreshold_double",10);
319  desc.add<edm::ParameterSetDescription>("cleaningConfig",psd0);
320  }
321  desc.add<double>("logWarningEtThreshold_EE_FE",50);
322  desc.add<edm::InputTag>("eeDetIdToBeRecovered",edm::InputTag("ecalDetIdToBeRecovered","eeDetId"));
323  desc.add<bool>("recoverEBFE",true);
324  desc.add<edm::InputTag>("eeFEToBeRecovered",edm::InputTag("ecalDetIdToBeRecovered","eeFE"));
325  desc.add<edm::InputTag>("ebDetIdToBeRecovered",edm::InputTag("ecalDetIdToBeRecovered","ebDetId"));
326  desc.add<double>("singleChannelRecoveryThreshold",8);
327  {
328  std::vector<std::string> temp1;
329  temp1.reserve(9);
330  temp1.push_back("kNoisy");
331  temp1.push_back("kNNoisy");
332  temp1.push_back("kFixedG6");
333  temp1.push_back("kFixedG1");
334  temp1.push_back("kFixedG0");
335  temp1.push_back("kNonRespondingIsolated");
336  temp1.push_back("kDeadVFE");
337  temp1.push_back("kDeadFE");
338  temp1.push_back("kNoDataNoTP");
339  desc.add<std::vector<std::string> >("ChannelStatusToBeExcluded",temp1);
340  }
341  desc.add<std::string>("EBrechitCollection","EcalRecHitsEB");
342  desc.add<edm::InputTag>("triggerPrimitiveDigiCollection",edm::InputTag("ecalDigis","EcalTriggerPrimitives"));
343  desc.add<bool>("recoverEEFE",true);
344  desc.add<std::string>("singleChannelRecoveryMethod","NeuralNetworks");
345  desc.add<double>("EBLaserMAX",3.0);
346  {
347  edm::ParameterSetDescription psd0;
348  {
349  std::vector<std::string> temp2;
350  temp2.reserve(4);
351  temp2.push_back("kOk");
352  temp2.push_back("kDAC");
353  temp2.push_back("kNoLaser");
354  temp2.push_back("kNoisy");
355  psd0.add<std::vector<std::string> >("kGood",temp2);
356  }
357  {
358  std::vector<std::string> temp2;
359  temp2.reserve(3);
360  temp2.push_back("kFixedG0");
361  temp2.push_back("kNonRespondingIsolated");
362  temp2.push_back("kDeadVFE");
363  psd0.add<std::vector<std::string> >("kNeighboursRecovered",temp2);
364  }
365  {
366  std::vector<std::string> temp2;
367  temp2.reserve(1);
368  temp2.push_back("kNoDataNoTP");
369  psd0.add<std::vector<std::string> >("kDead",temp2);
370  }
371  {
372  std::vector<std::string> temp2;
373  temp2.reserve(3);
374  temp2.push_back("kNNoisy");
375  temp2.push_back("kFixedG6");
376  temp2.push_back("kFixedG1");
377  psd0.add<std::vector<std::string> >("kNoisy",temp2);
378  }
379  {
380  std::vector<std::string> temp2;
381  temp2.reserve(1);
382  temp2.push_back("kDeadFE");
383  psd0.add<std::vector<std::string> >("kTowerRecovered",temp2);
384  }
385  desc.add<edm::ParameterSetDescription>("flagsMapDBReco",psd0);
386  }
387  desc.add<edm::InputTag>("EBuncalibRecHitCollection",edm::InputTag("ecalMultiFitUncalibRecHit","EcalUncalibRecHitsEB"));
388  desc.add<std::string>("algoRecover","EcalRecHitWorkerRecover");
389  desc.add<std::string>("algo","EcalRecHitWorkerSimple");
390  desc.add<double>("EELaserMAX",8.0);
391  desc.add<double>("logWarningEtThreshold_EB_FE",50);
392  desc.add<bool>("recoverEEIsolatedChannels",false);
393  desc.add<bool>("skipTimeCalib",false);
394  descriptions.add("ecalRecHit",desc);
395 }
edm::ParameterSetDescription::reserve
void reserve(SetDescriptionEntries::size_type n)
Definition: ParameterSetDescription.h:316
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:89
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:65
void EcalRecHitProducer::produce ( edm::Event &  evt,
const edm::EventSetup &  es 
)
overridevirtual

Definition at line 86 of file EcalRecHitProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), cleaningAlgo_, EcalRecHitWorkerBaseClass::EB_FE, EcalRecHitWorkerBaseClass::EB_single, EcalRecHitWorkerBaseClass::EB_VFE, ebDetIdToBeRecoveredToken_, ebFEToBeRecoveredToken_, ebRechitCollection_, ebUncalibRecHitToken_, 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::EventSetup::get(), edm::Event::getByToken(), EcalChannelStatusCode::getStatusCode(), EcalChannelStatusCode::kDeadVFE, killDeadChannels_, LogDebug, eostools::move(), edm::Handle< T >::product(), edm::Event::put(), recoverEBFE_, recoverEBIsolatedChannels_, recoverEBVFE_, recoverEEFE_, recoverEEIsolatedChannels_, recoverEEVFE_, EcalRecHitWorkerBaseClass::run(), EcalRecHitWorkerBaseClass::set(), EcalCleaningAlgo::setFlags(), edm::SortedCollection< T, SORT >::size(), EEDetId::validDetId(), worker_, and workerRecover_.

87 {
88  using namespace edm;
89 
90  Handle< EBUncalibratedRecHitCollection > pEBUncalibRecHits;
91  Handle< EEUncalibratedRecHitCollection > pEEUncalibRecHits;
92 
93  const EBUncalibratedRecHitCollection* ebUncalibRecHits = 0;
94  const EEUncalibratedRecHitCollection* eeUncalibRecHits = 0;
95 
96  // get the barrel uncalib rechit collection
97 
98  evt.getByToken( ebUncalibRecHitToken_, pEBUncalibRecHits);
99  ebUncalibRecHits = pEBUncalibRecHits.product();
100  LogDebug("EcalRecHitDebug") << "total # EB uncalibrated rechits: " << ebUncalibRecHits->size();
101 
102 
103 
104  evt.getByToken( eeUncalibRecHitToken_, pEEUncalibRecHits);
105  eeUncalibRecHits = pEEUncalibRecHits.product(); // get a ptr to the product
106  LogDebug("EcalRecHitDebug") << "total # EE uncalibrated rechits: " << eeUncalibRecHits->size();
107 
108  // collection of rechits to put in the event
109  auto ebRecHits = std::make_unique<EBRecHitCollection>();
110  auto eeRecHits = std::make_unique<EERecHitCollection>();
111 
112  worker_->set(es);
113 
114  if ( recoverEBIsolatedChannels_ || recoverEEIsolatedChannels_
115  || recoverEBFE_ || recoverEEFE_
116  || recoverEBVFE_ || recoverEEVFE_
117  || killDeadChannels_ ) {
118  workerRecover_->set(es);
119  }
120 
121  if (ebUncalibRecHits)
122  {
123  // loop over uncalibrated rechits to make calibrated ones
124  for(EBUncalibratedRecHitCollection::const_iterator it = ebUncalibRecHits->begin(); it != ebUncalibRecHits->end(); ++it) {
125  worker_->run(evt, *it, *ebRecHits);
126  }
127  }
128 
129  if (eeUncalibRecHits)
130  {
131  // loop over uncalibrated rechits to make calibrated ones
132  for(EEUncalibratedRecHitCollection::const_iterator it = eeUncalibRecHits->begin(); it != eeUncalibRecHits->end(); ++it) {
133  worker_->run(evt, *it, *eeRecHits);
134  }
135  }
136 
137  // sort collections before attempting recovery, to avoid insertion of double recHits
138  ebRecHits->sort();
139  eeRecHits->sort();
140 
141  if ( recoverEBIsolatedChannels_ || recoverEBFE_ || killDeadChannels_ )
142  {
143  edm::Handle< std::set<EBDetId> > pEBDetId;
144  const std::set<EBDetId> * detIds = 0;
145  evt.getByToken( ebDetIdToBeRecoveredToken_, pEBDetId);
146  detIds = pEBDetId.product();
147 
148 
149  if ( detIds ) {
150  edm::ESHandle<EcalChannelStatus> chStatus;
151  es.get<EcalChannelStatusRcd>().get(chStatus);
152  for( std::set<EBDetId>::const_iterator it = detIds->begin(); it != detIds->end(); ++it ) {
153  // get channel status map to treat dead VFE separately
154  EcalChannelStatusMap::const_iterator chit = chStatus->find( *it );
155  EcalChannelStatusCode chStatusCode;
156  if ( chit != chStatus->end() ) {
157  chStatusCode = *chit;
158  } else {
159  edm::LogError("EcalRecHitProducerError") << "No channel status found for xtal "
160  << (*it).rawId()
161  << "! something wrong with EcalChannelStatus in your DB? ";
162  }
163  EcalUncalibratedRecHit urh;
164  if ( chStatusCode.getStatusCode() == EcalChannelStatusCode::kDeadVFE ) { // dead VFE (from DB info)
165  // uses the EcalUncalibratedRecHit to pass the DetId info
166  urh = EcalUncalibratedRecHit( *it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_VFE );
167  if ( recoverEBVFE_ || killDeadChannels_ ) workerRecover_->run( evt, urh, *ebRecHits );
168  } else {
169  // uses the EcalUncalibratedRecHit to pass the DetId info
170  urh = EcalUncalibratedRecHit( *it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_single );
171  if ( recoverEBIsolatedChannels_ || killDeadChannels_ ) workerRecover_->run( evt, urh, *ebRecHits );
172  }
173 
174  }
175  }
176  }
177 
178  if ( recoverEEIsolatedChannels_ || recoverEEVFE_ || killDeadChannels_ )
179  {
180  edm::Handle< std::set<EEDetId> > pEEDetId;
181  const std::set<EEDetId> * detIds = 0;
182 
183  evt.getByToken( eeDetIdToBeRecoveredToken_, pEEDetId);
184  detIds = pEEDetId.product();
185 
186  if ( detIds ) {
187  edm::ESHandle<EcalChannelStatus> chStatus;
188  es.get<EcalChannelStatusRcd>().get(chStatus);
189  for( std::set<EEDetId>::const_iterator it = detIds->begin(); it != detIds->end(); ++it ) {
190  // get channel status map to treat dead VFE separately
191  EcalChannelStatusMap::const_iterator chit = chStatus->find( *it );
192  EcalChannelStatusCode chStatusCode;
193  if ( chit != chStatus->end() ) {
194  chStatusCode = *chit;
195  } else {
196  edm::LogError("EcalRecHitProducerError") << "No channel status found for xtal "
197  << (*it).rawId()
198  << "! something wrong with EcalChannelStatus in your DB? ";
199  }
200  EcalUncalibratedRecHit urh;
201  if ( chStatusCode.getStatusCode() == EcalChannelStatusCode::kDeadVFE) { // dead VFE (from DB info)
202  // uses the EcalUncalibratedRecHit to pass the DetId info
203  urh = EcalUncalibratedRecHit( *it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_VFE );
204  if ( recoverEEVFE_ || killDeadChannels_ ) workerRecover_->run( evt, urh, *eeRecHits );
205  } else {
206  // uses the EcalUncalibratedRecHit to pass the DetId info
207  urh = EcalUncalibratedRecHit( *it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_single );
208  if ( recoverEEIsolatedChannels_ || killDeadChannels_ ) workerRecover_->run( evt, urh, *eeRecHits );
209  }
210  }
211  }
212  }
213 
214  if ( recoverEBFE_ || killDeadChannels_ )
215  {
216  edm::Handle< std::set<EcalTrigTowerDetId> > pEBFEId;
217  const std::set<EcalTrigTowerDetId> * ttIds = 0;
218 
219  evt.getByToken( ebFEToBeRecoveredToken_, pEBFEId);
220  ttIds = pEBFEId.product();
221 
222  if ( ttIds ) {
223  for( std::set<EcalTrigTowerDetId>::const_iterator it = ttIds->begin(); it != ttIds->end(); ++it ) {
224  // uses the EcalUncalibratedRecHit to pass the DetId info
225  int ieta = (((*it).ietaAbs()-1)*5+1)*(*it).zside(); // from EcalTrigTowerConstituentsMap
226  int iphi = (((*it).iphi()-1)*5+11)%360; // from EcalTrigTowerConstituentsMap
227  if( iphi <= 0 ) iphi += 360; // from EcalTrigTowerConstituentsMap
228  EcalUncalibratedRecHit urh( EBDetId(ieta, iphi, EBDetId::ETAPHIMODE), 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_FE );
229  workerRecover_->run( evt, urh, *ebRecHits );
230  }
231  }
232  }
233 
234  if ( recoverEEFE_ || killDeadChannels_ )
235  {
236  edm::Handle< std::set<EcalScDetId> > pEEFEId;
237  const std::set<EcalScDetId> * scIds = 0;
238 
239  evt.getByToken( eeFEToBeRecoveredToken_, pEEFEId);
240  scIds = pEEFEId.product();
241 
242 
243  if ( scIds ) {
244  for( std::set<EcalScDetId>::const_iterator it = scIds->begin(); it != scIds->end(); ++it ) {
245  // uses the EcalUncalibratedRecHit to pass the DetId info
246  if (EEDetId::validDetId( ((*it).ix()-1)*5+1, ((*it).iy()-1)*5+1, (*it).zside() )) {
247  EcalUncalibratedRecHit urh( EEDetId( ((*it).ix()-1)*5+1, ((*it).iy()-1)*5+1, (*it).zside() ), 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_FE );
248  workerRecover_->run( evt, urh, *eeRecHits );
249  }
250  }
251  }
252  }
253 
254  // without re-sorting, find (used below in cleaning) will lead
255  // to undefined results
256  ebRecHits->sort();
257  eeRecHits->sort();
258 
259  // apply spike cleaning
260  if (cleaningAlgo_){
261  cleaningAlgo_->setFlags(*ebRecHits);
262  cleaningAlgo_->setFlags(*eeRecHits);
263  }
264 
265 
266  // put the collection of recunstructed hits in the event
267  LogInfo("EcalRecHitInfo") << "total # EB calibrated rechits: " << ebRecHits->size();
268  LogInfo("EcalRecHitInfo") << "total # EE calibrated rechits: " << eeRecHits->size();
269 
270  evt.put(std::move(ebRecHits), ebRechitCollection_);
271  evt.put(std::move(eeRecHits), eeRechitCollection_);
272 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
EcalRecHitProducer::eeRechitCollection_
std::string eeRechitCollection_
Definition: EcalRecHitProducer.h:36
edm::Event::put
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:122
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:460
EcalChannelStatusCode::getStatusCode
Code getStatusCode() const
return decoded status
Definition: EcalChannelStatusCode.h:61
edm::SortedCollection< EcalUncalibratedRecHit >::const_iterator
std::vector< EcalUncalibratedRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:82
EcalRecHitProducer::worker_
EcalRecHitWorkerBaseClass * worker_
Definition: EcalRecHitProducer.h:47
EcalRecHitProducer::cleaningAlgo_
EcalCleaningAlgo * cleaningAlgo_
Definition: EcalRecHitProducer.h:50
EcalRecHitProducer::eeUncalibRecHitToken_
edm::EDGetTokenT< EEUncalibratedRecHitCollection > eeUncalibRecHitToken_
Definition: EcalRecHitProducer.h:53
EcalRecHitProducer::eeFEToBeRecoveredToken_
edm::EDGetTokenT< std::set< EcalScDetId > > eeFEToBeRecoveredToken_
Definition: EcalRecHitProducer.h:57
EBDetId::ETAPHIMODE
static const int ETAPHIMODE
Definition: EBDetId.h:166
EcalRecHitProducer::ebUncalibRecHitToken_
edm::EDGetTokenT< EBUncalibratedRecHitCollection > ebUncalibRecHitToken_
Definition: EcalRecHitProducer.h:52
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:310
EcalRecHitProducer::workerRecover_
EcalRecHitWorkerBaseClass * workerRecover_
Definition: EcalRecHitProducer.h:48
EcalRecHitWorkerBaseClass::run
virtual bool run(const edm::Event &evt, const EcalUncalibratedRecHit &uncalibRH, EcalRecHitCollection &result)=0
EcalRecHitProducer::ebDetIdToBeRecoveredToken_
edm::EDGetTokenT< std::set< EBDetId > > ebDetIdToBeRecoveredToken_
Definition: EcalRecHitProducer.h:54
edm::Handle::product
T const * product() const
Definition: Handle.h:81
EEDetId::validDetId
static bool validDetId(int crystal_ix, int crystal_iy, int iz)
Definition: EEDetId.h:248
EcalRecHitProducer::ebRechitCollection_
std::string ebRechitCollection_
Definition: EcalRecHitProducer.h:35
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:56
EcalCondObjectContainer< EcalChannelStatusCode >::const_iterator
std::vector< Item >::const_iterator const_iterator
Definition: EcalCondObjectContainer.h:17
EcalRecHitWorkerBaseClass::set
virtual void set(const edm::EventSetup &es)=0
edm
HLT enums.
Definition: AlignableModifier.h:17
edm::SortedCollection::size
size_type size() const
Definition: SortedCollection.h:236
EcalCondObjectContainer::find
const_iterator find(uint32_t rawId) const
Definition: EcalCondObjectContainer.h:60
EcalCondObjectContainer::end
const_iterator end() const
Definition: EcalCondObjectContainer.h:90
EcalCleaningAlgo::setFlags
void setFlags(EcalRecHitCollection &rhs)
Definition: EcalCleaningAlgo.cc:266
EcalRecHitProducer::eeDetIdToBeRecoveredToken_
edm::EDGetTokenT< std::set< EEDetId > > eeDetIdToBeRecoveredToken_
Definition: EcalRecHitProducer.h:55
eostools.move
def move(src, dest)
Definition: eostools.py:510
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:303
EcalRecHitProducer::ebFEToBeRecoveredToken_
edm::EDGetTokenT< std::set< EcalTrigTowerDetId > > ebFEToBeRecoveredToken_
Definition: EcalRecHitProducer.h:56

Member Data Documentation

EcalCleaningAlgo* EcalRecHitProducer::cleaningAlgo_
private

Definition at line 50 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), produce(), and ~EcalRecHitProducer().

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

Definition at line 54 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

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

Definition at line 56 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

std::string EcalRecHitProducer::ebRechitCollection_
private

Definition at line 35 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

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

Definition at line 52 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

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

Definition at line 55 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

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

Definition at line 57 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

std::string EcalRecHitProducer::eeRechitCollection_
private

Definition at line 36 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

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

Definition at line 53 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::killDeadChannels_
private

Definition at line 44 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::recoverEBFE_
private

Definition at line 42 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::recoverEBIsolatedChannels_
private

Definition at line 38 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::recoverEBVFE_
private

Definition at line 40 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::recoverEEFE_
private

Definition at line 43 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::recoverEEIsolatedChannels_
private

Definition at line 39 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

bool EcalRecHitProducer::recoverEEVFE_
private

Definition at line 41 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), and produce().

EcalRecHitWorkerBaseClass* EcalRecHitProducer::worker_
private

Definition at line 47 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), produce(), and ~EcalRecHitProducer().

EcalRecHitWorkerBaseClass* EcalRecHitProducer::workerRecover_
private

Definition at line 48 of file EcalRecHitProducer.h.

Referenced by EcalRecHitProducer(), produce(), and ~EcalRecHitProducer().

Generated for CMSSW Reference Manual by doxygen 1.8.11