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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 ( const edm::ParameterSet & conf )

inline

Definition at line 44 of file CorrectedECALPFClusterProducer.cc.

References _corrector, _inputECAL, _inputPS, MillePedeFileConverter_cfg::e, fillDescriptions(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), particleFlowCluster_cff::inputECAL, and produce().

                                                              :
     _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>();
   }

Member Function Documentation

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

static

Definition at line 126 of file CorrectedECALPFClusterProducer.cc.

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

Referenced by CorrectedECALPFClusterProducer().

                                                                                                 {
   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>("autoDetectBunchSpacing",true);
     psd0.add<int>("bunchSpacing",25);
     psd0.add<double>("maxPtForMVAEvaluation",-99.);
     psd0.add<std::string>("algoName","PFClusterEMEnergyCorrector");
     psd0.add<edm::InputTag>("recHitsEBLabel",edm::InputTag("ecalRecHit","EcalRecHitsEB"));
     psd0.add<edm::InputTag>("recHitsEELabel",edm::InputTag("ecalRecHit","EcalRecHitsEE"));
     psd0.add<edm::InputTag>("verticesLabel",edm::InputTag("offlinePrimaryVertices"));
     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);
 }

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

override

Definition at line 74 of file CorrectedECALPFClusterProducer.cc.

References _corrector, _inputECAL, _inputPS, _minimumPSEnergy, PFLayer::ECAL_ENDCAP, edm::Event::getByToken(), mps_fire::i, SiStripPI::max, eostools::move(), PFLayer::PS1, PFLayer::PS2, edm::Event::put(), and sortByKey().

Referenced by CorrectedECALPFClusterProducer().

                                               {
   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));
 }