#include <HiEgammaSCCorrectionMaker/HiEgammaSCCorrectionMaker/src/HiEgammaSCCorrectionMaker.cc>

Inheritance diagram for HiEgammaSCCorrectionMaker:

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

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

	~HiEgammaSCCorrectionMaker () 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

Private Attributes
bool	applyEnergyCorrection_

std::unique_ptr< HiEgammaSCEnergyCorrectionAlgo >	energyCorrector_

double	etThresh_

std::string	outputCollection_

edm::EDGetTokenT< EcalRecHitCollection >	rHInputProducer_

edm::InputTag	rHInputProducerTag_

reco::CaloCluster::AlgoId	sCAlgo_

edm::EDGetTokenT< reco::SuperClusterCollection >	sCInputProducer_

edm::InputTag	sCInputProducerTag_

double	sigmaElectronicNoise_

edm::ESHandle< CaloTopology >	theCaloTopo_

HiEgammaSCEnergyCorrectionAlgo::VerbosityLevel	verbosity_

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

Description: Producer of corrected SuperClusters

Definition at line 37 of file HiEgammaSCCorrectionMaker.h.

Constructor & Destructor Documentation

◆ HiEgammaSCCorrectionMaker()

HiEgammaSCCorrectionMaker::HiEgammaSCCorrectionMaker ( const edm::ParameterSet & ps )

explicit

Definition at line 24 of file HiEgammaSCCorrectionMaker.cc.

                                                                               {
   // The verbosity level
   std::string debugString = ps.getParameter<std::string>("VerbosityLevel");
   if (debugString == "DEBUG")
     verbosity_ = HiEgammaSCEnergyCorrectionAlgo::pDEBUG;
   else if (debugString == "INFO")
     verbosity_ = HiEgammaSCEnergyCorrectionAlgo::pINFO;
   else
     verbosity_ = HiEgammaSCEnergyCorrectionAlgo::pERROR;
  
   // the input producers
   rHInputProducerTag_ = ps.getParameter<edm::InputTag>("recHitProducer");
   sCInputProducerTag_ = ps.getParameter<edm::InputTag>("rawSuperClusterProducer");
   rHInputProducer_ = consumes<EcalRecHitCollection>(rHInputProducerTag_);
   sCInputProducer_ = consumes<reco::SuperClusterCollection>(sCInputProducerTag_);
   std::string sCAlgo_str = ps.getParameter<std::string>("superClusterAlgo");
  
   // determine which BasicCluster algo we are correcting for
   //And obtain forrection parameters form cfg file
   edm::ParameterSet fCorrPset;
   if (sCAlgo_str == "Hybrid") {
     sCAlgo_ = reco::CaloCluster::hybrid;
     fCorrPset = ps.getParameter<edm::ParameterSet>("hyb_fCorrPset");
   } else if (sCAlgo_str == "Island") {
     sCAlgo_ = reco::CaloCluster::island;
     fCorrPset = ps.getParameter<edm::ParameterSet>("isl_fCorrPset");
   } else if (sCAlgo_str == "DynamicHybrid") {
     sCAlgo_ = reco::CaloCluster::dynamicHybrid;
     fCorrPset = ps.getParameter<edm::ParameterSet>("dyn_fCorrPset");
   } else if (sCAlgo_str == "Multi5x5") {
     sCAlgo_ = reco::CaloCluster::multi5x5;
     fCorrPset = ps.getParameter<edm::ParameterSet>("fix_fCorrPset");
   } else {
     edm::LogError("HiEgammaSCCorrectionMakerError")
         << "Error! SuperClusterAlgo in config file must be Hybrid or Island: " << sCAlgo_str
         << "  Using Hybrid by default";
     sCAlgo_ = reco::CaloCluster::hybrid;
   }
  
   // set correction algo parameters
   applyEnergyCorrection_ = ps.getParameter<bool>("applyEnergyCorrection");
   sigmaElectronicNoise_ = ps.getParameter<double>("sigmaElectronicNoise");
  
   etThresh_ = ps.getParameter<double>("etThresh");
  
   // set the producer parameters
   outputCollection_ = ps.getParameter<std::string>("corectedSuperClusterCollection");
   produces<reco::SuperClusterCollection>(outputCollection_);
  
   // instanciate the correction algo object
   energyCorrector_ = std::make_unique<HiEgammaSCEnergyCorrectionAlgo>(sigmaElectronicNoise_, fCorrPset, verbosity_);
 }

References applyEnergyCorrection_, reco::CaloCluster::dynamicHybrid, energyCorrector_, etThresh_, edm::ParameterSet::getParameter(), reco::CaloCluster::hybrid, reco::CaloCluster::island, reco::CaloCluster::multi5x5, outputCollection_, HiEgammaSCEnergyCorrectionAlgo::pDEBUG, HiEgammaSCEnergyCorrectionAlgo::pERROR, HiEgammaSCEnergyCorrectionAlgo::pINFO, rHInputProducer_, rHInputProducerTag_, sCAlgo_, sCInputProducer_, sCInputProducerTag_, sigmaElectronicNoise_, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity_.

◆ ~HiEgammaSCCorrectionMaker()

HiEgammaSCCorrectionMaker::~HiEgammaSCCorrectionMaker ( )

overridedefault

Member Function Documentation

◆ produce()

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

override

Definition at line 79 of file HiEgammaSCCorrectionMaker.cc.

                                                                               {
   using namespace edm;
  
   // get the collection geometry:
   edm::ESHandle<CaloGeometry> geoHandle;
   es.get<CaloGeometryRecord>().get(geoHandle);
   const CaloGeometry& geometry = *geoHandle;
   const CaloSubdetectorGeometry* geometry_p;
  
   edm::ESHandle<CaloTopology> pTopology;
   es.get<CaloTopologyRecord>().get(theCaloTopo_);
   const CaloTopology& topology = *theCaloTopo_;
  
   std::string rHInputCollection = rHInputProducerTag_.instance();
   if (rHInputCollection == "EcalRecHitsEB") {
     geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
   } else if (rHInputCollection == "EcalRecHitsEE") {
     geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
   } else if (rHInputCollection == "EcalRecHitsPS") {
     geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
   } else {
     std::string str =
         "\n\nSCCorrectionMaker encountered invalied ecalhitcollection type: " + rHInputCollection + ".\n\n";
     throw(std::runtime_error(str.c_str()));
   }
  
   // Get raw SuperClusters from the event
   Handle<reco::SuperClusterCollection> pRawSuperClusters;
   try {
     evt.getByToken(sCInputProducer_, pRawSuperClusters);
   } catch (cms::Exception& ex) {
     edm::LogError("HiEgammaSCCorrectionMakerError")
         << "Error! can't get the rawSuperClusters " << sCInputProducerTag_.label();
   }
  
   // Get the RecHits from the event
   Handle<EcalRecHitCollection> pRecHits;
   try {
     evt.getByToken(rHInputProducer_, pRecHits);
   } catch (cms::Exception& ex) {
     edm::LogError("HiEgammaSCCorrectionMakerError") << "Error! can't get the RecHits " << rHInputProducerTag_.label();
   }
  
   // Create a pointer to the RecHits and raw SuperClusters
   const EcalRecHitCollection* hitCollection = pRecHits.product();
   const reco::SuperClusterCollection* rawClusters = pRawSuperClusters.product();
  
   // 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++) {
     reco::SuperCluster newClus;
     if (applyEnergyCorrection_)
       newClus = energyCorrector_->applyCorrection(*aClus, *hitCollection, sCAlgo_, *geometry_p, topology);
     else
       newClus = *aClus;
  
     if (newClus.energy() * sin(newClus.position().theta()) > etThresh_) {
       corrClusters->push_back(newClus);
     }
   }
   // Put collection of corrected SuperClusters into the event
   evt.put(std::move(corrClusters), outputCollection_);
 }