Inheritance diagram for CorrectedECALPFClusterProducer:

Public Member Functions
	CorrectedECALPFClusterProducer (const edm::ParameterSet &conf)

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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
std::unique_ptr< PFClusterEMEnergyCorrector >	_corrector

edm::EDGetTokenT< reco::PFClusterCollection >	_inputECAL

edm::EDGetTokenT< reco::PFClusterCollection >	_inputPS

const double	_minimumPSEnergy

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

Definition at line 42 of file CorrectedECALPFClusterProducer.cc.

Constructor & Destructor Documentation

◆ CorrectedECALPFClusterProducer()

CorrectedECALPFClusterProducer::CorrectedECALPFClusterProducer ( const edm::ParameterSet & conf )

inline

Definition at line 44 of file CorrectedECALPFClusterProducer.cc.

       : _minimumPSEnergy(conf.getParameter<double>("minimumPSEnergy")) {
     const edm::InputTag& inputECAL = conf.getParameter<edm::InputTag>("inputECAL");
     _inputECAL = consumes<reco::PFClusterCollection>(inputECAL);
  
     const edm::InputTag& inputPS = conf.getParameter<edm::InputTag>("inputPS");
     _inputPS = consumes<reco::PFClusterCollection>(inputPS);
  
     const edm::ParameterSet& corConf = conf.getParameterSet("energyCorrector");
     _corrector.reset(new PFClusterEMEnergyCorrector(corConf, consumesCollector()));
  
     produces<reco::PFCluster::EEtoPSAssociation>();
     produces<reco::PFClusterCollection>();
   }

References _corrector, _inputECAL, _inputPS, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), HLT_2018_cff::inputECAL, and HLT_2018_cff::inputPS.

Member Function Documentation

◆ fillDescriptions()

void CorrectedECALPFClusterProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 125 of file CorrectedECALPFClusterProducer.cc.

                                                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<double>("minimumPSEnergy", 0.0);
   desc.add<edm::InputTag>("inputPS", edm::InputTag("particleFlowClusterPS"));
   {
     edm::ParameterSetDescription psd0;
     psd0.add<bool>("applyCrackCorrections", false);
     psd0.add<bool>("applyMVACorrections", false);
     psd0.add<bool>("srfAwareCorrection", false);
     psd0.add<bool>("setEnergyUncertainty", false);
     psd0.add<bool>("autoDetectBunchSpacing", true);
     psd0.add<int>("bunchSpacing", 25);
     psd0.add<double>("maxPtForMVAEvaluation", -99.);
     psd0.add<edm::InputTag>("recHitsEBLabel", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
     psd0.add<edm::InputTag>("recHitsEELabel", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
     psd0.add<edm::InputTag>("ebSrFlagLabel", edm::InputTag("ecalDigis"));
     psd0.add<edm::InputTag>("eeSrFlagLabel", edm::InputTag("ecalDigis"));
     desc.add<edm::ParameterSetDescription>("energyCorrector", psd0);
   }
   desc.add<edm::InputTag>("inputECAL", edm::InputTag("particleFlowClusterECALUncorrected"));
   descriptions.add("particleFlowClusterECAL", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_2018_cff::InputTag.

◆ produce()

void CorrectedECALPFClusterProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

override

Definition at line 71 of file CorrectedECALPFClusterProducer.cc.

                                                                                  {
   auto clusters_out = std::make_unique<reco::PFClusterCollection>();
   auto association_out = std::make_unique<reco::PFCluster::EEtoPSAssociation>();
  
   edm::Handle<reco::PFClusterCollection> handleECAL;
   e.getByToken(_inputECAL, handleECAL);
   edm::Handle<reco::PFClusterCollection> handlePS;
   e.getByToken(_inputPS, handlePS);
  
   auto const& ecals = *handleECAL;
   auto const& pss = *handlePS;
  
   clusters_out->reserve(ecals.size());
   association_out->reserve(ecals.size());
   clusters_out->insert(clusters_out->end(), ecals.begin(), ecals.end());
   //build the EE->PS association
   for (unsigned i = 0; i < pss.size(); ++i) {
     switch (pss[i].layer()) {  // just in case this isn't the ES...
       case PFLayer::PS1:
       case PFLayer::PS2:
         break;
       default:
         continue;
     }
     if (pss[i].energy() < _minimumPSEnergy)
       continue;
     int eematch = -1;
     auto min_dist = std::numeric_limits<double>::max();
     for (size_t ic = 0; ic < ecals.size(); ++ic) {
       if (ecals[ic].layer() != PFLayer::ECAL_ENDCAP)
         continue;
       auto dist = testPreshowerDistance(ecals[ic], pss[i]);
       if (dist == -1.0)
         dist = std::numeric_limits<double>::max();
       if (dist < min_dist) {
         eematch = ic;
         min_dist = dist;
       }
     }  // loop on EE clusters
     if (eematch >= 0) {
       edm::Ptr<reco::PFCluster> psclus(handlePS, i);
       association_out->push_back(std::make_pair(eematch, psclus));
     }
   }
   std::sort(association_out->begin(), association_out->end(), sortByKey);
  
   _corrector->correctEnergies(e, es, *association_out, *clusters_out);
  
   association_out->shrink_to_fit();
  
   e.put(std::move(association_out));
   e.put(std::move(clusters_out));
 }