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
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

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 53 of file CorrectedECALPFClusterProducer.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 55 of file CorrectedECALPFClusterProducer.cc.

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

                                                              :
     _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 138 of file CorrectedECALPFClusterProducer.cc.

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

                                                                                                 {
   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<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

Implements edm::stream::EDProducerBase.

Definition at line 85 of file CorrectedECALPFClusterProducer.cc.

References _corrector, _inputECAL, _inputPS, _minimumPSEnergy, PFLayer::ECAL_ENDCAP, edm::Event::getByToken(), i, edm::Ptr< T >::isNonnull(), edm::Ptr< T >::key(), PFLayer::PS1, PFLayer::PS2, edm::Event::put(), and python.multivaluedict::sort().

                                               {
   std::auto_ptr<reco::PFClusterCollection> clusters_out;
   clusters_out.reset(new reco::PFClusterCollection);    
   std::auto_ptr<reco::PFCluster::EEtoPSAssociation> association_out;
   association_out.reset(new reco::PFCluster::EEtoPSAssociation);
   
   edm::Handle<reco::PFClusterCollection> handleECAL;
   e.getByToken(_inputECAL,handleECAL);
   edm::Handle<reco::PFClusterCollection> handlePS;
   e.getByToken(_inputPS,handlePS);
   
   clusters_out->reserve(handleECAL->size());
   association_out->reserve(handleECAL->size());
   clusters_out->insert(clusters_out->end(),
                handleECAL->begin(),handleECAL->end());
   //build the EE->PS association
   double dist = -1.0, min_dist = -1.0;
   for( unsigned i = 0; i < handlePS->size(); ++i ) {      
     switch( handlePS->at(i).layer() ) { // just in case this isn't the ES...
     case PFLayer::PS1:
     case PFLayer::PS2:
       break;
     default:
       continue;
     }    
     edm::Ptr<reco::PFCluster> psclus(handlePS,i);
     if( psclus->energy() < _minimumPSEnergy ) continue;
     edm::Ptr<reco::PFCluster> eematch,eeclus;
     dist = min_dist = -1.0; // reset
     for( size_t ic = 0; ic < handleECAL->size(); ++ic ) {
       if( handleECAL->at(ic).layer() != PFLayer::ECAL_ENDCAP ) continue;
       eeclus = edm::Ptr<reco::PFCluster>(handleECAL,ic);    
       dist = testPreshowerDistance(eeclus,psclus);      
       if( dist == -1.0 || (min_dist != -1.0 && dist > min_dist) ) continue;
       if( dist < min_dist || min_dist == -1.0 ) {
     eematch = eeclus;
     min_dist = dist;
       }
     } // loop on EE clusters      
     if( eematch.isNonnull() ) {      
       association_out->push_back(std::make_pair(eematch.key(),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(association_out);
   e.put(clusters_out);
 }