PFEGammaProducer Class Reference

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::EDProducer
	EDProducer ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducer ()
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
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Member Functions
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_
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::EDProducer
typedef EDProducer	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Static Public Member Functions inherited from edm::EDProducer
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.

References PFEGammaAlgo::PFEGConfigInfo::applyCrackCorrections, PFEGammaAlgo::PFEGConfigInfo::coneEcalIsoForEgammaSC, PFEGammaAlgo::PFEGConfigInfo::coneTrackIsoForEgammaSC, ebeeClustersCollection_, eetopsSrc_, esClustersCollection_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inputTagBlocks_, LogDebug, PFEGammaAlgo::PFEGConfigInfo::mvaConvCut, PFEGammaAlgo::PFEGConfigInfo::mvaEleCut, PFEGammaAlgo::PFEGConfigInfo::mvaweightfile, PFEGammaAlgo::PFEGConfigInfo::mvaWeightFileEleID, PFEGammaAlgo::PFEGConfigInfo::nTrackIsoForEgammaSC, PFEGammaAlgo::PFEGConfigInfo::produceEGCandsWithNoSuperCluster, ReaderGC_, ReaderLC_, ReaderRes_, setPFEGParameters(), AlCaHLTBitMon_QueryRunRegistry::string, PFEGammaAlgo::PFEGConfigInfo::sumEtEcalIsoForEgammaSC_barrel, PFEGammaAlgo::PFEGConfigInfo::sumEtEcalIsoForEgammaSC_endcap, PFEGammaAlgo::PFEGConfigInfo::sumPtTrackIsoForEgammaSC_barrel, PFEGammaAlgo::PFEGConfigInfo::sumPtTrackIsoForEgammaSC_endcap, PFEGammaAlgo::PFEGConfigInfo::sumPtTrackIsoForPhoton, PFEGammaAlgo::PFEGConfigInfo::sumPtTrackIsoSlopeForPhoton, useCalibrationsFromDB_, PFEGammaAlgo::PFEGConfigInfo::useEGammaSupercluster, PFEGammaAlgo::PFEGConfigInfo::usePFSCEleCalib, PFEGammaAlgo::PFEGConfigInfo::useReg, useRegressionFromDB_, useVerticesForNeutral_, verbose_, vertices_, and PFEGammaAlgo::PFEGConfigInfo::X0_Map.

                                                                :
  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_);  
  
  //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 202 of file PFEGammaProducer.cc.

{}

Member Function Documentation

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

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 205 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::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Implements edm::EDProducer.

Definition at line 241 of file PFEGammaProducer.cc.

References gather_cfg::blocks, ebeeClustersCollection_, reco::PFBlockElement::ECAL, eetopsSrc_, egCandidates_, egExtra_, asciidump::elements, reco::CaloCluster::energy(), 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, 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(), edm::OwnVector< T, P >::size(), funct::true, useVerticesForNeutral_, 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 ) {   
    // 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);
    
    edm::LogInfo("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);    
  }
  
  edm::LogInfo("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>();
  
  size_t non_zero_sc_idx = 0; 
  
  //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::SuperCluster& rsc = sClusters_->at(non_zero_sc_idx);
    
    reco::PFCandidateEGammaExtraRef extraref(egXtraProd,i);
    reco::SuperClusterRef refinedSCRef;
    // only set refined SC refs where the is valid!
    if( rsc.energy() != 0.0 ) {      
      refinedSCRef = reco::SuperClusterRef(sClusterProd,non_zero_sc_idx++);
    } else {
      sClusters_->erase(sClusters_->begin() + non_zero_sc_idx);
    }
    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);  
  }
  
  // release our demonspawn into the wild to cause havoc
  iEvent.put(sClusters_);
  iEvent.put(egExtra_);  
  iEvent.put(egCandidates_); 
}

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

private

Definition at line 499 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 549 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 104 of file PFEGammaProducer.h.

double PFEGammaProducer::coneEcalIsoForEgammaSC_

private

Definition at line 110 of file PFEGammaProducer.h.

double PFEGammaProducer::coneTrackIsoForEgammaSC_

private

Definition at line 113 of file PFEGammaProducer.h.

std::string PFEGammaProducer::ebeeClustersCollection_

private

Definition at line 131 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 67 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 118 of file PFEGammaProducer.h.

Referenced by produce().

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

private

Definition at line 119 of file PFEGammaProducer.h.

Referenced by produce().

std::string PFEGammaProducer::esClustersCollection_

private

Definition at line 132 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 66 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().

double PFEGammaProducer::mvaEleCut_

private

Definition at line 101 of file PFEGammaProducer.h.

std::string PFEGammaProducer::mvaWeightFileEleID_

private

Variables for PFEGamma.

Definition at line 99 of file PFEGammaProducer.h.

unsigned int PFEGammaProducer::nTrackIsoForEgammaSC_

private

Definition at line 114 of file PFEGammaProducer.h.

std::unique_ptr<PFEGammaAlgo> PFEGammaProducer::pfeg_

private

the unfiltered electron collection

particle flow algorithm

Definition at line 129 of file PFEGammaProducer.h.

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

reco::Vertex PFEGammaProducer::primaryVertex_

private

Definition at line 116 of file PFEGammaProducer.h.

Referenced by setPFEGParameters(), and setPFVertexParameters().

const GBRForest* PFEGammaProducer::ReaderEcalRes_

private

Definition at line 86 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderGC_

private

Definition at line 78 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

const GBRForest* PFEGammaProducer::ReaderGCBarrel_

private

Definition at line 83 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderGCEndCapHighr9_

private

Definition at line 84 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderGCEndCapLowr9_

private

Definition at line 85 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderLC_

private

Definition at line 79 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

const GBRForest* PFEGammaProducer::ReaderLCEB_

private

Definition at line 81 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderLCEE_

private

Definition at line 82 of file PFEGammaProducer.h.

Referenced by beginRun().

const GBRForest* PFEGammaProducer::ReaderRes_

private

Definition at line 80 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

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

private

Definition at line 120 of file PFEGammaProducer.h.

Referenced by produce().

std::vector<double> PFEGammaProducer::setchi2Values_

private

Definition at line 100 of file PFEGammaProducer.h.

double PFEGammaProducer::sumEtEcalIsoForEgammaSC_barrel_

private

Definition at line 108 of file PFEGammaProducer.h.

double PFEGammaProducer::sumEtEcalIsoForEgammaSC_endcap_

private

Definition at line 109 of file PFEGammaProducer.h.

double PFEGammaProducer::sumPtTrackIsoForEgammaSC_barrel_

private

Definition at line 111 of file PFEGammaProducer.h.

double PFEGammaProducer::sumPtTrackIsoForEgammaSC_endcap_

private

Definition at line 112 of file PFEGammaProducer.h.

std::shared_ptr<PFSCEnergyCalibration> PFEGammaProducer::thePFSCEnergyCalibration_

private

Definition at line 96 of file PFEGammaProducer.h.

bool PFEGammaProducer::useCalibrationsFromDB_

private

Definition at line 94 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

bool PFEGammaProducer::useEGammaElectrons_

private

Definition at line 88 of file PFEGammaProducer.h.

bool PFEGammaProducer::useEGammaSupercluster_

private

Definition at line 107 of file PFEGammaProducer.h.

bool PFEGammaProducer::useEGElectrons_

private

Definition at line 106 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFElectrons_

private

Definition at line 102 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFPhotons_

private

Definition at line 103 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePFSCEleCalib_

private

Definition at line 105 of file PFEGammaProducer.h.

bool PFEGammaProducer::usePhotonReg_

private

Definition at line 76 of file PFEGammaProducer.h.

bool PFEGammaProducer::useRegressionFromDB_

private

Definition at line 77 of file PFEGammaProducer.h.

Referenced by beginRun(), and PFEGammaProducer().

bool PFEGammaProducer::useVerticesForNeutral_

private

Definition at line 91 of file PFEGammaProducer.h.

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

bool PFEGammaProducer::verbose_

private

verbose ?

Definition at line 73 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer().

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

private

Definition at line 68 of file PFEGammaProducer.h.

Referenced by PFEGammaProducer(), and produce().