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 &)

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

	~PFEGammaProducer ()

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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 *	ReaderEcalRes_

const GBRForest *	ReaderGC_

const GBRForest *	ReaderGCBarrel_

const GBRForest *	ReaderGCEndCapHighr9_

const GBRForest *	ReaderGCEndCapLowr9_

const GBRForest *	ReaderLC_

const GBRForest *	ReaderLCEB_

const GBRForest *	ReaderLCEE_

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 )

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<std::string>("pf_electronID_mvaWeightFile");
 
   algo_config.applyCrackCorrections
     = iConfig.getParameter<bool>("pf_electronID_crackCorrection");
   
   std::string path_mvaWeightFileEleID;
 
   algo_config.mvaWeightFileEleID = 
     edm::FileInPath ( algo_config.mvaWeightFileEleID.c_str() ).fullPath();
      
 
   //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<std::string>("pf_convID_mvaWeightFile");
   algo_config.mvaConvCut = iConfig.getParameter<double>("pf_conv_mvaCut");
   algo_config.mvaweightfile = 
     edm::FileInPath ( algo_config.mvaweightfile.c_str() ).fullPath();  
   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 203 of file PFEGammaProducer.cc.

203 {}

Member Function Documentation

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

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 206 of file PFEGammaProducer.cc.

References edm::EventSetup::get(), edm::ESHandle< class >::product(), ReaderEcalRes_, ReaderGCBarrel_, ReaderGCEndCapHighr9_, ReaderGCEndCapLowr9_, ReaderLCEB_, ReaderLCEE_, and useRegressionFromDB_.

 {
 
   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 581 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);
     
     }
 
   } 
   
 }

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 242 of file PFEGammaProducer.cc.

                                               {
   
   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(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 501 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 551 of file PFEGammaProducer.cc.

References i, pfeg_, primaryVertex_, 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 107 of file PFEGammaProducer.h.

double PFEGammaProducer::coneEcalIsoForEgammaSC_

private

Definition at line 113 of file PFEGammaProducer.h.

double PFEGammaProducer::coneTrackIsoForEgammaSC_

private

Definition at line 116 of file PFEGammaProducer.h.

std::string PFEGammaProducer::ebeeClustersCollection_

private

Definition at line 135 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 70 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 121 of file PFEGammaProducer.h.

Referenced by produce().

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

private

Definition at line 122 of file PFEGammaProducer.h.

Referenced by produce().

std::string PFEGammaProducer::esClustersCollection_

private

Definition at line 136 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 69 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

double PFEGammaProducer::mvaEleCut_

private

Definition at line 104 of file PFEGammaProducer.h.

std::string PFEGammaProducer::mvaWeightFileEleID_

private

Variables for PFEGamma.

Definition at line 102 of file PFEGammaProducer.h.

unsigned int PFEGammaProducer::nTrackIsoForEgammaSC_

private

Definition at line 117 of file PFEGammaProducer.h.

std::unique_ptr<PFEGammaAlgo> PFEGammaProducer::pfeg_

private

the unfiltered electron collection

particle flow algorithm

Definition at line 133 of file PFEGammaProducer.h.

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

reco::Vertex PFEGammaProducer::primaryVertex_

private

Definition at line 119 of file PFEGammaProducer.h.

Referenced by setPFEGParameters(), and setPFVertexParameters().

const GBRForest* PFEGammaProducer::ReaderEcalRes_

private

Definition at line 89 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderGC_

private

Definition at line 81 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

const GBRForest* PFEGammaProducer::ReaderGCBarrel_

private

Definition at line 86 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderGCEndCapHighr9_

private

Definition at line 87 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderGCEndCapLowr9_

private

Definition at line 88 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderLC_

private

Definition at line 82 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

const GBRForest* PFEGammaProducer::ReaderLCEB_

private

Definition at line 84 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderLCEE_

private

Definition at line 85 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderRes_

private

Definition at line 83 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

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

private

Definition at line 124 of file PFEGammaProducer.h.

Referenced by produce().

std::vector<double> PFEGammaProducer::setchi2Values_

private

Definition at line 103 of file PFEGammaProducer.h.

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

private

Definition at line 123 of file PFEGammaProducer.h.

Referenced by produce().

double PFEGammaProducer::sumEtEcalIsoForEgammaSC_barrel_

private

Definition at line 111 of file PFEGammaProducer.h.

double PFEGammaProducer::sumEtEcalIsoForEgammaSC_endcap_

private

Definition at line 112 of file PFEGammaProducer.h.

double PFEGammaProducer::sumPtTrackIsoForEgammaSC_barrel_

private

Definition at line 114 of file PFEGammaProducer.h.

double PFEGammaProducer::sumPtTrackIsoForEgammaSC_endcap_

private

Definition at line 115 of file PFEGammaProducer.h.

std::shared_ptr<PFSCEnergyCalibration> PFEGammaProducer::thePFSCEnergyCalibration_

private

Definition at line 99 of file PFEGammaProducer.h.

bool PFEGammaProducer::useCalibrationsFromDB_

private

Definition at line 97 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

bool PFEGammaProducer::useEGammaElectrons_

private

Definition at line 91 of file PFEGammaProducer.h.

bool PFEGammaProducer::useEGammaSupercluster_

private

Definition at line 110 of file PFEGammaProducer.h.

bool PFEGammaProducer::useEGElectrons_

private

Definition at line 109 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFElectrons_

private

Definition at line 105 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFPhotons_

private

Definition at line 106 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFSCEleCalib_

private

Definition at line 108 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePhotonReg_

private

Definition at line 79 of file PFEGammaProducer.h.

bool PFEGammaProducer::useRegressionFromDB_

private

Definition at line 80 of file PFEGammaProducer.h.

Referenced by beginRun(), and PFEGammaProducer().

bool PFEGammaProducer::useVerticesForNeutral_

private

Definition at line 94 of file PFEGammaProducer.h.

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

bool PFEGammaProducer::verbose_

private

verbose ?

Definition at line 76 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

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

private

Definition at line 71 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation