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

Inheritance diagram for EgammaSCCorrectionMaker:

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

void	produce (edm::Event &, const edm::EventSetup &) 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	applyCrackCorrection_

bool	applyEnergyCorrection_

bool	applyLocalContCorrection_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeomToken_

std::unique_ptr< EcalClusterFunctionBaseClass >	crackCorrectionFunction_

std::string	crackCorrectorName_

std::unique_ptr< EcalClusterFunctionBaseClass >	energyCorrectionFunction_

std::unique_ptr< EgammaSCEnergyCorrectionAlgo >	energyCorrector_

std::string	energyCorrectorName_

double	etThresh_

std::unique_ptr< EcalBasicClusterLocalContCorrection >	localContCorrectionFunction_

int	modeEB_

int	modeEE_

std::string	outputCollection_

edm::EDGetTokenT< EcalRecHitCollection >	rHInputProducer_

edm::InputTag	rHTag_

reco::CaloCluster::AlgoId	sCAlgo_

edm::EDGetTokenT< reco::SuperClusterCollection >	sCInputProducer_

double	sigmaElectronicNoise_

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 46 of file EgammaSCCorrectionMaker.cc.

Constructor & Destructor Documentation

◆ EgammaSCCorrectionMaker()

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

explicit

Definition at line 87 of file EgammaSCCorrectionMaker.cc.

References applyCrackCorrection_, applyEnergyCorrection_, applyLocalContCorrection_, caloGeomToken_, crackCorrectionFunction_, crackCorrectorName_, reco::CaloCluster::dynamicHybrid, energyCorrectionFunction_, energyCorrector_, energyCorrectorName_, deDxTools::esConsumes(), etThresh_, edm::ParameterSet::existsAs(), get, edm::ParameterSet::getParameter(), reco::CaloCluster::hybrid, reco::CaloCluster::island, localContCorrectionFunction_, modeEB_, modeEE_, reco::CaloCluster::multi5x5, outputCollection_, rHInputProducer_, rHTag_, sCAlgo_, sCInputProducer_, sigmaElectronicNoise_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
   // the input producers
   rHTag_ = ps.getParameter<edm::InputTag>("recHitProducer");
   rHInputProducer_ = consumes<EcalRecHitCollection>(rHTag_);
   sCInputProducer_ = consumes<reco::SuperClusterCollection>(ps.getParameter<edm::InputTag>("rawSuperClusterProducer"));
   caloGeomToken_ = esConsumes();
   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("EgammaSCCorrectionMakerError")
         << "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");
   applyCrackCorrection_ = ps.getParameter<bool>("applyCrackCorrection");
   applyLocalContCorrection_ =
       ps.existsAs<bool>("applyLocalContCorrection") ? ps.getParameter<bool>("applyLocalContCorrection") : false;
 
   energyCorrectorName_ = ps.getParameter<std::string>("energyCorrectorName");
   crackCorrectorName_ = ps.existsAs<std::string>("crackCorrectorName")
                             ? ps.getParameter<std::string>("crackCorrectorName")
                             : std::string("EcalClusterCrackCorrection");
 
   modeEB_ = ps.getParameter<int>("modeEB");
   modeEE_ = ps.getParameter<int>("modeEE");
 
   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<EgammaSCEnergyCorrectionAlgo>(sigmaElectronicNoise_);
 
   // energy correction class
   if (applyEnergyCorrection_)
     energyCorrectionFunction_ =
         EcalClusterFunctionFactory::get()->create(energyCorrectorName_, ps, consumesCollector());
   //energyCorrectionFunction_ = EcalClusterFunctionFactory::get()->create("EcalClusterEnergyCorrection", ps);
 
   if (applyCrackCorrection_)
     crackCorrectionFunction_ = EcalClusterFunctionFactory::get()->create(crackCorrectorName_, ps, consumesCollector());
 
   if (applyLocalContCorrection_)
     localContCorrectionFunction_ = std::make_unique<EcalBasicClusterLocalContCorrection>(consumesCollector());
 }

Member Function Documentation

◆ produce()

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

override

Definition at line 155 of file EgammaSCCorrectionMaker.cc.

References EgammaSCEnergyCorrectionAlgo::applyCrackCorrection(), applyCrackCorrection_, applyEnergyCorrection_, EgammaSCEnergyCorrectionAlgo::applyLocalContCorrection(), applyLocalContCorrection_, caloGeomToken_, crackCorrectionFunction_, DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, reco::CaloCluster::energy(), energyCorrectionFunction_, energyCorrector_, energyCorrectorName_, etThresh_, edm::Event::getByToken(), edm::EventSetup::getData(), hgceeDigitizer_cfi::hitCollection, edm::InputTag::instance(), localContCorrectionFunction_, modeEB_, modeEE_, eostools::move(), outputCollection_, reco::CaloCluster::position(), edm::Handle< T >::product(), edm::Event::put(), rHInputProducer_, rHTag_, sCAlgo_, sCInputProducer_, funct::sin(), str, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                             {
   using namespace edm;
 
   // initialize energy correction class
   if (applyEnergyCorrection_)
     energyCorrectionFunction_->init(es);
 
   // initialize energy correction class
   if (applyCrackCorrection_)
     crackCorrectionFunction_->init(es);
 
   // initialize containemnt correction class
   if (applyLocalContCorrection_)
     localContCorrectionFunction_->init(es);
 
   // get the collection geometry:
   const CaloGeometry& geometry = es.getData(caloGeomToken_);
   const CaloSubdetectorGeometry* geometry_p;
 
   std::string rHInputCollection = rHTag_.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;
   evt.getByToken(sCInputProducer_, pRawSuperClusters);
 
   // Get the RecHits from the event
   Handle<EcalRecHitCollection> pRecHits;
   evt.getByToken(rHInputProducer_, pRecHits);
 
   // 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 enecorrClus, crackcorrClus, localContCorrClus;
 
     if (applyEnergyCorrection_)
       enecorrClus = energyCorrector_->applyCorrection(*aClus,
                                                       *hitCollection,
                                                       sCAlgo_,
                                                       geometry_p,
                                                       energyCorrectionFunction_.get(),
                                                       energyCorrectorName_,
                                                       modeEB_,
                                                       modeEE_);
     else
       enecorrClus = *aClus;
 
     if (applyCrackCorrection_)
       crackcorrClus = EgammaSCEnergyCorrectionAlgo::applyCrackCorrection(enecorrClus, crackCorrectionFunction_.get());
     else
       crackcorrClus = enecorrClus;
 
     if (applyLocalContCorrection_)
       localContCorrClus =
           EgammaSCEnergyCorrectionAlgo::applyLocalContCorrection(crackcorrClus, *localContCorrectionFunction_);
     else
       localContCorrClus = crackcorrClus;
 
     if (localContCorrClus.energy() * sin(localContCorrClus.position().theta()) > etThresh_) {
       corrClusters->push_back(localContCorrClus);
     }
   }
 
   // Put collection of corrected SuperClusters into the event
   evt.put(std::move(corrClusters), outputCollection_);
 }