#include <MVAValueMapProducer.h>

Inheritance diagram for MVAValueMapProducer< ParticleType >:

Public Member Functions
	MVAValueMapProducer (const edm::ParameterSet &, const egamma::MVAObjectCache *)

	~MVAValueMapProducer ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< egamma::MVAObjectCache > >
	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 &	itemsToGetFrom (BranchType iType) 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 void	globalEndJob (const egamma::MVAObjectCache *)

static std::unique_ptr< egamma::MVAObjectCache >	initializeGlobalCache (const edm::ParameterSet &conf)

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 Member Functions
virtual void	produce (edm::Event &, const edm::EventSetup &) override

template<typename T >
void	writeValueMap (edm::Event &iEvent, const edm::Handle< edm::View< ParticleType > > &handle, const std::vector< T > &values, const std::string &label) const

Private Attributes
std::vector< std::string >	mvaCategoriesMapNames_

std::vector< std::string >	mvaValueMapNames_

edm::EDGetToken	src_

edm::EDGetToken	srcMiniAOD_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< egamma::MVAObjectCache > >
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

template<class ParticleType>
class MVAValueMapProducer< ParticleType >

Definition at line 22 of file MVAValueMapProducer.h.

Constructor & Destructor Documentation

template<class ParticleType >

MVAValueMapProducer< ParticleType >::MVAValueMapProducer	(	const edm::ParameterSet &	iConfig,
		const egamma::MVAObjectCache *	mva_cache
	)

Definition at line 64 of file MVAValueMapProducer.h.

References egamma::MVAObjectCache::allMVAs(), edm::EDConsumerBase::consumesCollector(), edm::ParameterSet::getParameter(), MVAValueMapProducer< ParticleType >::mvaCategoriesMapNames_, MVAValueMapProducer< ParticleType >::mvaValueMapNames_, MVAValueMapProducer< ParticleType >::src_, MVAValueMapProducer< ParticleType >::srcMiniAOD_, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
 
   //
   // Declare consummables, handle both AOD and miniAOD case
   //
   src_        = mayConsume<edm::View<ParticleType> >(iConfig.getParameter<edm::InputTag>("src"));
   srcMiniAOD_ = mayConsume<edm::View<ParticleType> >(iConfig.getParameter<edm::InputTag>("srcMiniAOD"));
 
   // Loop over the list of MVA configurations passed here from python and
   // construct all requested MVA esimtators.  
   const auto& all_mvas = mva_cache->allMVAs();
   for( auto mvaItr = all_mvas.begin(); mvaItr != all_mvas.end(); ++mvaItr ) {
     // set the consumes
     mvaItr->second->setConsumes(consumesCollector());
     //
     // Compose and save the names of the value maps to be produced
     //
     const auto& currentEstimator = mvaItr->second;
     const std::string full_name = ( currentEstimator->getName() + 
                                     currentEstimator->getTag()    );
     std::string thisValueMapName = full_name + "Values";
     std::string thisCategoriesMapName = full_name + "Categories";    
     mvaValueMapNames_.push_back( thisValueMapName );
     mvaCategoriesMapNames_.push_back( thisCategoriesMapName );
 
     // Declare the maps to the framework
     produces<edm::ValueMap<float> >(thisValueMapName);  
     produces<edm::ValueMap<int> >(thisCategoriesMapName);
   }
 
 
 }

template<class ParticleType >

MVAValueMapProducer< ParticleType >::~MVAValueMapProducer ( )

Definition at line 100 of file MVAValueMapProducer.h.

100 {

101 }

Member Function Documentation

template<class ParticleType >

void MVAValueMapProducer< ParticleType >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 165 of file MVAValueMapProducer.h.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

Referenced by MVAValueMapProducer< ParticleType >::globalEndJob().

                                                                                                      {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

template<class ParticleType >

static void MVAValueMapProducer< ParticleType >::globalEndJob ( const egamma::MVAObjectCache * )

inlinestatic

Definition at line 34 of file MVAValueMapProducer.h.

References MVAValueMapProducer< ParticleType >::fillDescriptions(), cmsBatch::handle, iEvent, diffTwoXMLs::label, MVAValueMapProducer< ParticleType >::produce(), AlCaHLTBitMon_QueryRunRegistry::string, MuonErrorMatrixValues_cff::values, and MVAValueMapProducer< ParticleType >::writeValueMap().

34 {

35 }

template<class ParticleType >

static std::unique_ptr<egamma::MVAObjectCache> MVAValueMapProducer< ParticleType >::initializeGlobalCache ( const edm::ParameterSet & conf )

inlinestatic

Definition at line 30 of file MVAValueMapProducer.h.

                                                      {
     return std::make_unique<egamma::MVAObjectCache>(conf);
    }

template<class ParticleType >

void MVAValueMapProducer< ParticleType >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Definition at line 104 of file MVAValueMapProducer.h.

References SoftLeptonByDistance_cfi::distance, edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), MVAValueMapProducer< ParticleType >::mvaCategoriesMapNames_, MVAValueMapProducer< ParticleType >::mvaValueMapNames_, TrackRefitter_38T_cff::src, MVAValueMapProducer< ParticleType >::src_, MVAValueMapProducer< ParticleType >::srcMiniAOD_, and MVAValueMapProducer< ParticleType >::writeValueMap().

Referenced by MVAValueMapProducer< ParticleType >::globalEndJob().

                                                                                              {
 
   using namespace edm;
   
   edm::Handle<edm::View<ParticleType> > src;
 
   // Retrieve the collection of particles from the event.
   // If we fail to retrieve the collection with the standard AOD
   // name, we next look for the one with the stndard miniAOD name.
   iEvent.getByToken(src_, src);
   if( !src.isValid() ){
     iEvent.getByToken(srcMiniAOD_,src);
     if( !src.isValid() )
       throw cms::Exception(" Collection not found: ")
     << " failed to find a standard AOD or miniAOD particle collection " << std::endl;
   }
 
  
   // Loop over MVA estimators
   const auto& all_mvas = globalCache()->allMVAs();
   for( auto mva_itr = all_mvas.begin(); mva_itr != all_mvas.end(); ++mva_itr ){    
     const int iEstimator = std::distance(all_mvas.begin(),mva_itr);
 
     // Set up all event content, such as ValueMaps produced upstream or other,
     // original event data pieces, that is needed (if any is implemented in the specific
     // MVA classes)
     const auto& thisEstimator = mva_itr->second;
 
     std::vector<float> mvaValues;
     std::vector<int> mvaCategories;
     
     // Loop over particles
     for (size_t i = 0; i < src->size(); ++i){
       auto iCand = src->ptrAt(i);      
       mvaValues.push_back( thisEstimator->mvaValue( iCand, iEvent ) );
       mvaCategories.push_back( thisEstimator->findCategory( iCand ) );
     } // end loop over particles
 
     writeValueMap(iEvent, src, mvaValues, mvaValueMapNames_[iEstimator] );  
     writeValueMap(iEvent, src, mvaCategories, mvaCategoriesMapNames_[iEstimator] );
   } // end loop over estimators
   
 
 }

template<class ParticleType >

template<typename T >

void MVAValueMapProducer< ParticleType >::writeValueMap	(	edm::Event &	iEvent,
		const edm::Handle< edm::View< ParticleType > > &	handle,
		const std::vector< T > &	values,
		const std::string &	label
	)		const

private

Definition at line 150 of file MVAValueMapProducer.h.

References objects.autophobj::filler, cmsBatch::handle, eostools::move(), and edm::Event::put().

Referenced by MVAValueMapProducer< ParticleType >::globalEndJob(), and MVAValueMapProducer< ParticleType >::produce().

 {
   using namespace edm; 
   using namespace std;
   auto valMap = std::make_unique<ValueMap<T>>();
   typename edm::ValueMap<T>::Filler filler(*valMap);
   filler.insert(handle, values.begin(), values.end());
   filler.fill();
   iEvent.put(std::move(valMap), label);
 }