#include <RecoHI/HiSpikeCleaner/src/HiSpikeCleaner.cc>

Inheritance diagram for HiSpikeCleaner:

Public Member Functions
	HiSpikeCleaner (const edm::ParameterSet &)

	~HiSpikeCleaner () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
double	etCut_

std::string	outputCollection_

edm::EDGetTokenT< EcalRecHitCollection >	rHInputProducerBToken_

edm::EDGetTokenT< EcalRecHitCollection >	rHInputProducerEToken_

edm::EDGetTokenT< reco::SuperClusterCollection >	sCInputProducerToken_

double	swissCutThr_

double	TimingCut_

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

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 46 of file HiSpikeCleaner.cc.

Constructor & Destructor Documentation

◆ HiSpikeCleaner()

HiSpikeCleaner::HiSpikeCleaner ( const edm::ParameterSet & iConfig )

explicit

Definition at line 66 of file HiSpikeCleaner.cc.

                                                              {
   //register your products
   /* Examples
    produces<ExampleData2>();
  
    //if do put with a label
    produces<ExampleData2>("label");
 */
   //now do what ever other initialization is needed
  
   rHInputProducerBToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitProducerBarrel"));
   rHInputProducerEToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitProducerEndcap"));
  
   sCInputProducerToken_ =
       consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("originalSuperClusterProducer"));
   TimingCut_ = iConfig.getUntrackedParameter<double>("TimingCut", 4.0);
   swissCutThr_ = iConfig.getUntrackedParameter<double>("swissCutThr", 0.95);
   etCut_ = iConfig.getParameter<double>("etCut");
  
   outputCollection_ = iConfig.getParameter<std::string>("outputColl");
   produces<reco::SuperClusterCollection>(outputCollection_);
 }

References etCut_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), outputCollection_, rHInputProducerBToken_, rHInputProducerEToken_, sCInputProducerToken_, AlCaHLTBitMon_QueryRunRegistry::string, swissCutThr_, and TimingCut_.

◆ ~HiSpikeCleaner()

HiSpikeCleaner::~HiSpikeCleaner ( )

override

Definition at line 89 of file HiSpikeCleaner.cc.

                                 {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ produce()

void HiSpikeCleaner::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 99 of file HiSpikeCleaner.cc.

                                                                           {
   using namespace edm;
  
   // Get raw SuperClusters from the event
   Handle<reco::SuperClusterCollection> pRawSuperClusters;
   try {
     iEvent.getByToken(sCInputProducerToken_, pRawSuperClusters);
   } catch (cms::Exception& ex) {
     edm::LogError("EgammaSCCorrectionMakerError") << "Error! can't get the rawSuperClusters ";
   }
  
   // Get the RecHits from the event
   Handle<EcalRecHitCollection> pRecHitsB;
   try {
     iEvent.getByToken(rHInputProducerBToken_, pRecHitsB);
   } catch (cms::Exception& ex) {
     edm::LogError("EgammaSCCorrectionMakerError") << "Error! can't get the RecHits ";
   }
  
   // Get the RecHits from the event
   Handle<EcalRecHitCollection> pRecHitsE;
   try {
     iEvent.getByToken(rHInputProducerEToken_, pRecHitsE);
   } catch (cms::Exception& ex) {
     edm::LogError("EgammaSCCorrectionMakerError") << "Error! can't get the RecHits ";
   }
  
   // get the channel status from the DB
   //   edm::ESHandle<EcalChannelStatus> chStatus;
   //   iSetup.get<EcalChannelStatusRcd>().get(chStatus);
  
   edm::ESHandle<EcalSeverityLevelAlgo> ecalSevLvlAlgoHndl;
   iSetup.get<EcalSeverityLevelAlgoRcd>().get(ecalSevLvlAlgoHndl);
  
   // Create a pointer to the RecHits and raw SuperClusters
   const reco::SuperClusterCollection* rawClusters = pRawSuperClusters.product();
  
   EcalClusterLazyTools lazyTool(iEvent, iSetup, rHInputProducerBToken_, rHInputProducerEToken_);
  
   // Define a collection of corrected SuperClusters to put back into the event
   auto corrClusters = std::make_unique<reco::SuperClusterCollection>();
  
   //  Loop over raw clusters and make corrected ones
   reco::SuperClusterCollection::const_iterator aClus;
   for (aClus = rawClusters->begin(); aClus != rawClusters->end(); aClus++) {
     double theEt = aClus->energy() / cosh(aClus->eta());
     //   std::cout << " et of SC = " << theEt << std::endl;
  
     if (theEt < etCut_)
       continue;  // cut off low pT superclusters
  
     bool flagS = true;
     float swissCrx(0);
  
     const reco::CaloClusterPtr seed = aClus->seed();
     DetId id = lazyTool.getMaximum(*seed).first;
     const EcalRecHitCollection& rechits = *pRecHitsB;
     EcalRecHitCollection::const_iterator it = rechits.find(id);
  
     if (it != rechits.end()) {
       ecalSevLvlAlgoHndl->severityLevel(id, rechits);
       swissCrx = EcalTools::swissCross(id, rechits, 0., true);
       //        std::cout << "swissCross = " << swissCrx <<std::endl;
       // std::cout << " timing = " << it->time() << std::endl;
     }
  
     if (fabs(it->time()) > TimingCut_) {
       flagS = false;
       //        std::cout << " timing = " << it->time() << std::endl;
       //   std::cout << " timing is bad........" << std::endl;
     }
     if (swissCrx > (float)swissCutThr_) {
       flagS = false;  // swissCross cut
                       //        std::cout << "swissCross = " << swissCrx <<std::endl;
                       //   std::cout << " removed by swiss cross cut" << std::endl;
     }
     // - kGood        --> good channel
     // - kProblematic --> problematic (e.g. noisy)
     // - kRecovered   --> recovered (e.g. an originally dead or saturated)
     // - kTime        --> the channel is out of time (e.g. spike)
     // - kWeird       --> weird (e.g. spike)
     // - kBad         --> bad, not suitable to be used in the reconstruction
     //   enum EcalSeverityLevel { kGood=0, kProblematic, kRecovered, kTime, kWeird, kBad };
  
     reco::SuperCluster newClus;
     if (flagS == true)
       newClus = *aClus;
     else
       continue;
     corrClusters->push_back(newClus);
   }
  
   // Put collection of corrected SuperClusters into the event
   iEvent.put(std::move(corrClusters), outputCollection_);
 }