#include <LowPtGsfElectronIDProducer.h>

Inheritance diagram for LowPtGsfElectronIDProducer:

Public Member Functions
	LowPtGsfElectronIDProducer (const edm::ParameterSet &, const lowptgsfeleid::HeavyObjectCache *)

void	produce (edm::Event &, const edm::EventSetup &) override

	~LowPtGsfElectronIDProducer () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

static void	globalEndJob (lowptgsfeleid::HeavyObjectCache const *)

static std::unique_ptr< lowptgsfeleid::HeavyObjectCache >	initializeGlobalCache (const edm::ParameterSet &conf)

Private Attributes
const edm::EDGetTokenT< reco::GsfElectronCollection >	gsfElectrons_

const double	maxPtThreshold_

const double	minPtThreshold_

const std::vector< std::string >	names_

const bool	passThrough_

const edm::EDGetTokenT< double >	rho_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleid::HeavyObjectCache > >
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 12 of file LowPtGsfElectronIDProducer.h.

Constructor & Destructor Documentation

LowPtGsfElectronIDProducer::LowPtGsfElectronIDProducer	(	const edm::ParameterSet &	conf,
		const lowptgsfeleid::HeavyObjectCache *
	)

explicit

Definition at line 11 of file LowPtGsfElectronIDProducer.cc.

References dataset::name, and names_.

                                                                    :
   gsfElectrons_(consumes<reco::GsfElectronCollection>(conf.getParameter<edm::InputTag>("electrons"))),
   rho_(consumes<double>(conf.getParameter<edm::InputTag>("rho"))),
   names_(conf.getParameter< std::vector<std::string> >("ModelNames")),
   passThrough_(conf.getParameter<bool>("PassThrough")),
   minPtThreshold_(conf.getParameter<double>("MinPtThreshold")),
   maxPtThreshold_(conf.getParameter<double>("MaxPtThreshold"))
 {
   for ( const auto& name : names_ ) {
     produces< edm::ValueMap<float> >(name);
   }
 }

LowPtGsfElectronIDProducer::~LowPtGsfElectronIDProducer ( )

override

Definition at line 27 of file LowPtGsfElectronIDProducer.cc.

27 {}

Member Function Documentation

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

static

Definition at line 70 of file LowPtGsfElectronIDProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and DEFINE_FWK_MODULE.

Referenced by globalEndJob().

 {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("electrons",edm::InputTag("lowPtGsfElectrons"));
   desc.add<edm::InputTag>("rho",edm::InputTag("fixedGridRhoFastjetAllTmp"));
   desc.add< std::vector<std::string> >("ModelNames",std::vector<std::string>());
   desc.add< std::vector<std::string> >("ModelWeights",std::vector<std::string>());
   desc.add< std::vector<double> >("ModelThresholds",std::vector<double>());
   desc.add<bool>("PassThrough",false);
   desc.add<double>("MinPtThreshold",0.5);
   desc.add<double>("MaxPtThreshold",15.);
   descriptions.add("defaultLowPtGsfElectronID",desc);
 }

static void LowPtGsfElectronIDProducer::globalEndJob ( lowptgsfeleid::HeavyObjectCache const * )

inlinestatic

Definition at line 27 of file LowPtGsfElectronIDProducer.h.

References fillDescriptions(), and produce().

27 {}

static std::unique_ptr<lowptgsfeleid::HeavyObjectCache> LowPtGsfElectronIDProducer::initializeGlobalCache ( const edm::ParameterSet & conf )

inlinestatic

Definition at line 23 of file LowPtGsfElectronIDProducer.h.

                                                          {
     return std::make_unique<lowptgsfeleid::HeavyObjectCache>(lowptgsfeleid::HeavyObjectCache(conf));
   }

void LowPtGsfElectronIDProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 31 of file LowPtGsfElectronIDProducer.cc.

References begin, end, edm::helper::Filler< Map >::fill(), objects.autophobj::filler, gsfElectrons_cfi::gsfElectrons, gsfElectrons_, edm::helper::Filler< Map >::insert(), edm::HandleBase::isValid(), eostools::move(), names_, convertSQLitetoXML_cfg::output, rho, and rho_.

Referenced by globalEndJob().

                                                                                       {
 
   // Pileup
   edm::Handle<double> rho;
   event.getByToken(rho_,rho);
   if ( !rho.isValid() ) { edm::LogError("Problem with rho handle"); }
 
   // Retrieve GsfElectrons from Event
   edm::Handle<reco::GsfElectronCollection> gsfElectrons;
   event.getByToken(gsfElectrons_,gsfElectrons);
   if ( !gsfElectrons.isValid() ) { edm::LogError("Problem with gsfElectrons handle"); }
 
   // Iterate through Electrons, evaluate BDT, and store result
   std::vector< std::vector<float> > output;
   for ( unsigned int iname = 0; iname < names_.size(); ++iname ) { 
     output.push_back( std::vector<float>(gsfElectrons->size(),-999.) );
   }
   for ( unsigned int iele = 0; iele < gsfElectrons->size(); iele++ ) {
     reco::GsfElectronRef ele(gsfElectrons,iele);
     //if ( !passThrough_ && ( ele->pt() < minPtThreshold_ ) ) { continue; }
     for ( unsigned int iname = 0; iname < names_.size(); ++iname ) {
       output[iname][iele] = globalCache()->eval( names_[iname], ele, *rho );
     }
   }
   
   // Create and put ValueMap in Event
   for ( unsigned int iname = 0; iname < names_.size(); ++iname ) { 
     auto ptr = std::make_unique< edm::ValueMap<float> >( edm::ValueMap<float>() );
     edm::ValueMap<float>::Filler filler(*ptr);
     filler.insert(gsfElectrons, output[iname].begin(), output[iname].end());
     filler.fill();
     reco::GsfElectronRef ele(gsfElectrons,0);
     event.put(std::move(ptr),names_[iname]);
   }
   
 }