Inheritance diagram for ElectronRegressionEnergyProducer:

Public Member Functions
	ElectronRegressionEnergyProducer (const edm::ParameterSet &)

	~ElectronRegressionEnergyProducer ()

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

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)

Private Member Functions
virtual bool	filter (edm::Event &, const edm::EventSetup &)

Private Attributes
const CaloGeometry *	caloGeometry_

const CaloTopology *	ecalTopology_

edm::EDGetTokenT< reco::GsfElectronCollection >	electronToken_

uint32_t	energyRegressionType_

bool	geomInitialized_

edm::EDGetTokenT< double >	hRhoKt6PFJetsToken_

edm::EDGetTokenT< reco::VertexCollection >	hVertexToken_

std::string	nameEnergyErrorReg_

std::string	nameEnergyReg_

bool	printDebug_

edm::EDGetTokenT< EcalRecHitCollection >	recHitCollectionEBToken_

edm::EDGetTokenT< EcalRecHitCollection >	recHitCollectionEEToken_

ElectronEnergyRegressionEvaluate *	regressionEvaluator

std::string	regressionInputFile_

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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 30 of file ElectronRegressionEnergyProducer.cc.

Constructor & Destructor Documentation

ElectronRegressionEnergyProducer::ElectronRegressionEnergyProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 63 of file ElectronRegressionEnergyProducer.cc.

References electronToken_, energyRegressionType_, geomInitialized_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hRhoKt6PFJetsToken_, hVertexToken_, ElectronEnergyRegressionEvaluate::kNoTrkVar, ElectronEnergyRegressionEvaluate::kWithSubCluVar, ElectronEnergyRegressionEvaluate::kWithTrkVarV1, ElectronEnergyRegressionEvaluate::kWithTrkVarV2, nameEnergyErrorReg_, nameEnergyReg_, printDebug_, recHitCollectionEBToken_, recHitCollectionEEToken_, regressionEvaluator, regressionInputFile_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                  {
   printDebug_  = iConfig.getUntrackedParameter<bool>("printDebug", false);
   electronToken_ = consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("electronTag"));
 
   regressionInputFile_  = iConfig.getParameter<std::string>("regressionInputFile");
   energyRegressionType_ = iConfig.getParameter<uint32_t>("energyRegressionType");
 
   nameEnergyReg_      = iConfig.getParameter<std::string>("nameEnergyReg");
   nameEnergyErrorReg_ = iConfig.getParameter<std::string>("nameEnergyErrorReg");
 
   recHitCollectionEBToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitCollectionEB"));
   recHitCollectionEEToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitCollectionEE"));
 
   hVertexToken_ = consumes<reco::VertexCollection>(edm::InputTag("offlinePrimaryVertices"));
   hRhoKt6PFJetsToken_ = consumes<double>(edm::InputTag("kt6PFJets","rho"));
 
   produces<edm::ValueMap<double> >(nameEnergyReg_);
   produces<edm::ValueMap<double> >(nameEnergyErrorReg_);
 
   regressionEvaluator = new ElectronEnergyRegressionEvaluate();
 
   //set regression type
   ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type = ElectronEnergyRegressionEvaluate::kNoTrkVar;
   if (energyRegressionType_ == 1) type = ElectronEnergyRegressionEvaluate::kNoTrkVar;
   else if (energyRegressionType_ == 2) type = ElectronEnergyRegressionEvaluate::kWithSubCluVar;
   else if (energyRegressionType_ == 3) type = ElectronEnergyRegressionEvaluate::kWithTrkVarV1;
   else if (energyRegressionType_ == 4) type = ElectronEnergyRegressionEvaluate::kWithTrkVarV2;
 
   //load weights and initialize
   regressionEvaluator->initialize(regressionInputFile_.c_str(),type);
 
   geomInitialized_ = false;
 
 }

ElectronRegressionEnergyProducer::~ElectronRegressionEnergyProducer ( )

Definition at line 99 of file ElectronRegressionEnergyProducer.cc.

References regressionEvaluator.

 {
   delete regressionEvaluator;
 }

Member Function Documentation

bool ElectronRegressionEnergyProducer::filter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Definition at line 105 of file ElectronRegressionEnergyProducer.cc.

References ElectronEnergyRegressionEvaluate::calculateRegressionEnergy(), ElectronEnergyRegressionEvaluate::calculateRegressionEnergyUncertainty(), caloGeometry_, DEFINE_FWK_MODULE, ecalTopology_, electronToken_, relativeConstraints::error, edm::helper::Filler< Map >::fill(), geomInitialized_, edm::EventSetup::get(), edm::Event::getByToken(), hRhoKt6PFJetsToken_, hVertexToken_, edm::helper::Filler< Map >::insert(), ElectronEnergyRegressionEvaluate::isInitialized(), eostools::move(), nameEnergyErrorReg_, nameEnergyReg_, printDebug_, edm::Handle< T >::product(), edm::Event::put(), recHitCollectionEBToken_, recHitCollectionEEToken_, regressionEvaluator, and rho.

Referenced by Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::filter(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::setDataAccessor(), and Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::switchCenterView().

                                                                                            {
 
   assert(regressionEvaluator->isInitialized());
 
   if (!geomInitialized_) {
     edm::ESHandle<CaloTopology> theCaloTopology;
     iSetup.get<CaloTopologyRecord>().get(theCaloTopology);
     ecalTopology_ = & (*theCaloTopology);
 
     edm::ESHandle<CaloGeometry> theCaloGeometry;
     iSetup.get<CaloGeometryRecord>().get(theCaloGeometry);
     caloGeometry_ = & (*theCaloGeometry);
     geomInitialized_ = true;
   }
 
   std::unique_ptr<edm::ValueMap<double> > regrEnergyMap(new edm::ValueMap<double>() );
   edm::ValueMap<double>::Filler energyFiller(*regrEnergyMap);
 
   std::unique_ptr<edm::ValueMap<double> > regrEnergyErrorMap(new edm::ValueMap<double>() );
   edm::ValueMap<double>::Filler energyErrorFiller(*regrEnergyErrorMap);
 
   edm::Handle<reco::GsfElectronCollection> egCollection;
   iEvent.getByToken(electronToken_,egCollection);
   const reco::GsfElectronCollection egCandidates = (*egCollection.product());
 
   std::vector<double> energyValues;
   std::vector<double> energyErrorValues;
   energyValues.reserve(egCollection->size());
   energyErrorValues.reserve(egCollection->size());
   //
   //**************************************************************************
   // Rechits
   //**************************************************************************
   edm::Handle< EcalRecHitCollection > pEBRecHits;
   edm::Handle< EcalRecHitCollection > pEERecHits;
   iEvent.getByToken( recHitCollectionEBToken_, pEBRecHits );
   iEvent.getByToken( recHitCollectionEEToken_, pEERecHits );
 
   //**************************************************************************
   //Get Number of Vertices
   //**************************************************************************
   edm::Handle<reco::VertexCollection> hVertexProduct;
   iEvent.getByToken(hVertexToken_,hVertexProduct);
   const reco::VertexCollection inVertices = *(hVertexProduct.product());
 
   // loop through all vertices
   Int_t nvertices = 0;
   for (reco::VertexCollection::const_iterator inV = inVertices.begin();
        inV != inVertices.end(); ++inV) {
 
     // pass these vertex cuts
     if (inV->ndof() >= 4
         && inV->position().Rho() <= 2.0
         && fabs(inV->z()) <= 24.0
       ) {
       nvertices++;
     }
   }
 
   //**************************************************************************
   //Get Rho
   //**************************************************************************
   double rho = 0;
   edm::Handle<double> hRhoKt6PFJets;
   iEvent.getByToken(hRhoKt6PFJetsToken_, hRhoKt6PFJets);
   rho = (*hRhoKt6PFJets);
 
 
   for ( reco::GsfElectronCollection::const_iterator egIter = egCandidates.begin();
         egIter != egCandidates.end(); ++egIter) {
 
     const EcalRecHitCollection * recHits=0;
     if(egIter->isEB())
         recHits = pEBRecHits.product();
     else
         recHits = pEERecHits.product();
 
     SuperClusterHelper mySCHelper(&(*egIter),recHits,ecalTopology_,caloGeometry_);
 
     double energy=regressionEvaluator->calculateRegressionEnergy(&(*egIter),
                                                           mySCHelper,
                                                           rho,nvertices,
                                                           printDebug_);
 
     double error=regressionEvaluator->calculateRegressionEnergyUncertainty(&(*egIter),
                                                                     mySCHelper,
                                                                     rho,nvertices,
                                                                     printDebug_);
 
     energyValues.push_back(energy);
     energyErrorValues.push_back(error);
 
   }
 
   energyFiller.insert( egCollection, energyValues.begin(), energyValues.end() );
   energyFiller.fill();
 
   energyErrorFiller.insert( egCollection, energyErrorValues.begin(), energyErrorValues.end() );
   energyErrorFiller.fill();
 
   iEvent.put(std::move(regrEnergyMap),nameEnergyReg_);
   iEvent.put(std::move(regrEnergyErrorMap),nameEnergyErrorReg_);
 
   return true;
 
 }