Producer for particle flow reconstructed particles (PFCandidates) More...

#include <PFEGammaProducer.h>

Inheritance diagram for PFEGammaProducer:

Public Member Functions
virtual void	beginRun (const edm::Run &, const edm::EventSetup &) override

	PFEGammaProducer (const edm::ParameterSet &, const pfEGHelpers::HeavyObjectCache *)

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

	~PFEGammaProducer ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< pfEGHelpers::HeavyObjectCache > >
	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	globalEndJob (pfEGHelpers::HeavyObjectCache const *)

static std::unique_ptr < pfEGHelpers::HeavyObjectCache >	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
void	createSingleLegConversions (reco::PFCandidateEGammaExtraCollection &extras, reco::ConversionCollection &oneLegConversions, const edm::RefProd< reco::ConversionCollection > &convProd)

void	setPFEGParameters (PFEGammaAlgo::PFEGConfigInfo &)

void	setPFVertexParameters (bool useVertex, const reco::VertexCollection *primaryVertices)

Private Attributes
bool	applyCrackCorrectionsElectrons_

double	coneEcalIsoForEgammaSC_

double	coneTrackIsoForEgammaSC_

std::string	ebeeClustersCollection_

edm::EDGetTokenT < reco::PFCluster::EEtoPSAssociation >	eetopsSrc_

std::auto_ptr < reco::PFCandidateCollection >	egCandidates_

std::auto_ptr < reco::PFCandidateEGammaExtraCollection >	egExtra_

std::string	esClustersCollection_

edm::EDGetTokenT < reco::PFBlockCollection >	inputTagBlocks_

double	mvaEleCut_

std::string	mvaWeightFileEleID_
	Variables for PFEGamma. More...

unsigned int	nTrackIsoForEgammaSC_

std::unique_ptr< PFEGammaAlgo >	pfeg_
	the unfiltered electron collection More...

reco::Vertex	primaryVertex_

const GBRForest *	ReaderGC_

const GBRForest *	ReaderLC_

const GBRForest *	ReaderRes_

std::auto_ptr < reco::SuperClusterCollection >	sClusters_

std::vector< double >	setchi2Values_

std::auto_ptr < reco::ConversionCollection >	singleLegConv_

double	sumEtEcalIsoForEgammaSC_barrel_

double	sumEtEcalIsoForEgammaSC_endcap_

double	sumPtTrackIsoForEgammaSC_barrel_

double	sumPtTrackIsoForEgammaSC_endcap_

std::shared_ptr < PFSCEnergyCalibration >	thePFSCEnergyCalibration_

bool	useCalibrationsFromDB_

bool	useEGammaElectrons_

bool	useEGammaSupercluster_

bool	useEGElectrons_

bool	usePFElectrons_

bool	usePFPhotons_

bool	usePFSCEleCalib_

bool	usePhotonReg_

bool	useRegressionFromDB_

bool	useVerticesForNeutral_

bool	verbose_
	verbose ? More...

edm::EDGetTokenT < reco::VertexCollection >	vertices_

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

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

Producer for particle flow reconstructed particles (PFCandidates)

This producer makes use of PFAlgo, the particle flow algorithm.

Author: Colin Bernet

Date: July 2006

Definition at line 51 of file PFEGammaProducer.h.

Constructor & Destructor Documentation

PFEGammaProducer::PFEGammaProducer	(	const edm::ParameterSet &	iConfig,
		const pfEGHelpers::HeavyObjectCache *
	)

explicit

Definition at line 45 of file PFEGammaProducer.cc.

                                                                       :
   primaryVertex_(reco::Vertex()),
   ebeeClustersCollection_("EBEEClusters"),
   esClustersCollection_("ESClusters") {
     
   PFEGammaAlgo::PFEGConfigInfo algo_config;
 
   inputTagBlocks_ 
     = consumes<reco::PFBlockCollection>(iConfig.getParameter<edm::InputTag>("blocks"));
 
   eetopsSrc_ = consumes<reco::PFCluster::EEtoPSAssociation>(iConfig.getParameter<edm::InputTag>("EEtoPS_source"));
 
   algo_config.useReg
     =  iConfig.getParameter<bool>("usePhotonReg");
 
   useVerticesForNeutral_
     = iConfig.getParameter<bool>("useVerticesForNeutral"); 
 
   useRegressionFromDB_
     = iConfig.getParameter<bool>("useRegressionFromDB"); 
 
 
   std::vector<double>  calibPFSCEle_Fbrem_barrel; 
   std::vector<double>  calibPFSCEle_Fbrem_endcap;
   std::vector<double>  calibPFSCEle_barrel;
   std::vector<double>  calibPFSCEle_endcap;
   algo_config.usePFSCEleCalib = iConfig.getParameter<bool>("usePFSCEleCalib");
   calibPFSCEle_Fbrem_barrel = iConfig.getParameter<std::vector<double> >("calibPFSCEle_Fbrem_barrel");
   calibPFSCEle_Fbrem_endcap = iConfig.getParameter<std::vector<double> >("calibPFSCEle_Fbrem_endcap");
   calibPFSCEle_barrel = iConfig.getParameter<std::vector<double> >("calibPFSCEle_barrel");
   calibPFSCEle_endcap = iConfig.getParameter<std::vector<double> >("calibPFSCEle_endcap");
   std::shared_ptr<PFSCEnergyCalibration>  
     thePFSCEnergyCalibration ( new PFSCEnergyCalibration(calibPFSCEle_Fbrem_barrel,calibPFSCEle_Fbrem_endcap,
                                                          calibPFSCEle_barrel,calibPFSCEle_endcap )); 
                                
   algo_config.useEGammaSupercluster = 
     iConfig.getParameter<bool>("useEGammaSupercluster");
   algo_config.produceEGCandsWithNoSuperCluster = 
     iConfig.getParameter<bool>("produceEGCandsWithNoSuperCluster");
   algo_config.sumEtEcalIsoForEgammaSC_barrel = 
     iConfig.getParameter<double>("sumEtEcalIsoForEgammaSC_barrel");
   algo_config.sumEtEcalIsoForEgammaSC_endcap = 
     iConfig.getParameter<double>("sumEtEcalIsoForEgammaSC_endcap");
   algo_config.coneEcalIsoForEgammaSC = 
     iConfig.getParameter<double>("coneEcalIsoForEgammaSC");
   algo_config.sumPtTrackIsoForEgammaSC_barrel = 
     iConfig.getParameter<double>("sumPtTrackIsoForEgammaSC_barrel");
   algo_config.sumPtTrackIsoForEgammaSC_endcap = 
     iConfig.getParameter<double>("sumPtTrackIsoForEgammaSC_endcap");
   algo_config.coneTrackIsoForEgammaSC = 
     iConfig.getParameter<double>("coneTrackIsoForEgammaSC");
   algo_config.nTrackIsoForEgammaSC  = 
     iConfig.getParameter<unsigned int>("nTrackIsoForEgammaSC");
 
 
   // register products
   produces<reco::PFCandidateCollection>();
   produces<reco::PFCandidateEGammaExtraCollection>();  
   produces<reco::SuperClusterCollection>();
   produces<reco::CaloClusterCollection>(ebeeClustersCollection_);
   produces<reco::CaloClusterCollection>(esClustersCollection_);  
   produces<reco::ConversionCollection>();
   
   //PFElectrons Configuration
   algo_config.mvaEleCut
     = iConfig.getParameter<double>("pf_electron_mvaCut");
 
   
   algo_config. mvaWeightFileEleID
     = iConfig.getParameter<edm::FileInPath>("pf_electronID_mvaWeightFile").fullPath();
 
   algo_config.applyCrackCorrections
     = iConfig.getParameter<bool>("pf_electronID_crackCorrection");
     
   //PFPhoton Configuration
 
   std::string path_mvaWeightFileConvID;
   std::string mvaWeightFileConvID;
   std::string path_mvaWeightFileGCorr;
   std::string path_mvaWeightFileLCorr;
   std::string path_X0_Map;
   std::string path_mvaWeightFileRes;
 
   algo_config.mvaweightfile =
     iConfig.getParameter<edm::FileInPath>("pf_convID_mvaWeightFile").fullPath();
   algo_config.mvaConvCut = iConfig.getParameter<double>("pf_conv_mvaCut");  
   algo_config.sumPtTrackIsoForPhoton = 
     iConfig.getParameter<double>("sumPtTrackIsoForPhoton");
   algo_config.sumPtTrackIsoSlopeForPhoton = 
     iConfig.getParameter<double>("sumPtTrackIsoSlopeForPhoton");
 
   algo_config.X0_Map = iConfig.getParameter<std::string>("X0_Map");
   algo_config.X0_Map = 
     edm::FileInPath( algo_config.X0_Map.c_str() ).fullPath();
 
   if(!useRegressionFromDB_) {
     std::string mvaWeightFileLCorr=iConfig.getParameter<std::string>("pf_locC_mvaWeightFile");
     path_mvaWeightFileLCorr = edm::FileInPath( mvaWeightFileLCorr.c_str() ).fullPath();
     std::string mvaWeightFileGCorr=iConfig.getParameter<std::string>("pf_GlobC_mvaWeightFile");
     path_mvaWeightFileGCorr = edm::FileInPath( mvaWeightFileGCorr.c_str() ).fullPath();
     std::string mvaWeightFileRes=iConfig.getParameter<std::string>("pf_Res_mvaWeightFile");
     path_mvaWeightFileRes=edm::FileInPath(mvaWeightFileRes.c_str()).fullPath();
 
     TFile *fgbr = new TFile(path_mvaWeightFileGCorr.c_str(),"READ");
     ReaderGC_  =(const GBRForest*)fgbr->Get("GBRForest");
     TFile *fgbr2 = new TFile(path_mvaWeightFileLCorr.c_str(),"READ");
     ReaderLC_  = (const GBRForest*)fgbr2->Get("GBRForest");
     TFile *fgbr3 = new TFile(path_mvaWeightFileRes.c_str(),"READ");
     ReaderRes_  = (const GBRForest*)fgbr3->Get("GBRForest");
     LogDebug("PFEGammaProducer")<<"Will set regressions from binary files " <<std::endl;
   }
 
   edm::ParameterSet iCfgCandConnector 
     = iConfig.getParameter<edm::ParameterSet>("iCfgCandConnector");
 
 
   // fToRead =  iConfig.getUntrackedParameter<std::vector<std::string> >("toRead");
 
   useCalibrationsFromDB_
     = iConfig.getParameter<bool>("useCalibrationsFromDB");    
 
   std::shared_ptr<PFEnergyCalibration> calibration(new PFEnergyCalibration()); 
 
   int algoType 
     = iConfig.getParameter<unsigned>("algoType");
   
   switch(algoType) {
   case 0:
     //pfAlgo_.reset( new PFAlgo);
     break;
    default:
     assert(0);
   }
   
   //PFEGamma
   setPFEGParameters(algo_config);  
 
   //MIKE: Vertex Parameters
   vertices_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexCollection"));
 
   verbose_ = 
     iConfig.getUntrackedParameter<bool>("verbose",false);
 
 //   bool debug_ = 
 //     iConfig.getUntrackedParameter<bool>("debug",false);
 
 }

PFEGammaProducer::~PFEGammaProducer ( )

Definition at line 196 of file PFEGammaProducer.cc.

196 {}

Member Function Documentation

void PFEGammaProducer::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	es
	)

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 199 of file PFEGammaProducer.cc.

 {
 
   /* // kept for historical reasons
   if(useRegressionFromDB_) {
     
     edm::ESHandle<GBRForest> readerPFLCEB;
     edm::ESHandle<GBRForest> readerPFLCEE;    
     edm::ESHandle<GBRForest> readerPFGCEB;
     edm::ESHandle<GBRForest> readerPFGCEEHR9;
     edm::ESHandle<GBRForest> readerPFGCEELR9;
     edm::ESHandle<GBRForest> readerPFRes;
     es.get<GBRWrapperRcd>().get("PFLCorrectionBar",readerPFLCEB);
     ReaderLCEB_=readerPFLCEB.product();
     es.get<GBRWrapperRcd>().get("PFLCorrectionEnd",readerPFLCEE);
     ReaderLCEE_=readerPFLCEE.product();
     es.get<GBRWrapperRcd>().get("PFGCorrectionBar",readerPFGCEB);       
     ReaderGCBarrel_=readerPFGCEB.product();
     es.get<GBRWrapperRcd>().get("PFGCorrectionEndHighR9",readerPFGCEEHR9);
     ReaderGCEndCapHighr9_=readerPFGCEEHR9.product();
     es.get<GBRWrapperRcd>().get("PFGCorrectionEndLowR9",readerPFGCEELR9);
     ReaderGCEndCapLowr9_=readerPFGCEELR9.product();
     es.get<GBRWrapperRcd>().get("PFEcalResolution",readerPFRes);
     ReaderEcalRes_=readerPFRes.product();
 
     
     LogDebug("PFEGammaProducer")<<"setting regressions from DB "<<std::endl;
     
   } 
   */
 
   //pfAlgo_->setPFPhotonRegWeights(ReaderLC_, ReaderGC_, ReaderRes_);
     
 }

void PFEGammaProducer::createSingleLegConversions	(	reco::PFCandidateEGammaExtraCollection &	extras,
		reco::ConversionCollection &	oneLegConversions,
		const edm::RefProd< reco::ConversionCollection > &	convProd
	)

private

Definition at line 576 of file PFEGammaProducer.cc.

References reco::TrackBase::d0(), relativeConstraints::error, reco::Track::innerMomentum(), reco::Track::innerPosition(), reco::Track::outerMomentum(), reco::Track::outerPosition(), reco::Conversion::pflow, edm::PtrVector< T >::push_back(), edm::refToPtr(), and reco::Conversion::setOneLegMVA().

Referenced by produce().

                                                                                                                                                                                                  {
  
   math::Error<3>::type error;
   for (auto &extra : extras){
     for (const auto &tkrefmva : extra.singleLegConvTrackRefMva()) {
       const reco::Track &trk = *tkrefmva.first;
             
       const reco::Vertex convVtx(trk.innerPosition(), error);
       std::vector<reco::TrackRef> OneLegConvVector;
       OneLegConvVector.push_back(tkrefmva.first);
       std::vector< float > OneLegMvaVector;
       OneLegMvaVector.push_back(tkrefmva.second);
       std::vector<reco::CaloClusterPtr> dummymatchingBC;
       reco::CaloClusterPtrVector scPtrVec;
       scPtrVec.push_back(edm::refToPtr(extra.superClusterRef()));
 
       std::vector<math::XYZPointF>trackPositionAtEcalVec;
       std::vector<math::XYZPointF>innPointVec;
       std::vector<math::XYZVectorF>trackPinVec;
       std::vector<math::XYZVectorF>trackPoutVec;
       math::XYZPointF trackPositionAtEcal(trk.outerPosition().X(), trk.outerPosition().Y(), trk.outerPosition().Z());
       trackPositionAtEcalVec.push_back(trackPositionAtEcal);
       
       math::XYZPointF innPoint(trk.innerPosition().X(), trk.innerPosition().Y(), trk.innerPosition().Z());
       innPointVec.push_back(innPoint);
 
       math::XYZVectorF trackPin(trk.innerMomentum().X(), trk.innerMomentum().Y(), trk.innerMomentum().Z());
       trackPinVec.push_back(trackPin);
 
       math::XYZVectorF trackPout(trk.outerMomentum().X(), trk.outerMomentum().Y(), trk.outerMomentum().Z());
       trackPoutVec.push_back( trackPout );
       
       float DCA = trk.d0() ;
       float mvaval = tkrefmva.second;
       reco::Conversion singleLegConvCandidate(scPtrVec, 
                                           OneLegConvVector,
                                           trackPositionAtEcalVec,
                                           convVtx,
                                           dummymatchingBC,
                                           DCA,
                                           innPointVec,
                                           trackPinVec,
                                           trackPoutVec,
                                           mvaval,                         
                                           reco::Conversion::pflow);
       singleLegConvCandidate.setOneLegMVA(OneLegMvaVector); 
       oneLegConversions.push_back(singleLegConvCandidate);
             
       reco::ConversionRef convref(convProd,oneLegConversions.size()-1);
       extra.addSingleLegConversionRef(convref);
     
     }
 
   } 
   
 }

static void PFEGammaProducer::globalEndJob ( pfEGHelpers::HeavyObjectCache const * )

inlinestatic

Definition at line 61 of file PFEGammaProducer.h.

61 {

62 }

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

inlinestatic

Definition at line 57 of file PFEGammaProducer.h.

                                                          {
        return std::unique_ptr<pfEGHelpers::HeavyObjectCache>(new pfEGHelpers::HeavyObjectCache(conf));
    }

void PFEGammaProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 237 of file PFEGammaProducer.cc.

References assert(), gather_cfg::blocks, HLT_25ns14e33_v1_cff::clusters, createSingleLegConversions(), TauDecayModes::dec, ebeeClustersCollection_, reco::PFBlockElement::ECAL, eetopsSrc_, egCandidates_, egExtra_, asciidump::elements, esClustersCollection_, edm::EventID::event(), edm::hlt::Exception, newFWLiteAna::found, edm::Event::getByToken(), edm::Event::getRefBeforePut(), reco::PFBlockElement::HCAL, reco::PFBlockElement::HFEM, reco::PFBlockElement::HFHAD, reco::PFBlockElement::HO, i, edm::EventBase::id(), edm::EDGetTokenT< T >::index(), inputTagBlocks_, LOGDRESSED, eostools::move(), pfeg_, edm::Handle< T >::product(), reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, edm::PtrVector< T >::push_back(), edm::Event::put(), edm::EventID::run(), reco::PFBlockElement::SC, sClusters_, reco::PFCandidate::setPFEGammaExtraRef(), setPFVertexParameters(), reco::PFCandidateEGammaExtra::setSuperClusterRef(), reco::PFCandidate::setSuperClusterRef(), singleLegConv_, edm::OwnVector< T, P >::size(), funct::true, useVerticesForNeutral_, HLT_25ns14e33_v1_cff::vertices, and vertices_.

                                               {
   
   LOGDRESSED("PFEGammaProducer")
     <<"START event: "
     <<iEvent.id().event()
     <<" in run "<<iEvent.id().run()<<std::endl;
   
 
   // reset output collection  
   egCandidates_.reset( new reco::PFCandidateCollection );   
   egExtra_.reset( new reco::PFCandidateEGammaExtraCollection ); 
   sClusters_.reset( new reco::SuperClusterCollection );      
     
   // Get the EE-PS associations
   edm::Handle<reco::PFCluster::EEtoPSAssociation> eetops;
   iEvent.getByToken(eetopsSrc_,eetops);
   pfeg_->setEEtoPSAssociation(eetops);
 
   // Get The vertices from the event
   // and assign dynamic vertex parameters
   edm::Handle<reco::VertexCollection> vertices;
   bool gotVertices = iEvent.getByToken(vertices_,vertices);
   if(!gotVertices) {
     std::ostringstream err;
     err<<"Cannot find vertices for this event.Continuing Without them ";
     edm::LogError("PFEGammaProducer")<<err.str()<<std::endl;
   }
 
   //Assign the PFAlgo Parameters
   setPFVertexParameters(useVerticesForNeutral_,vertices.product());
 
   // get the collection of blocks 
 
   edm::Handle< reco::PFBlockCollection > blocks;
 
   LOGDRESSED("PFEGammaProducer")<<"getting blocks"<<std::endl;
   bool found = iEvent.getByToken( inputTagBlocks_, blocks );  
 
   if(!found ) {
 
     std::ostringstream err;
     err<<"cannot find blocks: (tag index)"
        << std::hex<< inputTagBlocks_.index() << std::dec;
     edm::LogError("PFEGammaProducer")<<err.str()<<std::endl;
     
     throw cms::Exception( "MissingProduct", err.str());
   }
   
   LOGDRESSED("PFEGammaProducer")
     <<"EGPFlow is starting..."<<std::endl;
 
 #ifdef PFLOW_DEBUG
   assert( blocks.isValid() && "edm::Handle to blocks was null!");
   std::ostringstream  str;
   //str<<(*pfAlgo_)<<std::endl;
   //    cout << (*pfAlgo_) << std::endl;
   LOGDRESSED("PFEGammaProducer") <<str.str()<<std::endl;
 #endif  
 
   // sort elements in three lists:
   std::list< reco::PFBlockRef > hcalBlockRefs;
   std::list< reco::PFBlockRef > ecalBlockRefs;
   std::list< reco::PFBlockRef > hoBlockRefs;
   std::list< reco::PFBlockRef > otherBlockRefs;
   
   for( unsigned i=0; i<blocks->size(); ++i ) {
     // reco::PFBlockRef blockref( blockh,i );
     //reco::PFBlockRef blockref = createBlockRef( *blocks, i);
     reco::PFBlockRef blockref(blocks, i);    
     
     const edm::OwnVector< reco::PFBlockElement >& 
       elements = blockref->elements();
    
     LOGDRESSED("PFEGammaProducer") 
       << "Found " << elements.size() 
       << " PFBlockElements in block: " << i << std::endl;
     
     bool singleEcalOrHcal = false;
     if( elements.size() == 1 ){
       switch( elements[0].type() ) {
       case reco::PFBlockElement::SC:
     edm::LogError("PFEGammaProducer")
       << "PFBLOCKALGO BUG!!!! Found a SuperCluster in a block by itself!";
       case reco::PFBlockElement::PS1:
       case reco::PFBlockElement::PS2:
       case reco::PFBlockElement::ECAL:
         ecalBlockRefs.push_back( blockref );
         singleEcalOrHcal = true;
     break;
       case reco::PFBlockElement::HFEM:
       case reco::PFBlockElement::HFHAD:
       case reco::PFBlockElement::HCAL:
         hcalBlockRefs.push_back( blockref );
         singleEcalOrHcal = true;
     break;
       case reco::PFBlockElement::HO:
         // Single HO elements are likely to be noise. Not considered for now.
         hoBlockRefs.push_back( blockref );
         singleEcalOrHcal = true;
     break;
       default:
     break;
       }
     }
     
     if(!singleEcalOrHcal) {
       otherBlockRefs.push_back( blockref );
     }
   }//loop blocks
   
   // loop on blocks that are not single ecal, single ps1, single ps2 , or
   // single hcal and produce unbiased collection of EGamma Candidates
 
   //printf("loop over blocks\n");
   unsigned nblcks = 0;
 
   // this auto is a const reco::PFBlockRef&
   for( const auto& blockref : otherBlockRefs ) {
     ++nblcks;
     // this auto is a: const edm::OwnVector< reco::PFBlockElement >&
     const auto& elements = blockref->elements();
     // make a copy of the link data, which will be edited.
     //PFBlock::LinkData linkData =  block.linkData();
     
     // keep track of the elements which are still active.
     std::vector<bool> active( elements.size(), true );      
     
     pfeg_->RunPFEG(globalCache(),blockref,active);
 
     if( pfeg_->getCandidates().size() ) {
       LOGDRESSED("PFEGammaProducer")
       << "Block with " << elements.size() 
       << " elements produced " 
       << pfeg_->getCandidates().size() 
       << " e-g candidates!" << std::endl;      
     }
 
     const size_t egsize = egCandidates_->size();
     egCandidates_->resize(egsize + pfeg_->getCandidates().size());
     reco::PFCandidateCollection::iterator eginsertfrom = 
       egCandidates_->begin() + egsize;
     std::move(pfeg_->getCandidates().begin(),
           pfeg_->getCandidates().end(),
           eginsertfrom);
     
     const size_t egxsize = egExtra_->size();
     egExtra_->resize(egxsize + pfeg_->getEGExtra().size());
     reco::PFCandidateEGammaExtraCollection::iterator egxinsertfrom = 
       egExtra_->begin() + egxsize;
     std::move(pfeg_->getEGExtra().begin(),
           pfeg_->getEGExtra().end(),
           egxinsertfrom);
 
     const size_t rscsize = sClusters_->size();
     sClusters_->resize(rscsize + pfeg_->getRefinedSCs().size());
     reco::SuperClusterCollection::iterator rscinsertfrom = 
       sClusters_->begin() + rscsize;
     std::move(pfeg_->getRefinedSCs().begin(),
           pfeg_->getRefinedSCs().end(),
           rscinsertfrom);    
   }
 
   LOGDRESSED("PFEGammaProducer")
       << "Running PFEGammaAlgo on all blocks produced = " 
       << egCandidates_->size() << " e-g candidates!"
       << std::endl;
   
   edm::RefProd<reco::SuperClusterCollection> sClusterProd = 
     iEvent.getRefBeforePut<reco::SuperClusterCollection>();
 
   edm::RefProd<reco::PFCandidateEGammaExtraCollection> egXtraProd = 
     iEvent.getRefBeforePut<reco::PFCandidateEGammaExtraCollection>();
     
   //set the correct references to refined SC and EG extra using the refprods
   for (unsigned int i=0; i < egCandidates_->size(); ++i) {
     reco::PFCandidate &cand = egCandidates_->at(i);
     reco::PFCandidateEGammaExtra &xtra = egExtra_->at(i);
     
     reco::PFCandidateEGammaExtraRef extraref(egXtraProd,i);
     reco::SuperClusterRef refinedSCRef(sClusterProd,i);
 
     xtra.setSuperClusterRef(refinedSCRef); 
     cand.setSuperClusterRef(refinedSCRef);
     cand.setPFEGammaExtraRef(extraref);    
   }
   
   //build collections of output CaloClusters from the used PFClusters
   std::auto_ptr<reco::CaloClusterCollection> caloClustersEBEE(new reco::CaloClusterCollection);
   std::auto_ptr<reco::CaloClusterCollection> caloClustersES(new reco::CaloClusterCollection);
   
   std::map<edm::Ptr<reco::CaloCluster>, unsigned int> pfClusterMapEBEE; //maps of pfclusters to caloclusters 
   std::map<edm::Ptr<reco::CaloCluster>, unsigned int> pfClusterMapES;  
   
   for( const auto& sc : *sClusters_ ) {
     for (reco::CaloCluster_iterator pfclus = sc.clustersBegin(); pfclus!=sc.clustersEnd(); ++pfclus) {
       if (!pfClusterMapEBEE.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersEBEE->push_back(caloclus);
         pfClusterMapEBEE[*pfclus] = caloClustersEBEE->size() - 1;
       }
       else {
         throw cms::Exception("PFEgammaProducer::produce")
             << "Found an EB/EE pfcluster matched to more than one supercluster!" 
             << std::dec << std::endl;
       }
     }
     for (reco::CaloCluster_iterator pfclus = sc.preshowerClustersBegin(); pfclus!=sc.preshowerClustersEnd(); ++pfclus) {
       if (!pfClusterMapES.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersES->push_back(caloclus);
         pfClusterMapES[*pfclus] = caloClustersES->size() - 1;
       }
       else {
         throw cms::Exception("PFEgammaProducer::produce")
             << "Found an ES pfcluster matched to more than one supercluster!" 
             << std::dec << std::endl;
       }
     }
   }
   
   //put calocluster output collections in event and get orphan handles to create ptrs
   const edm::OrphanHandle<reco::CaloClusterCollection> &caloClusHandleEBEE = iEvent.put(caloClustersEBEE,ebeeClustersCollection_);
   const edm::OrphanHandle<reco::CaloClusterCollection> &caloClusHandleES = iEvent.put(caloClustersES,esClustersCollection_);
   
   //relink superclusters to output caloclusters
   for( auto& sc : *sClusters_ ) {
     edm::Ptr<reco::CaloCluster> seedptr(caloClusHandleEBEE,pfClusterMapEBEE[sc.seed()]);
     sc.setSeed(seedptr);
     
     reco::CaloClusterPtrVector clusters;
     for (reco::CaloCluster_iterator pfclus = sc.clustersBegin(); pfclus!=sc.clustersEnd(); ++pfclus) {
       edm::Ptr<reco::CaloCluster> clusptr(caloClusHandleEBEE,pfClusterMapEBEE[*pfclus]);
       clusters.push_back(clusptr);
     }
     sc.setClusters(clusters);
     
     reco::CaloClusterPtrVector psclusters;
     for (reco::CaloCluster_iterator pfclus = sc.preshowerClustersBegin(); pfclus!=sc.preshowerClustersEnd(); ++pfclus) {
       edm::Ptr<reco::CaloCluster> clusptr(caloClusHandleES,pfClusterMapES[*pfclus]);
       psclusters.push_back(clusptr);
     }
     sc.setPreshowerClusters(psclusters);  
   }
   
   //create and fill references to single leg conversions
   edm::RefProd<reco::ConversionCollection> convProd = iEvent.getRefBeforePut<reco::ConversionCollection>();
   singleLegConv_.reset(new reco::ConversionCollection);  
   createSingleLegConversions(*egExtra_, *singleLegConv_, convProd);
   
   // release our demonspawn into the wild to cause havoc
   iEvent.put(sClusters_);
   iEvent.put(egExtra_);  
   iEvent.put(singleLegConv_);
   iEvent.put(egCandidates_); 
 }

void PFEGammaProducer::setPFEGParameters ( PFEGammaAlgo::PFEGConfigInfo & cfg )

private

Definition at line 496 of file PFEGammaProducer.cc.

References alignCSCRings::e, PFEGammaAlgo::PFEGConfigInfo::mvaweightfile, PFEGammaAlgo::PFEGConfigInfo::mvaWeightFileEleID, AlCaHLTBitMon_ParallelJobs::p, pfeg_, primaryVertex_, PFEGammaAlgo::PFEGConfigInfo::primaryVtx, AlCaHLTBitMon_QueryRunRegistry::string, and useVerticesForNeutral_.

Referenced by PFEGammaProducer().

                                                                    {  
   
   FILE * fileEleID = fopen(cfg.mvaWeightFileEleID.c_str(), "r");
   if (fileEleID) {
     fclose(fileEleID);
   }
   else {
     std::string err = "PFAlgo: cannot open weight file '";
     err += cfg.mvaWeightFileEleID;
     err += "'";
     throw std::invalid_argument( err );
   }
 
   //for MVA pass PV if there is one in the collection otherwise pass a dummy  
   if(!useVerticesForNeutral_) { // create a dummy PV  
     reco::Vertex::Error e;  
     e(0, 0) = 0.0015 * 0.0015;  
     e(1, 1) = 0.0015 * 0.0015;  
     e(2, 2) = 15. * 15.;  
     reco::Vertex::Point p(0, 0, 0);  
     primaryVertex_ = reco::Vertex(p, e, 0, 0, 0);  
   }  
   // pv=&dummy;  
   //if(! usePFPhotons_) return;  
   FILE * filePhotonConvID = fopen(cfg.mvaweightfile.c_str(), "r");  
   if (filePhotonConvID) {  
     fclose(filePhotonConvID);  
   }  
   else {  
     std::string err = "PFAlgo: cannot open weight file '";  
     err += cfg.mvaweightfile;
     err += "'";  
     throw std::invalid_argument( err );  
   }  
   cfg.primaryVtx = &primaryVertex_;  
   pfeg_.reset(new PFEGammaAlgo(cfg));
 }

void PFEGammaProducer::setPFVertexParameters	(	bool	useVertex,
		const reco::VertexCollection *	primaryVertices
	)

private

Definition at line 546 of file PFEGammaProducer.cc.

References i, pfeg_, primaryVertex_, HLT_25ns14e33_v1_cff::useVertex, and useVerticesForNeutral_.

Referenced by produce().

                                                                             {
   useVerticesForNeutral_ = useVertex;
 
   //Set the vertices for muon cleaning
 //  pfmu_->setInputsForCleaning(primaryVertices);
 
 
   //Now find the primary vertex!
   //bool primaryVertexFound = false;
   int nVtx=primaryVertices->size();
   pfeg_->setnPU(nVtx);
 //   if(usePFPhotons_){
 //     pfpho_->setnPU(nVtx);
 //   }
   primaryVertex_ = primaryVertices->front();
   for (unsigned short i=0 ;i<primaryVertices->size();++i)
     {
       if(primaryVertices->at(i).isValid()&&(!primaryVertices->at(i).isFake()))
         {
           primaryVertex_ = primaryVertices->at(i);
           //primaryVertexFound = true;
           break;
         }
     }
   
   pfeg_->setPhotonPrimaryVtx(primaryVertex_ );
   
 }

Member Data Documentation

bool PFEGammaProducer::applyCrackCorrectionsElectrons_

private

Definition at line 115 of file PFEGammaProducer.h.

double PFEGammaProducer::coneEcalIsoForEgammaSC_

private

Definition at line 121 of file PFEGammaProducer.h.

double PFEGammaProducer::coneTrackIsoForEgammaSC_

private

Definition at line 124 of file PFEGammaProducer.h.

std::string PFEGammaProducer::ebeeClustersCollection_

private

Definition at line 143 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

edm::EDGetTokenT<reco::PFCluster::EEtoPSAssociation> PFEGammaProducer::eetopsSrc_

private

Definition at line 78 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

std::auto_ptr< reco::PFCandidateCollection > PFEGammaProducer::egCandidates_

private

Definition at line 129 of file PFEGammaProducer.h.

Referenced by produce().

std::auto_ptr<reco::PFCandidateEGammaExtraCollection> PFEGammaProducer::egExtra_

private

Definition at line 130 of file PFEGammaProducer.h.

Referenced by produce().

std::string PFEGammaProducer::esClustersCollection_

private

Definition at line 144 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

edm::EDGetTokenT<reco::PFBlockCollection> PFEGammaProducer::inputTagBlocks_

private

Definition at line 77 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

double PFEGammaProducer::mvaEleCut_

private

Definition at line 112 of file PFEGammaProducer.h.

std::string PFEGammaProducer::mvaWeightFileEleID_

private

Variables for PFEGamma.

Definition at line 110 of file PFEGammaProducer.h.

unsigned int PFEGammaProducer::nTrackIsoForEgammaSC_

private

Definition at line 125 of file PFEGammaProducer.h.

std::unique_ptr<PFEGammaAlgo> PFEGammaProducer::pfeg_

private

the unfiltered electron collection

particle flow algorithm

Definition at line 141 of file PFEGammaProducer.h.

Referenced by produce(), setPFEGParameters(), and setPFVertexParameters().

reco::Vertex PFEGammaProducer::primaryVertex_

private

Definition at line 127 of file PFEGammaProducer.h.

Referenced by setPFEGParameters(), and setPFVertexParameters().

const GBRForest* PFEGammaProducer::ReaderGC_

private

Definition at line 89 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

const GBRForest* PFEGammaProducer::ReaderLC_

private

Definition at line 90 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

const GBRForest* PFEGammaProducer::ReaderRes_

private

Definition at line 91 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

std::auto_ptr< reco::SuperClusterCollection > PFEGammaProducer::sClusters_

private

Definition at line 132 of file PFEGammaProducer.h.

Referenced by produce().

std::vector<double> PFEGammaProducer::setchi2Values_

private

Definition at line 111 of file PFEGammaProducer.h.

std::auto_ptr<reco::ConversionCollection> PFEGammaProducer::singleLegConv_

private

Definition at line 131 of file PFEGammaProducer.h.

Referenced by produce().

double PFEGammaProducer::sumEtEcalIsoForEgammaSC_barrel_

private

Definition at line 119 of file PFEGammaProducer.h.

double PFEGammaProducer::sumEtEcalIsoForEgammaSC_endcap_

private

Definition at line 120 of file PFEGammaProducer.h.

double PFEGammaProducer::sumPtTrackIsoForEgammaSC_barrel_

private

Definition at line 122 of file PFEGammaProducer.h.

double PFEGammaProducer::sumPtTrackIsoForEgammaSC_endcap_

private

Definition at line 123 of file PFEGammaProducer.h.

std::shared_ptr<PFSCEnergyCalibration> PFEGammaProducer::thePFSCEnergyCalibration_

private

Definition at line 107 of file PFEGammaProducer.h.

bool PFEGammaProducer::useCalibrationsFromDB_

private

Definition at line 105 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

bool PFEGammaProducer::useEGammaElectrons_

private

Definition at line 99 of file PFEGammaProducer.h.

bool PFEGammaProducer::useEGammaSupercluster_

private

Definition at line 118 of file PFEGammaProducer.h.

bool PFEGammaProducer::useEGElectrons_

private

Definition at line 117 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFElectrons_

private

Definition at line 113 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFPhotons_

private

Definition at line 114 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFSCEleCalib_

private

Definition at line 116 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePhotonReg_

private

Definition at line 87 of file PFEGammaProducer.h.

bool PFEGammaProducer::useRegressionFromDB_

private

Definition at line 88 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

bool PFEGammaProducer::useVerticesForNeutral_

private

Definition at line 102 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), produce(), setPFEGParameters(), and setPFVertexParameters().

bool PFEGammaProducer::verbose_

private

verbose ?

Definition at line 84 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

edm::EDGetTokenT<reco::VertexCollection> PFEGammaProducer::vertices_

private

Definition at line 79 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation