Inheritance diagram for CorrectedECALPFClusterProducer:

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

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

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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, edm::EDConsumerBase::consumesCollector(), MillePedeFileConverter_cfg::e, fillDescriptions(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), particleFlowCluster_cff::inputECAL, particleFlowClusterECAL_cfi::inputPS, 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<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<bool>("autoDetectBunchSpacing",true);
     psd0.add<int>("bunchSpacing",25);
     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
	)

virtual

Definition at line 74 of file CorrectedECALPFClusterProducer.cc.

References _corrector, _inputECAL, _inputPS, _minimumPSEnergy, PFLayer::ECAL_ENDCAP, edm::Event::getByToken(), mps_fire::i, hpstanc_transforms::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));
 }