#include <PFEGammaAlgo.h>

Classes
struct	PFEGConfigInfo

struct	ProtoEGObject

Public Types
typedef std::unordered_map< unsigned int, std::vector< unsigned int > >	AsscMap

typedef std::unordered_map< const PFClusterElement *, std::vector< PFClusterFlaggedElement > >	ClusterMap

typedef reco::PFCluster::EEtoPSAssociation	EEtoPSAssociation

typedef std::vector< std::pair< const reco::PFBlockElement , const reco::PFBlockElement > >	ElementMap

typedef std::unordered_map< const PFGSFElement *, std::vector< PFKFFlaggedElement > >	GSFToTrackMap

typedef std::unordered_map< const PFKFElement *, float >	KFValMap

typedef reco::PFBlockElementBrem	PFBremElement

typedef std::pair< const PFBremElement *, bool >	PFBremFlaggedElement

typedef reco::PFBlockElementCluster	PFClusterElement

typedef std::pair< const PFClusterElement *, bool >	PFClusterFlaggedElement

typedef std::pair< const reco::PFBlockElement *, bool >	PFFlaggedElement

typedef reco::PFBlockElementGsfTrack	PFGSFElement

typedef std::pair< const PFGSFElement *, bool >	PFGSFFlaggedElement

typedef reco::PFBlockElementTrack	PFKFElement

typedef std::pair< const PFKFElement *, bool >	PFKFFlaggedElement

typedef reco::PFBlockElementSuperCluster	PFSCElement

typedef std::pair< const PFSCElement *, bool >	PFSCFlaggedElement

Public Member Functions
reco::PFCandidateCollection &	getCandidates ()

reco::PFCandidateEGammaExtraCollection &	getEGExtra ()

reco::SuperClusterCollection &	getRefinedSCs ()

bool	isEGValidCandidate (const pfEGHelpers::HeavyObjectCache *hoc, const reco::PFBlockRef &blockRef, std::vector< bool > &active)

	PFEGammaAlgo (const PFEGConfigInfo &)

void	RunPFEG (const pfEGHelpers::HeavyObjectCache *hoc, const reco::PFBlockRef &blockRef, std::vector< bool > &active)

void	setAlphaGamma_ESplanes_fromDB (const ESEEIntercalibConstants *esEEInterCalib)

void	setEEtoPSAssociation (const edm::Handle< EEtoPSAssociation > &eetops)

void	setESChannelStatus (const ESChannelStatus *channelStatus)

void	setnPU (int nVtx)

void	setPhotonPrimaryVtx (const reco::Vertex &primary)

	~PFEGammaAlgo ()

Private Types
enum	verbosityLevel { Silent, Summary, Chatty }

Private Member Functions
int	attachPSClusters (const PFClusterElement *, ClusterMap::mapped_type &)

void	buildAndRefineEGObjects (const pfEGHelpers::HeavyObjectCache *hoc, const reco::PFBlockRef &block)

reco::SuperCluster	buildRefinedSuperCluster (const ProtoEGObject &)

float	calculate_ele_mva (const pfEGHelpers::HeavyObjectCache *hoc, const ProtoEGObject &, reco::PFCandidateEGammaExtra &)

void	dumpCurrentRefinableObjects () const

float	EvaluateSingleLegMVA (const pfEGHelpers::HeavyObjectCache *hoc, const reco::PFBlockRef &blockref, const reco::Vertex &primaryvtx, unsigned int track_index)

void	fill_extra_info (const ProtoEGObject &, reco::PFCandidateEGammaExtra &)

void	fillPFCandidates (const pfEGHelpers::HeavyObjectCache *hoc, const std::list< ProtoEGObject > &, reco::PFCandidateCollection &, reco::PFCandidateEGammaExtraCollection &)

void	initializeProtoCands (std::list< ProtoEGObject > &)

bool	isAMuon (const reco::PFBlockElement &)

bool	isPrimaryTrack (const reco::PFBlockElementTrack &KfEl, const reco::PFBlockElementGsfTrack &GsfEl)

void	linkKFTrackToECAL (const PFKFFlaggedElement &, ProtoEGObject &)

void	linkRefinableObjectBremTangentsToECAL (ProtoEGObject &)

void	linkRefinableObjectConvSecondaryKFsToSecondaryKFs (ProtoEGObject &)

void	linkRefinableObjectECALToSingleLegConv (const pfEGHelpers::HeavyObjectCache *hoc, ProtoEGObject &)

void	linkRefinableObjectGSFTracksToKFs (ProtoEGObject &)

void	linkRefinableObjectKFTracksToECAL (ProtoEGObject &)

void	linkRefinableObjectPrimaryGSFTrackToECAL (ProtoEGObject &)

void	linkRefinableObjectPrimaryGSFTrackToHCAL (ProtoEGObject &)

void	linkRefinableObjectPrimaryKFsToSecondaryKFs (ProtoEGObject &)

void	linkRefinableObjectSecondaryKFsToECAL (ProtoEGObject &)

void	mergeROsByAnyLink (std::list< ProtoEGObject > &)

void	removeOrLinkECALClustersToKFTracks ()

void	unlinkRefinableObjectKFandECALMatchedToHCAL (ProtoEGObject &, bool removeFreeECAL=false, bool removeSCECAL=false)

void	unlinkRefinableObjectKFandECALWithBadEoverP (ProtoEGObject &)

bool	unwrapSuperCluster (const reco::PFBlockElementSuperCluster *, std::vector< PFClusterFlaggedElement > &, ClusterMap &)

Private Attributes
reco::PFBlockRef	_currentblock

reco::PFBlock::LinkData	_currentlinks

reco::PFCandidateCollection	_finalCandidates

ElementMap	_recoveredlinks

std::list< ProtoEGObject >	_refinableObjects

std::vector< std::vector< PFFlaggedElement > >	_splayedblock

std::vector< unsigned int >	AddFromElectron_

PFEGConfigInfo	cfg_

const ESChannelStatus *	channelStatus_

float	chi2

float	chi2_gsf

float	chi2_kf

float	Clus5x5ratio_

float	ClusEta_

float	ClusPhi_

float	ClusR9_

std::vector< std::pair< unsigned int, unsigned int > >	convGsfTrack_

float	CrysEta_

int	CrysIEta_

int	CrysIPhi_

float	CrysPhi_

float	CrysX_

float	CrysY_

float	del_phi

float	dEta_

float	DEtaGsfEcalClust

float	dPhi_

float	dPtOverPt_gsf

float	DPtOverPt_gsf

float	DPtOverPt_kf

float	e1x3_

float	e1x5_

float	e2x5Bottom_

float	e2x5Left_

float	e2x5Max_

float	e2x5Right_

float	e2x5Top_

float	e3x1_

float	e3x3_

float	E3x3_

float	e5x5Map [5][5]

float	earlyBrem

float	EB

float	ebottom_

edm::Handle< reco::PFCluster::EEtoPSAssociation >	eetops_

reco::PFCandidateCollection	egCandidate_

reco::PFCandidateEGammaExtraCollection	egExtra_

float	EGsfPoutMode

float	eleft_

float	EoverPt

float	eright_

float	eSeed_

float	Eta_gsf

float	etop_

float	EtotBremPinPoutMode

float	EtotPinMode

float	excluded_

std::vector< std::pair< unsigned int, unsigned int > >	fifthStepKfTrack_

float	firstBrem

std::vector< bool >	GsfTrackSingleEcal_

float	HOverHE

float	HOverPin

float	HoverPt

bool	isvalid_

float	lateBrem

float	lnPt_gsf

std::vector< bool >	lockExtraKf_

float	logPFClusE_

float	LowClusE_

std::vector< int >	match_ind

float	Mustache_Et_out_

float	Mustache_EtRatio_

float	MustE_

double	mvaValue

const char *	mvaWeightFile_

float	nhit_gsf

float	nhit_kf

float	nlayers

float	nlost

float	nPFClus_

float	nVtx_

reco::PFCandidateCollection	outcands_

reco::PFCandidateEGammaExtraCollection	outcandsextra_

std::vector< reco::PFCandidate >	permElectronCandidates_

float	PFCrysEtaCrack_

float	PFPhoE_

float	PFPhoECorr_

float	PFPhoEt_

float	PFPhoEta_

float	PFPhoEtCorr_

float	PFPhoPhi_

float	PFPhoR9_

float	PFPhoR9Corr_

const reco::Vertex *	primaryVertex_

float	RConv_

const GBRForest *	ReaderGC_

const GBRForest *	ReaderGCEB_

const GBRForest *	ReaderGCEEhR9_

const GBRForest *	ReaderGCEElR9_

const GBRForest *	ReaderLC_

const GBRForest *	ReaderLCEB_

const GBRForest *	ReaderLCEE_

const GBRForest *	ReaderRes_

reco::SuperClusterCollection	refinedscs_

float	RMSAll_

float	RMSMust_

float	SCEtaWidth_

float	SCPhiWidth_

float	SigmaEtaEta

float	STIP

double	sumPtTrackIsoForPhoton_

double	sumPtTrackIsoSlopeForPhoton_

float	TotPS1_

float	TotPS2_

float	track_pt

verbosityLevel	verbosityLevel_

float	VtxZ_

TH2D *	X0_inner

TH2D *	X0_middle

TH2D *	X0_outer

TH2D *	X0_sum

float	x0inner_

float	x0middle_

float	x0outer_

Detailed Description

Definition at line 58 of file PFEGammaAlgo.h.

Member Typedef Documentation

typedef std::unordered_map<unsigned int, std::vector<unsigned int> > PFEGammaAlgo::AsscMap

Definition at line 72 of file PFEGammaAlgo.h.

typedef std::unordered_map<const PFClusterElement*, std::vector<PFClusterFlaggedElement> > PFEGammaAlgo::ClusterMap

Definition at line 78 of file PFEGammaAlgo.h.

typedef reco::PFCluster::EEtoPSAssociation PFEGammaAlgo::EEtoPSAssociation

Definition at line 60 of file PFEGammaAlgo.h.

typedef std::vector<std::pair<const reco::PFBlockElement*, const reco::PFBlockElement*> > PFEGammaAlgo::ElementMap

Definition at line 74 of file PFEGammaAlgo.h.

typedef std::unordered_map<const PFGSFElement*, std::vector<PFKFFlaggedElement> > PFEGammaAlgo::GSFToTrackMap

Definition at line 76 of file PFEGammaAlgo.h.

typedef std::unordered_map<const PFKFElement*, float > PFEGammaAlgo::KFValMap

Definition at line 80 of file PFEGammaAlgo.h.

typedef reco::PFBlockElementBrem PFEGammaAlgo::PFBremElement

Definition at line 62 of file PFEGammaAlgo.h.

typedef std::pair<const PFBremElement*,bool> PFEGammaAlgo::PFBremFlaggedElement

Definition at line 68 of file PFEGammaAlgo.h.

typedef reco::PFBlockElementCluster PFEGammaAlgo::PFClusterElement

Definition at line 65 of file PFEGammaAlgo.h.

typedef std::pair<const PFClusterElement*,bool> PFEGammaAlgo::PFClusterFlaggedElement

Definition at line 71 of file PFEGammaAlgo.h.

typedef std::pair<const reco::PFBlockElement*,bool> PFEGammaAlgo::PFFlaggedElement

Definition at line 66 of file PFEGammaAlgo.h.

typedef reco::PFBlockElementGsfTrack PFEGammaAlgo::PFGSFElement

Definition at line 63 of file PFEGammaAlgo.h.

typedef std::pair<const PFGSFElement*,bool> PFEGammaAlgo::PFGSFFlaggedElement

Definition at line 69 of file PFEGammaAlgo.h.

typedef reco::PFBlockElementTrack PFEGammaAlgo::PFKFElement

Definition at line 64 of file PFEGammaAlgo.h.

typedef std::pair<const PFKFElement*,bool> PFEGammaAlgo::PFKFFlaggedElement

Definition at line 70 of file PFEGammaAlgo.h.

typedef reco::PFBlockElementSuperCluster PFEGammaAlgo::PFSCElement

Definition at line 61 of file PFEGammaAlgo.h.

typedef std::pair<const PFSCElement*,bool> PFEGammaAlgo::PFSCFlaggedElement

Definition at line 67 of file PFEGammaAlgo.h.

Member Enumeration Documentation

enum PFEGammaAlgo::verbosityLevel

private

Enumerator
Silent
Summary
Chatty

Definition at line 185 of file PFEGammaAlgo.h.

                       {
     Silent,
     Summary,
     Chatty
   };

Constructor & Destructor Documentation

PFEGammaAlgo::PFEGammaAlgo ( const PFEGConfigInfo & cfg )

Definition at line 695 of file PFEGammaAlgo.cc.

References cfg_, X0_inner, PFEGammaAlgo::PFEGConfigInfo::X0_Map, X0_middle, X0_outer, and X0_sum.

                                                     : 
   cfg_(cfg),
   isvalid_(false), 
   verbosityLevel_(Silent), 
   nlost(0.0), nlayers(0.0),
   chi2(0.0), STIP(0.0), del_phi(0.0),HoverPt(0.0), EoverPt(0.0), track_pt(0.0),
   mvaValue(0.0),
   CrysPhi_(0.0), CrysEta_(0.0),  VtxZ_(0.0), ClusPhi_(0.0), ClusEta_(0.0),
   ClusR9_(0.0), Clus5x5ratio_(0.0),  PFCrysEtaCrack_(0.0), logPFClusE_(0.0), e3x3_(0.0),
   CrysIPhi_(0), CrysIEta_(0),
   CrysX_(0.0), CrysY_(0.0),
   EB(0.0),
   eSeed_(0.0), e1x3_(0.0),e3x1_(0.0), e1x5_(0.0), e2x5Top_(0.0),  e2x5Bottom_(0.0), e2x5Left_(0.0),  e2x5Right_(0.0),
   etop_(0.0), ebottom_(0.0), eleft_(0.0), eright_(0.0),
   e2x5Max_(0.0),
   PFPhoEta_(0.0), PFPhoPhi_(0.0), PFPhoR9_(0.0), PFPhoR9Corr_(0.0), SCPhiWidth_(0.0), SCEtaWidth_(0.0), 
   PFPhoEt_(0.0), RConv_(0.0), PFPhoEtCorr_(0.0), PFPhoE_(0.0), PFPhoECorr_(0.0), MustE_(0.0), E3x3_(0.0),
   dEta_(0.0), dPhi_(0.0), LowClusE_(0.0), RMSAll_(0.0), RMSMust_(0.0), nPFClus_(0.0),
   TotPS1_(0.0), TotPS2_(0.0),
   nVtx_(0.0),
   x0inner_(0.0), x0middle_(0.0), x0outer_(0.0),
   excluded_(0.0), Mustache_EtRatio_(0.0), Mustache_Et_out_(0.0),
   channelStatus_(nullptr)
 {   
   //Material Map
   TFile *XO_File = new TFile(cfg_.X0_Map.c_str(),"READ");
   X0_sum    = (TH2D*)XO_File->Get("TrackerSum");
   X0_inner  = (TH2D*)XO_File->Get("Inner");
   X0_middle = (TH2D*)XO_File->Get("Middle");
   X0_outer  = (TH2D*)XO_File->Get("Outer");
   
 }

PFEGammaAlgo::~PFEGammaAlgo ( )

inline

Definition at line 139 of file PFEGammaAlgo.h.

139 { };

Member Function Documentation

int PFEGammaAlgo::attachPSClusters	(	const PFClusterElement *	,
		ClusterMap::mapped_type &
	)

private

Definition at line 1260 of file PFEGammaAlgo.cc.

References _splayedblock, docast, PFLayer::ECAL_BARREL, eetops_, edm::Ptr< T >::key(), reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, edm::refToPtr(), and groupFilesInBlocks::temp.

Referenced by linkKFTrackToECAL(), linkRefinableObjectBremTangentsToECAL(), linkRefinableObjectPrimaryGSFTrackToECAL(), linkRefinableObjectSecondaryKFsToECAL(), and unwrapSuperCluster().

                                                    {  
    if( ecalclus->clusterRef()->layer() == PFLayer::ECAL_BARREL ) return 0;
    edm::Ptr<reco::PFCluster> clusptr = refToPtr(ecalclus->clusterRef());
    EEtoPSElement ecalkey = std::make_pair(clusptr.key(),clusptr);
    auto assc_ps = std::equal_range(eetops_->cbegin(),
                    eetops_->cend(),
                    ecalkey,
                    comparePSMapByKey);
    for( const auto& ps1 : _splayedblock[reco::PFBlockElement::PS1] ) {
      edm::Ptr<reco::PFCluster> temp = refToPtr(ps1.first->clusterRef());
      for( auto pscl = assc_ps.first; pscl != assc_ps.second; ++pscl ) {
        if( pscl->second == temp ) {
      const ClusterElement* pstemp = 
        docast(const ClusterElement*,ps1.first);
      eslist.push_back( PFClusterFlaggedElement(pstemp,true) );
        }
      }
    }
    for( const auto& ps2 : _splayedblock[reco::PFBlockElement::PS2] ) {
      edm::Ptr<reco::PFCluster> temp = refToPtr(ps2.first->clusterRef());
      for( auto pscl = assc_ps.first; pscl != assc_ps.second; ++pscl ) {
        if( pscl->second == temp ) {
      const ClusterElement* pstemp = 
        docast(const ClusterElement*,ps2.first);
      eslist.push_back( PFClusterFlaggedElement(pstemp,true) );
        }
      }
    }
    return eslist.size();
  }

void PFEGammaAlgo::buildAndRefineEGObjects	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		const reco::PFBlockRef &	block
	)

private

Definition at line 829 of file PFEGammaAlgo.cc.

Referenced by RunPFEG().

                                                                         {
   LOGVERB("PFEGammaAlgo") 
     << "Resetting PFEGammaAlgo for new block and running!" << std::endl;
   _splayedblock.clear();
   _recoveredlinks.clear();
   _refinableObjects.clear();
   _finalCandidates.clear();  
   _splayedblock.resize(13); // make sure that we always have the HGCAL entry
 
   _currentblock = block;
   _currentlinks = block->linkData();
   //LOGDRESSED("PFEGammaAlgo") << *_currentblock << std::endl;
   LOGVERB("PFEGammaAlgo") << "Splaying block" << std::endl;  
   //unwrap the PF block into a fast access map
   for( const auto& pfelement : _currentblock->elements() ) {
     if( isAMuon(pfelement) ) continue; // don't allow muons in our element list
     if (pfelement.type() == PFBlockElement::HCAL && 
         pfelement.clusterRef()->flags() & reco::CaloCluster::badHcalMarker) continue; // skip also dead area markers for now
     const size_t itype = (size_t)pfelement.type();    
     if( itype >= _splayedblock.size() ) _splayedblock.resize(itype+1);    
     _splayedblock[itype].push_back(std::make_pair(&pfelement,true));    
   }
 
   // show the result of splaying the tree if it's really *really* needed
 #ifdef PFLOW_DEBUG
   std::stringstream splayout;
   for( size_t itype = 0; itype < _splayedblock.size(); ++itype ) {
     splayout << "\tType: " << itype << " indices: ";
     for( const auto& flaggedelement : _splayedblock[itype] ) {
       splayout << flaggedelement.first->index() << ' ';
     }
     if( itype != _splayedblock.size() - 1 ) splayout << std::endl;
   }
   LOGVERB("PFEGammaAlgo") << splayout.str();  
 #endif
 
   // precleaning of the ECAL clusters with respect to primary KF tracks
   // we don't allow clusters in super clusters to be locked out this way
   removeOrLinkECALClustersToKFTracks();
 
   initializeProtoCands(_refinableObjects); 
   LOGDRESSED("PFEGammaAlgo") 
     << "Initialized " << _refinableObjects.size() << " proto-EGamma objects"
     << std::endl;
   dumpCurrentRefinableObjects();
 
   //
   // now we start the refining steps
   //
   //
   
   // --- Primary Linking Step ---
   // since this is particle flow and we try to work from the pixels out
   // we start by linking the tracks together and finding the ECAL clusters
   for( auto& RO : _refinableObjects ) {
     // find the KF tracks associated to GSF primary tracks
     linkRefinableObjectGSFTracksToKFs(RO);
     // do the same for HCAL clusters associated to the GSF
     linkRefinableObjectPrimaryGSFTrackToHCAL(RO);
     // link secondary KF tracks associated to primary KF tracks
     linkRefinableObjectPrimaryKFsToSecondaryKFs(RO);
     // pick up clusters that are linked to the GSF primary
     linkRefinableObjectPrimaryGSFTrackToECAL(RO);
     // link associated KF to ECAL (ECAL part grabs PS clusters too if able)
     linkRefinableObjectKFTracksToECAL(RO);
     // now finally look for clusters associated to brem tangents
     linkRefinableObjectBremTangentsToECAL(RO);
   }
 
   LOGDRESSED("PFEGammaAlgo")
     << "Dumping after GSF and KF Track (Primary) Linking : " << std::endl;
   dumpCurrentRefinableObjects();
 
   // merge objects after primary linking
   mergeROsByAnyLink(_refinableObjects);
 
   LOGDRESSED("PFEGammaAlgo")
     << "Dumping after first merging operation : " << std::endl;
   dumpCurrentRefinableObjects();
 
   // --- Secondary Linking Step ---
   // after this we go through the ECAL clusters on the remaining tracks
   // and try to link those in...
   for( auto& RO : _refinableObjects ) {    
     // look for conversion legs
     linkRefinableObjectECALToSingleLegConv(hoc,RO);
     dumpCurrentRefinableObjects();
     // look for tracks that complement conversion legs
     linkRefinableObjectConvSecondaryKFsToSecondaryKFs(RO);
     // look again for ECAL clusters (this time with an e/p cut)
     linkRefinableObjectSecondaryKFsToECAL(RO);
   } 
 
   LOGDRESSED("PFEGammaAlgo")
     << "Dumping after ECAL to Track (Secondary) Linking : " << std::endl;
   dumpCurrentRefinableObjects();
 
   // merge objects after primary linking
   mergeROsByAnyLink(_refinableObjects);
 
   LOGDRESSED("PFEGammaAlgo")
     << "There are " << _refinableObjects.size() 
     << " after the 2nd merging step." << std::endl;
   dumpCurrentRefinableObjects();
 
   // -- unlinking and proto-object vetos, final sorting
   for( auto& RO : _refinableObjects ) {
     // remove secondary KFs (and possibly ECALs) matched to HCAL clusters
     unlinkRefinableObjectKFandECALMatchedToHCAL(RO, false, false);
     // remove secondary KFs and ECALs linked to them that have bad E/p_in 
     // and spoil the resolution
     unlinkRefinableObjectKFandECALWithBadEoverP(RO);
     // put things back in order after partitioning
     std::sort(RO.ecalclusters.begin(), RO.ecalclusters.end(),
         [](const PFClusterFlaggedElement& a,
            const PFClusterFlaggedElement& b) 
         { return ( a.first->clusterRef()->correctedEnergy() > 
                b.first->clusterRef()->correctedEnergy() ) ; });
     setROElectronCluster(RO);
   }
 
   LOGDRESSED("PFEGammaAlgo")
     << "There are " << _refinableObjects.size() 
     << " after the unlinking and vetos step." << std::endl;
   dumpCurrentRefinableObjects();
 
   // fill the PF candidates and then build the refined SC
   fillPFCandidates(hoc,_refinableObjects,outcands_,outcandsextra_);
 
 }

reco::SuperCluster PFEGammaAlgo::buildRefinedSuperCluster ( const ProtoEGObject & RO )

private

Definition at line 2280 of file PFEGammaAlgo.cc.

Referenced by fill_extra_info(), and fillPFCandidates().

                                                               {
   if( RO.ecalclusters.empty() ) { 
     return reco::SuperCluster(0.0,math::XYZPoint(0,0,0));
   }
     
   SumPSEnergy sumps1(reco::PFBlockElement::PS1), 
     sumps2(reco::PFBlockElement::PS2);  
                           
   bool isEE = false;
   edm::Ptr<reco::PFCluster> clusptr;
   // need the vector of raw pointers for a PF width class
   std::vector<const reco::PFCluster*> bare_ptrs;
   // calculate necessary parameters and build the SC
   double posX(0), posY(0), posZ(0),
     rawSCEnergy(0), corrSCEnergy(0), corrPSEnergy(0),
     PS1_clus_sum(0), PS2_clus_sum(0),
     ePS1(0), ePS2(0), ps1_energy(0.0), ps2_energy(0.0); 
   int condP1(1), condP2(1);
   for( auto& clus : RO.ecalclusters ) {
     ePS1 = 0;
     ePS2 = 0;
     isEE = PFLayer::ECAL_ENDCAP == clus.first->clusterRef()->layer();
     clusptr = 
       edm::refToPtr<reco::PFClusterCollection>(clus.first->clusterRef());
     bare_ptrs.push_back(clusptr.get());    
 
     const double cluseraw = clusptr->energy();
     double cluscalibe = clusptr->correctedEnergy();
     const math::XYZPoint& cluspos = clusptr->position();
     posX += cluseraw * cluspos.X();
     posY += cluseraw * cluspos.Y();
     posZ += cluseraw * cluspos.Z();
     // update EE calibrated super cluster energies
     if( isEE && RO.ecal2ps.count(clus.first)) {
       ePS1 = 0;
       ePS2 = 0;
       condP1 = condP2 = 1;
 
       const auto& psclusters = RO.ecal2ps.at(clus.first);
       
       for( auto i_ps = psclusters.begin(); i_ps != psclusters.end(); ++i_ps) {
     const PFClusterRef&  psclus = i_ps->first->clusterRef();
     
     auto const& recH_Frac = psclus->recHitFractions();  
     
     switch( psclus->layer() ) {
     case PFLayer::PS1:
       for (auto const& recH : recH_Frac){
         ESDetId strip1 = recH.recHitRef()->detId();
         if(strip1 != ESDetId(0)){
           ESChannelStatusMap::const_iterator status_p1 = channelStatus_->getMap().find(strip1);
           //getStatusCode() == 0 => active channel
           // apply correction if all recHits are dead
           if(status_p1->getStatusCode() == 0) condP1 = 0;
         }
       }
       break;
     case PFLayer::PS2:
       for (auto const& recH : recH_Frac){
         ESDetId strip2 = recH.recHitRef()->detId();
         if(strip2 != ESDetId(0)) {
           ESChannelStatusMap::const_iterator status_p2 = channelStatus_->getMap().find(strip2);
           if(status_p2->getStatusCode() == 0) condP2 = 0;
         }
       }
       break;
     default:
       break;
     }
       }
       
       
       PS1_clus_sum = std::accumulate(psclusters.begin(),psclusters.end(),
                      0.0,sumps1);
       PS2_clus_sum = std::accumulate(psclusters.begin(),psclusters.end(),
                      0.0,sumps2);
             
       if(condP1 == 1) ePS1 = -1.;
       if(condP2 == 1) ePS2 = -1.;
 
       cluscalibe = 
     cfg_.thePFEnergyCalibration->energyEm(*clusptr,
                           PS1_clus_sum,PS2_clus_sum,
                           ePS1, ePS2,
                           cfg_.applyCrackCorrections);
     }
     if(ePS1 == -1.) ePS1 = 0;
     if(ePS2 == -1.) ePS2 = 0;
 
     rawSCEnergy  += cluseraw;
     corrSCEnergy += cluscalibe;    
     ps1_energy   += ePS1;
     ps2_energy   += ePS2;
     corrPSEnergy += ePS1 + ePS2;    
   }
   posX /= rawSCEnergy;
   posY /= rawSCEnergy;
   posZ /= rawSCEnergy;
 
   // now build the supercluster
   reco::SuperCluster new_sc(corrSCEnergy,math::XYZPoint(posX,posY,posZ)); 
 
   clusptr = 
     edm::refToPtr<reco::PFClusterCollection>(RO.ecalclusters.front().
                          first->clusterRef());
   new_sc.setCorrectedEnergy(corrSCEnergy);
   new_sc.setSeed(clusptr);
   new_sc.setPreshowerEnergyPlane1(ps1_energy);
   new_sc.setPreshowerEnergyPlane2(ps2_energy);
   new_sc.setPreshowerEnergy(corrPSEnergy); 
   for( const auto& clus : RO.ecalclusters ) {
     clusptr = 
       edm::refToPtr<reco::PFClusterCollection>(clus.first->clusterRef());
     new_sc.addCluster(clusptr);
     auto& hits_and_fractions = clusptr->hitsAndFractions();
     for( auto& hit_and_fraction : hits_and_fractions ) {
       new_sc.addHitAndFraction(hit_and_fraction.first,hit_and_fraction.second);
     }
      // put the preshower stuff back in later
     if( RO.ecal2ps.count(clus.first) ) {
       const auto& cluspsassociation = RO.ecal2ps.at(clus.first);
       // EE rechits should be uniquely matched to sets of pre-shower
       // clusters at this point, so we throw an exception if otherwise
       // now wrapped in EDM debug flags
       for( const auto& pscluselem : cluspsassociation ) {    
     edm::Ptr<reco::PFCluster> psclus = 
       edm::refToPtr<reco::PFClusterCollection>(pscluselem.first->
                            clusterRef());
 #ifdef PFFLOW_DEBUG
     auto found_pscluster = std::find(new_sc.preshowerClustersBegin(),
                      new_sc.preshowerClustersEnd(),
                      reco::CaloClusterPtr(psclus));
     if( found_pscluster == new_sc.preshowerClustersEnd() ) {
 #endif        
       new_sc.addPreshowerCluster(psclus);
 #ifdef PFFLOW_DEBUG
     } else {
       throw cms::Exception("PFECALSuperClusterAlgo::buildSuperCluster")
         << "Found a PS cluster matched to more than one EE cluster!" 
         << std::endl << std::hex << psclus.get() << " == " 
         << found_pscluster->get() << std::dec << std::endl;
     }
 #endif
       }    
     }
   }
   
   // calculate linearly weighted cluster widths
   PFClusterWidthAlgo pfwidth(bare_ptrs);
   new_sc.setEtaWidth(pfwidth.pflowEtaWidth());
   new_sc.setPhiWidth(pfwidth.pflowPhiWidth());
   
   // cache the value of the raw energy  
   new_sc.rawEnergy();
   
   return new_sc;
 }

float PFEGammaAlgo::calculate_ele_mva	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		const ProtoEGObject &	RO,
		reco::PFCandidateEGammaExtra &	xtra
	)

private

Definition at line 2084 of file PFEGammaAlgo.cc.

Referenced by fillPFCandidates().

                                             {
   if( RO.primaryGSFs.empty() ) return -2.0f;
   const PFGSFElement* gsfElement = RO.primaryGSFs.front().first;
   const PFKFElement* kfElement = nullptr;
   if( !RO.primaryKFs.empty() ) kfElement = RO.primaryKFs.front().first;
   reco::GsfTrackRef RefGSF= gsfElement->GsftrackRef();
   reco::TrackRef RefKF;
   constexpr float m_el = 0.000511;
   const double Ein_gsf = std::hypot(RefGSF->pMode(),m_el);
   double deta_gsfecal = 1e6;
   double sigmaEtaEta = 1e-14;
   const double Ene_hcalgsf = std::accumulate(RO.hcalClusters.begin(),
                          RO.hcalClusters.end(),
                          0.0,
                     [](const double a,
                        const PFClusterFlaggedElement& b) 
                 { return a + b.first->clusterRef()->energy(); }
                          );
   if( !RO.primaryKFs.empty() ) {
     RefKF = RO.primaryKFs.front().first->trackRef();
   }
   const double Eout_gsf = gsfElement->Pout().t();
   const double Etaout_gsf = gsfElement->positionAtECALEntrance().eta();
   double FirstEcalGsfEnergy(0.0), OtherEcalGsfEnergy(0.0), EcalBremEnergy(0.0);
   //shower shape of cluster closest to gsf track
   std::vector<const reco::PFCluster*> gsfcluster;  
   for( const auto& ecal : RO.ecalclusters ) {
     const double cenergy = ecal.first->clusterRef()->correctedEnergy();
     ElementMap::value_type gsfToEcal(gsfElement,ecal.first);
     ElementMap::value_type kfToEcal(kfElement,ecal.first);
     bool hasgsf = 
       ( std::find(RO.localMap.begin(), RO.localMap.end(), gsfToEcal) == 
     RO.localMap.end() );
     bool haskf = 
       ( std::find(RO.localMap.begin(), RO.localMap.end(), kfToEcal) == 
     RO.localMap.end() );
     bool hasbrem = false;
     for( const auto& brem : RO.brems ) {
       ElementMap::value_type bremToEcal(brem.first,ecal.first);
       if( std::find(RO.localMap.begin(), RO.localMap.end(), bremToEcal) != 
       RO.localMap.end() ) {
     hasbrem = true;
       }
     }
     if( hasbrem && ecal.first != RO.electronClusters[0] ) {      
       EcalBremEnergy += cenergy;
     } 
     if( !hasbrem && ecal.first != RO.electronClusters[0] ) {
       if( hasgsf ) OtherEcalGsfEnergy += cenergy;
       if( haskf  ) EcalBremEnergy += cenergy; // from conv. brem!
       if( !(hasgsf || haskf) ) OtherEcalGsfEnergy += cenergy; // stuff from SC
     }
   }
   
   if( RO.electronClusters[0] ) {
     reco::PFClusterRef cref = RO.electronClusters[0]->clusterRef();
     xtra.setGsfElectronClusterRef(_currentblock,*(RO.electronClusters[0]));
     FirstEcalGsfEnergy = cref->correctedEnergy();    
     deta_gsfecal = cref->positionREP().eta() - Etaout_gsf;
     gsfcluster.push_back(&*cref);
     PFClusterWidthAlgo pfwidth(gsfcluster);
     sigmaEtaEta = pfwidth.pflowSigmaEtaEta();
   } 
 
   // brem sequence information
   lateBrem = firstBrem = earlyBrem = -1.0f;
   if(RO.nBremsWithClusters > 0) {
     if (RO.lateBrem == 1) lateBrem = 1.0f;
     else lateBrem = 0.0f;
     firstBrem = RO.firstBrem;
     if(RO.firstBrem < 4) earlyBrem = 1.0f;
     else earlyBrem = 0.0f;
   }     
   xtra.setEarlyBrem(earlyBrem);
   xtra.setLateBrem(lateBrem);
   if( FirstEcalGsfEnergy > 0.0 ) {
     if( RefGSF.isNonnull() ) {
       xtra.setGsfTrackPout(gsfElement->Pout());
       // normalization observables
       const float Pt_gsf = RefGSF->ptMode();
       lnPt_gsf = std::log(Pt_gsf);
       Eta_gsf = RefGSF->etaMode();
       // tracking observables
       const double ptModeErrorGsf = RefGSF->ptModeError();
       dPtOverPt_gsf = (ptModeErrorGsf > 0. ? ptModeErrorGsf/Pt_gsf : 1.0);
       nhit_gsf = RefGSF->hitPattern().trackerLayersWithMeasurement();
       chi2_gsf = RefGSF->normalizedChi2();
       DPtOverPt_gsf =  (Pt_gsf - gsfElement->Pout().pt())/Pt_gsf;
       // kalman filter vars
       nhit_kf = 0;
       chi2_kf = -0.01;
       DPtOverPt_kf = -0.01;
       if( RefKF.isNonnull() ) {
     nhit_kf = RefKF->hitPattern().trackerLayersWithMeasurement();
     chi2_kf = RefKF->normalizedChi2();
     // not used for moment, weird behavior of variable
     // DPtOverPt_kf = (RefKF->pt() - RefKF->outerPt())/RefKF->pt();
       } 
       //tracker + calorimetry observables
       const double EcalETot = 
     (FirstEcalGsfEnergy+OtherEcalGsfEnergy+EcalBremEnergy);
       EtotPinMode  = EcalETot / Ein_gsf;
       EGsfPoutMode = FirstEcalGsfEnergy / Eout_gsf;
       EtotBremPinPoutMode = ( (EcalBremEnergy + OtherEcalGsfEnergy) / 
                   (Ein_gsf - Eout_gsf) );
       DEtaGsfEcalClust = std::abs(deta_gsfecal);
       SigmaEtaEta = std::log(sigmaEtaEta);
       xtra.setDeltaEta(DEtaGsfEcalClust);
       xtra.setSigmaEtaEta(sigmaEtaEta);      
       
       HOverHE = Ene_hcalgsf/(Ene_hcalgsf + FirstEcalGsfEnergy);
       HOverPin = Ene_hcalgsf / Ein_gsf;
       xtra.setHadEnergy(Ene_hcalgsf);
 
       // Apply bounds to variables and calculate MVA
       DPtOverPt_gsf = std::max(DPtOverPt_gsf,-0.2f);
       DPtOverPt_gsf =  std::min(DPtOverPt_gsf,1.0f);  
       dPtOverPt_gsf = std::min(dPtOverPt_gsf,0.3f);  
       chi2_gsf = std::min(chi2_gsf,10.0f);  
       DPtOverPt_kf = std::max(DPtOverPt_kf,-0.2f);
       DPtOverPt_kf = std::min(DPtOverPt_kf,1.0f);  
       chi2_kf = std::min(chi2_kf,10.0f);  
       EtotPinMode = std::max(EtotPinMode,0.0f);
       EtotPinMode = std::min(EtotPinMode,5.0f);  
       EGsfPoutMode = std::max(EGsfPoutMode,0.0f);
       EGsfPoutMode = std::min(EGsfPoutMode,5.0f);  
       EtotBremPinPoutMode = std::max(EtotBremPinPoutMode,0.0f);
       EtotBremPinPoutMode = std::min(EtotBremPinPoutMode,5.0f);  
       DEtaGsfEcalClust = std::min(DEtaGsfEcalClust,0.1f);  
       SigmaEtaEta = std::max(SigmaEtaEta,-14.0f);  
       HOverPin = std::max(HOverPin,0.0f);
       HOverPin = std::min(HOverPin,5.0f);
       /*
       std::cout << " **** PFEG BDT observables ****" << endl;
       std::cout << " < Normalization > " << endl;
       std::cout << " Pt_gsf " << Pt_gsf << " Pin " << Ein_gsf  
         << " Pout " << Eout_gsf << " Eta_gsf " << Eta_gsf << endl;
       std::cout << " < PureTracking > " << endl;
       std::cout << " dPtOverPt_gsf " << dPtOverPt_gsf 
         << " DPtOverPt_gsf " << DPtOverPt_gsf
         << " chi2_gsf " << chi2_gsf
         << " nhit_gsf " << nhit_gsf
         << " DPtOverPt_kf " << DPtOverPt_kf
         << " chi2_kf " << chi2_kf 
         << " nhit_kf " << nhit_kf <<  endl;
       std::cout << " < track-ecal-hcal-ps " << endl;
       std::cout << " EtotPinMode " << EtotPinMode 
         << " EGsfPoutMode " << EGsfPoutMode
         << " EtotBremPinPoutMode " << EtotBremPinPoutMode
         << " DEtaGsfEcalClust " << DEtaGsfEcalClust 
         << " SigmaEtaEta " << SigmaEtaEta
         << " HOverHE " << HOverHE << " Hcal energy " << Ene_hcalgsf
         << " HOverPin " << HOverPin 
         << " lateBrem " << lateBrem
         << " firstBrem " << firstBrem << endl;
       */
       
       float vars[] = { lnPt_gsf, Eta_gsf, dPtOverPt_gsf, DPtOverPt_gsf, chi2_gsf,
                        nhit_kf, chi2_kf, EtotPinMode, EGsfPoutMode, EtotBremPinPoutMode,
                        DEtaGsfEcalClust, SigmaEtaEta, HOverHE, lateBrem, firstBrem };
 
       return hoc->gbrEle_->GetAdaBoostClassifier(vars);
     }
   }
   return -2.0f;
 }

void PFEGammaAlgo::dumpCurrentRefinableObjects ( ) const

private

Definition at line 1292 of file PFEGammaAlgo.cc.

References _refinableObjects, info(), and removeOrLinkECALClustersToKFTracks().

Referenced by buildAndRefineEGObjects().

                                                       {
  #ifdef PFLOW_DEBUG
    edm::LogVerbatim("PFEGammaAlgo") 
      //<< "Dumping current block: " << std::endl << *_currentblock << std::endl
      << "Dumping " << _refinableObjects.size()
      << " refinable objects for this block: " << std::endl;
    for( const auto& ro : _refinableObjects ) {    
      std::stringstream info;
      info << "Refinable Object:" << std::endl;
      if( ro.parentSC ) {
        info << "\tSuperCluster element attached to object:" << std::endl 
         << '\t';
        ro.parentSC->Dump(info,"\t");
        info << std::endl;      
      } 
      if( ro.electronSeed.isNonnull() ) {
        info << "\tGSF element attached to object:" << std::endl;
        ro.primaryGSFs.front().first->Dump(info,"\t");
        info << std::endl;
        info << "firstBrem : " << ro.firstBrem 
         << " lateBrem : " << ro.lateBrem
         << " nBrems with cluster : " << ro.nBremsWithClusters
         << std::endl;;
        if( ro.electronClusters.size() && ro.electronClusters[0] ) {
      info << "electron cluster : ";
      ro.electronClusters[0]->Dump(info,"\t");
      info << std::endl;
        } else {
      info << " no electron cluster." << std::endl;
        }     
      }
      if( ro.primaryKFs.size() ) {
        info << "\tPrimary KF tracks attached to object: " << std::endl;
        for( const auto& kf : ro.primaryKFs ) {
      kf.first->Dump(info,"\t");
      info << std::endl;
        }
      }
      if( ro.secondaryKFs.size() ) {
        info << "\tSecondary KF tracks attached to object: " << std::endl;
        for( const auto& kf : ro.secondaryKFs ) {
      kf.first->Dump(info,"\t");
      info << std::endl;
        }
      }
      if( ro.brems.size() ) {
        info << "\tBrem tangents attached to object: " << std::endl;
        for( const auto& brem : ro.brems ) {
      brem.first->Dump(info,"\t");
      info << std::endl;
        }
      }
      if( ro.ecalclusters.size() ) {
        info << "\tECAL clusters attached to object: " << std::endl;
        for( const auto& clus : ro.ecalclusters ) {
      clus.first->Dump(info,"\t");
      info << std::endl;
      if( ro.ecal2ps.find(clus.first) != ro.ecal2ps.end() ) {
        for( const auto& psclus : ro.ecal2ps.at(clus.first) ) {
          info << "\t\t Attached PS Cluster: ";
          psclus.first->Dump(info,"");
          info << std::endl;
        }
      }
        }
      }
      edm::LogVerbatim("PFEGammaAlgo") << info.str();
    }
  #endif
  }

float PFEGammaAlgo::EvaluateSingleLegMVA	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		const reco::PFBlockRef &	blockref,
		const reco::Vertex &	primaryvtx,
		unsigned int	track_index
	)

private

Definition at line 746 of file PFEGammaAlgo.cc.

References reco::PFBlock::associatedElements(), groupFilesInBlocks::block, chi2, del_phi, hiPixelPairStep_cff::deltaPhi, reco::PFBlockElement::ECAL, allElectronIsolations_cfi::elements, reco::PFBlock::elements(), EoverPt, pfEGHelpers::HeavyObjectCache::gbrSingleLeg_, reco::PFBlockElement::HCAL, HoverPt, reco::PFBlock::linkData(), reco::PFBlock::LINKTEST_ALL, mvaValue, nlayers, nlost, colinearityKinematic::Phi, PV3DBase< T, PVType, FrameType >::phi(), STIP, track_pt, X, reco::Vertex::x(), reco::Vertex::y(), and reco::Vertex::z().

Referenced by fillPFCandidates(), linkRefinableObjectECALToSingleLegConv(), and RunPFEG().

                                                {  
   const reco::PFBlock& block = *blockref;  
   const edm::OwnVector< reco::PFBlockElement >& elements = block.elements();  
   //use this to store linkdata in the associatedElements function below  
   const PFBlock::LinkData& linkData =  block.linkData();  
   //calculate MVA Variables  
   chi2=elements[track_index].trackRef()->chi2()/elements[track_index].trackRef()->ndof(); 
   nlost=elements[track_index].trackRef()->hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS); 
   nlayers=elements[track_index].trackRef()->hitPattern().trackerLayersWithMeasurement(); 
   track_pt=elements[track_index].trackRef()->pt();  
   STIP=elements[track_index].trackRefPF()->STIP();  
    
   float linked_e=0;  
   float linked_h=0;  
   std::multimap<double, unsigned int> ecalAssoTrack;  
   block.associatedElements( track_index,linkData,  
                 ecalAssoTrack,  
                 reco::PFBlockElement::ECAL,  
                 reco::PFBlock::LINKTEST_ALL );  
   std::multimap<double, unsigned int> hcalAssoTrack;  
   block.associatedElements( track_index,linkData,  
                 hcalAssoTrack,  
                 reco::PFBlockElement::HCAL,  
                 reco::PFBlock::LINKTEST_ALL );  
   if(!ecalAssoTrack.empty()) {  
     for(std::multimap<double, unsigned int>::iterator itecal = ecalAssoTrack.begin();  
     itecal != ecalAssoTrack.end(); ++itecal) {  
       linked_e=linked_e+elements[itecal->second].clusterRef()->energy();  
     }  
   }  
   if(!hcalAssoTrack.empty()) {  
     for(std::multimap<double, unsigned int>::iterator ithcal = hcalAssoTrack.begin();  
     ithcal != hcalAssoTrack.end(); ++ithcal) {  
       linked_h=linked_h+elements[ithcal->second].clusterRef()->energy();  
     }  
   }  
   EoverPt=linked_e/elements[track_index].trackRef()->pt();  
   HoverPt=linked_h/elements[track_index].trackRef()->pt();  
   GlobalVector rvtx(elements[track_index].trackRef()->innerPosition().X()-primaryvtx.x(),  
             elements[track_index].trackRef()->innerPosition().Y()-primaryvtx.y(),  
             elements[track_index].trackRef()->innerPosition().Z()-primaryvtx.z());  
   double vtx_phi=rvtx.phi();  
   //delta Phi between conversion vertex and track  
   del_phi=fabs(deltaPhi(vtx_phi, elements[track_index].trackRef()->innerMomentum().Phi()));  
   
   float vars[] = { del_phi, nlayers, chi2, EoverPt,
                    HoverPt, track_pt, STIP, nlost };
 
   mvaValue = hoc->gbrSingleLeg_->GetAdaBoostClassifier(vars);
   
   return mvaValue;
 }

void PFEGammaAlgo::fill_extra_info	(	const ProtoEGObject &	RO,
		reco::PFCandidateEGammaExtra &	xtra
	)

private

Definition at line 2253 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, reco::PFCandidateEGammaExtra::addExtraNonConvTrack(), buildRefinedSuperCluster(), docast, digitizers_cfi::ecal, reco::PFBlockElement::ECAL, PFEGammaAlgo::ProtoEGObject::ecalclusters, and reco::PFBlockElement::TRACK.

Referenced by fillPFCandidates().

                                                        {
   // add tracks associated to clusters that are not T_FROM_GAMMACONV
   // info about single-leg convs is already save, so just veto in loops
   IsConversionTrack<reco::PFBlockElementTrack> isConvKf;
   auto KFbegin = _splayedblock[reco::PFBlockElement::TRACK].begin();
   auto KFend = _splayedblock[reco::PFBlockElement::TRACK].end();  
   for( auto& ecal : RO.ecalclusters ) {
     NotCloserToOther<reco::PFBlockElement::ECAL,
                      reco::PFBlockElement::TRACK,
                      true>
       ECALToTracks(_currentblock,_currentlinks,ecal.first);           
     auto notmatchedkf  = std::partition(KFbegin,KFend,ECALToTracks);
     auto notconvkf     = std::partition(KFbegin,notmatchedkf,isConvKf);
     // go through non-conv-identified kfs and check MVA to add conversions
     for( auto kf = notconvkf; kf != notmatchedkf; ++kf ) {      
       const reco::PFBlockElementTrack* elemaskf =
     docast(const reco::PFBlockElementTrack*,kf->first);
       xtra.addExtraNonConvTrack(_currentblock,*elemaskf);   
     }
   }
 }

void PFEGammaAlgo::fillPFCandidates	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		const std::list< ProtoEGObject > &	,
		reco::PFCandidateCollection &	,
		reco::PFCandidateEGammaExtraCollection &
	)

private

Definition at line 1938 of file PFEGammaAlgo.cc.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectSecondaryKFsToECAL().

                                                      {
   // reset output collections
   egcands.clear();
   egxs.clear();  
   refinedscs_.clear();
   egcands.reserve(ROs.size());
   egxs.reserve(ROs.size());
   refinedscs_.reserve(ROs.size());
   for( auto& RO : ROs ) {    
     if( RO.ecalclusters.empty()  && 
     !cfg_.produceEGCandsWithNoSuperCluster ) continue;
     
     reco::PFCandidate cand;
     reco::PFCandidateEGammaExtra xtra;
     if( !RO.primaryGSFs.empty() || !RO.primaryKFs.empty() ) {
       cand.setPdgId(-11); // anything with a primary track is an electron
     } else {
       cand.setPdgId(22); // anything with no primary track is a photon
     }    
     if( !RO.primaryKFs.empty() ) {
       cand.setCharge(RO.primaryKFs[0].first->trackRef()->charge());
       xtra.setKfTrackRef(RO.primaryKFs[0].first->trackRef());
       cand.setTrackRef(RO.primaryKFs[0].first->trackRef());
       cand.addElementInBlock(_currentblock,RO.primaryKFs[0].first->index());
     }
     if( !RO.primaryGSFs.empty() ) {        
       cand.setCharge(RO.primaryGSFs[0].first->GsftrackRef()->chargeMode());
       xtra.setGsfTrackRef(RO.primaryGSFs[0].first->GsftrackRef());
       cand.setGsfTrackRef(RO.primaryGSFs[0].first->GsftrackRef());
       cand.addElementInBlock(_currentblock,RO.primaryGSFs[0].first->index());
     }
     if( RO.parentSC ) {
       xtra.setSuperClusterPFECALRef(RO.parentSC->superClusterRef());      
       // we'll set to the refined supercluster back up in the producer
       cand.setSuperClusterRef(RO.parentSC->superClusterRef());
       xtra.setSuperClusterRef(RO.parentSC->superClusterRef());      
       cand.addElementInBlock(_currentblock,RO.parentSC->index());
     }
     // add brems
     for( const auto& bremflagged : RO.brems ) {
       const PFBremElement* brem = bremflagged.first;
       cand.addElementInBlock(_currentblock,brem->index());      
     }
     // add clusters and ps clusters
     for( const auto& ecal : RO.ecalclusters ) {
       const PFClusterElement* clus = ecal.first;
       cand.addElementInBlock(_currentblock,clus->index());      
       if( RO.ecal2ps.count(clus) ) {
     for( auto& ps : RO.ecal2ps.at(clus) ) {
       const PFClusterElement* psclus = ps.first;
       cand.addElementInBlock(_currentblock,psclus->index());    
     }
       }
     }
     // add secondary tracks
     for( const auto& secdkf : RO.secondaryKFs ) {
       const PFKFElement* kf = secdkf.first;
       cand.addElementInBlock(_currentblock,kf->index());
       const reco::ConversionRefVector& convrefs = kf->convRefs();
       bool no_conv_ref = true;
       for( const auto& convref : convrefs ) {
     if( convref.isNonnull() && convref.isAvailable() ) {
       xtra.addConversionRef(convref);
       no_conv_ref = false;
     }
       }
       if( no_conv_ref ) {
         //single leg conversions
         
         //look for stored mva value in map or else recompute
         const auto &mvavalmapped = RO.singleLegConversionMvaMap.find(kf);
         //FIXME: Abuse single mva value to store both provenance and single leg mva score
         //by storing 3.0 + mvaval
         float mvaval = ( mvavalmapped != RO.singleLegConversionMvaMap.end() ? 
                          mvavalmapped->second : 
                          3.0 + EvaluateSingleLegMVA(hoc,_currentblock,
                                                     *cfg_.primaryVtx, 
                                                     kf->index()) );
         
         xtra.addSingleLegConvTrackRefMva(std::make_pair(kf->trackRef(),mvaval));
       }
     }
     
     // build the refined supercluster from those clusters left in the cand
     refinedscs_.push_back(buildRefinedSuperCluster(RO));
 
     //*TODO* cluster time is not reliable at the moment, so only use track timing
     float trkTime = 0, trkTimeErr = -1;
     if (!RO.primaryGSFs.empty() && RO.primaryGSFs[0].first->isTimeValid()) {
         trkTime = RO.primaryGSFs[0].first->time();
         trkTimeErr = RO.primaryGSFs[0].first->timeError();
     } else if (!RO.primaryKFs.empty() && RO.primaryKFs[0].first->isTimeValid()) {
         trkTime = RO.primaryKFs[0].first->time();
         trkTimeErr = RO.primaryKFs[0].first->timeError();
     }
     if (trkTimeErr >= 0) {
       cand.setTime( trkTime, trkTimeErr );
     }
     
     const reco::SuperCluster& the_sc = refinedscs_.back();
     // with the refined SC in hand we build a naive candidate p4 
     // and set the candidate ECAL position to either the barycenter of the 
     // supercluster (if super-cluster present) or the seed of the
     // new SC generated by the EGAlgo 
     const double scE = the_sc.energy();
     if( scE != 0.0 ) {
       const math::XYZPoint& seedPos = the_sc.seed()->position();
       math::XYZVector egDir = the_sc.position()-cfg_.primaryVtx->position();
       egDir = egDir.Unit();      
       cand.setP4(math::XYZTLorentzVector(scE*egDir.x(),
                      scE*egDir.y(),
                      scE*egDir.z(),
                      scE           ));
       math::XYZPointF ecalPOS_f(seedPos.x(),seedPos.y(),seedPos.z());
       cand.setPositionAtECALEntrance(ecalPOS_f);
       cand.setEcalEnergy(the_sc.rawEnergy(),the_sc.energy());
     } else if ( cfg_.produceEGCandsWithNoSuperCluster && 
         !RO.primaryGSFs.empty() ) {
       const PFGSFElement* gsf = RO.primaryGSFs[0].first;
       const reco::GsfTrackRef& gref = gsf->GsftrackRef();
       math::XYZTLorentzVector p4(gref->pxMode(),gref->pyMode(),
                  gref->pzMode(),gref->pMode());
       cand.setP4(p4);      
       cand.setPositionAtECALEntrance(gsf->positionAtECALEntrance());
     } else if ( cfg_.produceEGCandsWithNoSuperCluster &&
         !RO.primaryKFs.empty() ) {
       const PFKFElement* kf = RO.primaryKFs[0].first;
       reco::TrackRef kref = RO.primaryKFs[0].first->trackRef();
       math::XYZTLorentzVector p4(kref->px(),kref->py(),kref->pz(),kref->p());
       cand.setP4(p4);   
       cand.setPositionAtECALEntrance(kf->positionAtECALEntrance());
     }    
     const float ele_mva_value = calculate_ele_mva(hoc,RO,xtra);
     fill_extra_info(RO,xtra);
     //std::cout << "PFEG ele_mva: " << ele_mva_value << std::endl;
     xtra.setMVA(ele_mva_value);    
     cand.set_mva_e_pi(ele_mva_value);
     egcands.push_back(cand);
     egxs.push_back(xtra);    
   }
 }

reco::PFCandidateCollection& PFEGammaAlgo::getCandidates ( )

inline

Definition at line 174 of file PFEGammaAlgo.h.

References outcands_.

174 {return outcands_;}

PFEGammaAlgo::outcands_

reco::PFCandidateCollection outcands_

Definition: PFEGammaAlgo.h:193

reco::PFCandidateEGammaExtraCollection& PFEGammaAlgo::getEGExtra ( )

inline

Definition at line 177 of file PFEGammaAlgo.h.

References outcandsextra_.

177 {return outcandsextra_;}

PFEGammaAlgo::outcandsextra_

reco::PFCandidateEGammaExtraCollection outcandsextra_

Definition: PFEGammaAlgo.h:194

reco::SuperClusterCollection& PFEGammaAlgo::getRefinedSCs ( )

inline

Definition at line 180 of file PFEGammaAlgo.h.

References refinedscs_.

180 {return refinedscs_;}

PFEGammaAlgo::refinedscs_

reco::SuperClusterCollection refinedscs_

Definition: PFEGammaAlgo.h:195

void PFEGammaAlgo::initializeProtoCands ( std::list< ProtoEGObject > & )

private

Definition at line 962 of file PFEGammaAlgo.cc.

Referenced by buildAndRefineEGObjects().

                                                                  {
   // step 1: build SC based proto-candidates
   // in the future there will be an SC Et requirement made here to control
   // block size
   for( auto& element : _splayedblock[PFBlockElement::SC] ) {
     LOGDRESSED("PFEGammaAlgo") 
       << "creating SC-based proto-object" << std::endl
       << "\tSC at index: " << element.first->index() 
       << " has type: " << element.first->type() << std::endl;
     element.second = false;
     ProtoEGObject fromSC;
     fromSC.nBremsWithClusters = -1;
     fromSC.firstBrem = -1;
     fromSC.lateBrem = -1;
     fromSC.parentBlock = _currentblock;
     fromSC.parentSC = docast(const PFSCElement*,element.first);
     // splay the supercluster so we can knock out used elements
     bool sc_success = 
       unwrapSuperCluster(fromSC.parentSC,fromSC.ecalclusters,fromSC.ecal2ps);
     if( sc_success ) {
       /*
       auto ins_pos = std::lower_bound(_refinableObjects.begin(),
                       _refinableObjects.end(),
                       fromSC,
                       [&](const ProtoEGObject& a,
                       const ProtoEGObject& b){
                     const double a_en = 
                     a.parentSC->superClusterRef()->energy();
                     const double b_en = 
                     b.parentSC->superClusterRef()->energy();
                     return a_en < b_en;
                       });
       */
       _refinableObjects.insert(_refinableObjects.end(),fromSC);
     }
   }
   // step 2: build GSF-seed-based proto-candidates
   reco::GsfTrackRef gsfref_forextra;
   reco::TrackExtraRef gsftrk_extra;
   reco::ElectronSeedRef theseedref; 
   std::list<ProtoEGObject>::iterator objsbegin, objsend;  
   for( auto& element : _splayedblock[PFBlockElement::GSF] ) {
     LOGDRESSED("PFEGammaAlgo") 
       << "creating GSF-based proto-object" << std::endl
       << "\tGSF at index: " << element.first->index() 
       << " has type: " << element.first->type() << std::endl;
     const PFGSFElement* elementAsGSF = 
       docast(const PFGSFElement*,element.first);
     if( elementAsGSF->trackType(reco::PFBlockElement::T_FROM_GAMMACONV) ) {
       continue; // for now, do not allow dedicated brems to make proto-objects
     }
     element.second = false;
     
     ProtoEGObject fromGSF;  
     fromGSF.nBremsWithClusters = -1;
     fromGSF.firstBrem = -1;
     fromGSF.lateBrem = 0;
     gsfref_forextra = elementAsGSF->GsftrackRef();
     gsftrk_extra = ( gsfref_forextra.isAvailable() ? 
              gsfref_forextra->extra() : reco::TrackExtraRef() );
     theseedref = ( gsftrk_extra.isAvailable() ?
            gsftrk_extra->seedRef().castTo<reco::ElectronSeedRef>() :
            reco::ElectronSeedRef() );  
     fromGSF.electronSeed = theseedref;
     // exception if there's no seed
     if(fromGSF.electronSeed.isNull() || !fromGSF.electronSeed.isAvailable()) {
       std::stringstream gsf_err;
       elementAsGSF->Dump(gsf_err,"\t");
       throw cms::Exception("PFEGammaAlgo::initializeProtoCands()")
     << "Found a GSF track with no seed! This should not happen!" 
     << std::endl << gsf_err.str() << std::endl;
     }
     // flag this GSF element as globally used and push back the track ref
     // into the protocand
     element.second = false;
     fromGSF.parentBlock = _currentblock;
     fromGSF.primaryGSFs.push_back(std::make_pair(elementAsGSF,true));
     // add the directly matched brem tangents    
     for( auto& brem : _splayedblock[PFBlockElement::BREM] ) {
       float dist = _currentblock->dist(elementAsGSF->index(),
                        brem.first->index(),
                        _currentlinks,
                        reco::PFBlock::LINKTEST_ALL);
       if( dist == 0.001f ) {
     const PFBremElement* eAsBrem = 
       docast(const PFBremElement*,brem.first);
     fromGSF.brems.push_back(std::make_pair(eAsBrem,true));
     fromGSF.localMap.push_back( ElementMap::value_type(eAsBrem,elementAsGSF) );
     fromGSF.localMap.push_back( ElementMap::value_type(elementAsGSF,eAsBrem) );
      brem.second = false;
        }
      }
      // if this track is ECAL seeded reset links or import cluster
      // tracker (this is pixel only, right?) driven seeds just get the GSF
      // track associated since this only branches for ECAL Driven seeds
      if( fromGSF.electronSeed->isEcalDriven() ) {
        // step 2a: either merge with existing ProtoEG object with SC or add 
        //          SC directly to this proto EG object if not present
        LOGDRESSED("PFEGammaAlgo")
      << "GSF-based proto-object is ECAL driven, merging SC-cand"
      << std::endl;
        LOGVERB("PFEGammaAlgo")
      << "ECAL Seed Ptr: " << fromGSF.electronSeed.get() 
      << " isAvailable: " << fromGSF.electronSeed.isAvailable() 
      << " isNonnull: " << fromGSF.electronSeed.isNonnull() 
      << std::endl;           
        SeedMatchesToProtoObject sctoseedmatch(fromGSF.electronSeed);      
        objsbegin = _refinableObjects.begin();
        objsend   = _refinableObjects.end();
        // this auto is a std::list<ProtoEGObject>::iterator
        auto clusmatch = std::find_if(objsbegin,objsend,sctoseedmatch);
        if( clusmatch != objsend ) {
      fromGSF.parentSC = clusmatch->parentSC;
      fromGSF.ecalclusters = std::move(clusmatch->ecalclusters);
      fromGSF.ecal2ps  = std::move(clusmatch->ecal2ps);
      _refinableObjects.erase(clusmatch);    
        } else if (fromGSF.electronSeed.isAvailable()  && 
           fromGSF.electronSeed.isNonnull()) {
      // link tests in the gap region can current split a gap electron
      // HEY THIS IS A WORK AROUND FOR A KNOWN BUG IN PFBLOCKALGO
      // MAYBE WE SHOULD FIX IT??????????????????????????????????
      LOGDRESSED("PFEGammaAlgo")
        << "Encountered the known GSF-SC splitting bug "
        << " in PFBlockAlgo! We should really fix this!" << std::endl; 
        } else { // SC was not in a earlier proto-object 
      std::stringstream gsf_err;
      elementAsGSF->Dump(gsf_err,"\t");
      throw cms::Exception("PFEGammaAlgo::initializeProtoCands()")
        << "Expected SuperCluster from ECAL driven GSF seed "
        << "was not found in the block!" << std::endl 
        << gsf_err.str() << std::endl;
        } // supercluster in block
      } // is ECAL driven seed?   
      /*
      auto ins_pos = std::lower_bound(_refinableObjects.begin(),
                      _refinableObjects.end(),
                      fromGSF,
                      [&](const ProtoEGObject& a,
                      const ProtoEGObject& b){
                        const double a_en = ( a.parentSC ?
                                  a.parentSC->superClusterRef()->energy() :
                                  a.primaryGSFs[0].first->GsftrackRef()->pt() );
                        const double b_en = ( b.parentSC ?
                                  b.parentSC->superClusterRef()->energy() :
                                  b.primaryGSFs[0].first->GsftrackRef()->pt() );
                        return a_en < b_en;
                      });   
      */
      _refinableObjects.insert(_refinableObjects.end(),fromGSF);
    } // end loop on GSF elements of block
 }

bool PFEGammaAlgo::isAMuon ( const reco::PFBlockElement & pfbe )

private

Definition at line 802 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, allElectronIsolations_cfi::elements, reco::PFBlockElement::GSF, reco::PFBlockElement::index(), PFMuonAlgo::isMuon(), reco::PFBlock::LINKTEST_ALL, reco::PFBlockElement::TRACK, and reco::PFBlockElement::type().

Referenced by buildAndRefineEGObjects().

                                                          {
   switch( pfbe.type() ) {
   case reco::PFBlockElement::GSF:    
     {
       auto& elements = _currentblock->elements();
       std::multimap<double,unsigned> tks;
       _currentblock->associatedElements(pfbe.index(),
                     _currentlinks,
                     tks,
                     reco::PFBlockElement::TRACK,
                     reco::PFBlock::LINKTEST_ALL);      
       for( const auto& tk : tks ) {
     if( PFMuonAlgo::isMuon(elements[tk.second]) ) {
       return true;
     }
       }
     }
     break;
   case reco::PFBlockElement::TRACK:
     return PFMuonAlgo::isMuon(pfbe);
     break;
   default:
     break;
   }
   return false;
 }

bool PFEGammaAlgo::isEGValidCandidate	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		const reco::PFBlockRef &	blockRef,
		std::vector< bool > &	active
	)

inline

Definition at line 166 of file PFEGammaAlgo.h.

References egCandidate_, and RunPFEG().

                                                      {
     RunPFEG(hoc,blockRef,active);
     return (!egCandidate_.empty());
   };

bool PFEGammaAlgo::isPrimaryTrack	(	const reco::PFBlockElementTrack &	KfEl,
		const reco::PFBlockElementGsfTrack &	GsfEl
	)

private

Definition at line 2621 of file PFEGammaAlgo.cc.

References reco::PFBlockElementGsfTrack::GsftrackRefPF(), edm::Ref< C, T, F >::isNonnull(), and reco::PFBlockElementTrack::trackRefPF().

Referenced by linkRefinableObjectGSFTracksToKFs().

                                                              {
   bool isPrimary = false;
   
   const GsfPFRecTrackRef& gsfPfRef = GsfEl.GsftrackRefPF();
   
   if(gsfPfRef.isNonnull()) {
     const PFRecTrackRef&  kfPfRef = KfEl.trackRefPF();
     PFRecTrackRef  kfPfRef_fromGsf = (*gsfPfRef).kfPFRecTrackRef();
     if(kfPfRef.isNonnull() && kfPfRef_fromGsf.isNonnull()) {
       reco::TrackRef kfref= (*kfPfRef).trackRef();
       reco::TrackRef kfref_fromGsf = (*kfPfRef_fromGsf).trackRef();
       if(kfref.isNonnull() && kfref_fromGsf.isNonnull()) {
     if(kfref ==  kfref_fromGsf)
       isPrimary = true;
       }
     }
   }
 
   return isPrimary;
 }

void PFEGammaAlgo::linkKFTrackToECAL	(	const PFKFFlaggedElement &	,
		ProtoEGObject &
	)

private

Definition at line 1715 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, attachPSClusters(), docast, reco::PFBlockElement::ECAL, PFEGammaAlgo::ProtoEGObject::ecal2ps, PFEGammaAlgo::ProtoEGObject::ecalclusters, linkRefinableObjectBremTangentsToECAL(), PFEGammaAlgo::ProtoEGObject::localMap, and LOGDRESSED.

Referenced by linkRefinableObjectKFTracksToECAL().

                                    {
   std::vector<PFClusterFlaggedElement>& currentECAL = RO.ecalclusters;
   auto ECALbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
   auto ECALend = _splayedblock[reco::PFBlockElement::ECAL].end();  
   NotCloserToOther<reco::PFBlockElement::TRACK,reco::PFBlockElement::ECAL>
     kfTrackToECALs(_currentblock,_currentlinks,kfflagged.first);      
   NotCloserToOther<reco::PFBlockElement::GSF,reco::PFBlockElement::ECAL>
     kfTrackGSFToECALs(_currentblock,_currentlinks,kfflagged.first);
   //get the ECAL elements not used and not closer to another KF
   auto notmatched_sc = std::partition(currentECAL.begin(),
                       currentECAL.end(),
                       kfTrackToECALs);
   //get subset ECAL elements not used or closer to another GSF of any type
   notmatched_sc = std::partition(currentECAL.begin(),
                  notmatched_sc,
                  kfTrackGSFToECALs);
   for( auto ecalitr = currentECAL.begin(); ecalitr != notmatched_sc; 
        ++ecalitr ) {
     const PFClusterElement* elemascluster = 
       docast(const PFClusterElement*,ecalitr->first);
     PFClusterFlaggedElement flaggedclus(elemascluster,true);
         
     LOGDRESSED("PFEGammaAlgo::linkKFTracktoECAL()") 
     << "Found a cluster already in RO by KF extrapolation"
     << " at ECAL surface!" << std::endl
     << *elemascluster << std::endl;
     RO.localMap.push_back(ElementMap::value_type(elemascluster,
                          kfflagged.first));
     RO.localMap.push_back(ElementMap::value_type(kfflagged.first,
                          elemascluster));
   }
   //get the ECAL elements not used and not closer to another KF
   auto notmatched_blk = std::partition(ECALbegin,ECALend,kfTrackToECALs);
   //get subset ECAL elements not used or closer to another GSF of any type
   notmatched_blk = std::partition(ECALbegin,notmatched_blk,kfTrackGSFToECALs);
   for( auto ecalitr = ECALbegin; ecalitr != notmatched_blk; ++ecalitr ) {
     const PFClusterElement* elemascluster = 
       docast(const PFClusterElement*,ecalitr->first);
     if( addPFClusterToROSafe(elemascluster,RO) ) {
       attachPSClusters(elemascluster,RO.ecal2ps[elemascluster]);      
       ecalitr->second = false;
       
       LOGDRESSED("PFEGammaAlgo::linkKFTracktoECAL()") 
     << "Found a cluster not in RO by KF extrapolation"
     << " at ECAL surface!" << std::endl
     << *elemascluster << std::endl;
       RO.localMap.push_back(ElementMap::value_type(elemascluster,
                            kfflagged.first));
       RO.localMap.push_back( ElementMap::value_type(kfflagged.first,
                             elemascluster));
     }
   }  
 }

void PFEGammaAlgo::linkRefinableObjectBremTangentsToECAL ( ProtoEGObject & RO )

private

Definition at line 1771 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, funct::abs(), attachPSClusters(), PFEGammaAlgo::ProtoEGObject::brems, docast, digitizers_cfi::ecal, reco::PFBlockElement::ECAL, PFEGammaAlgo::ProtoEGObject::ecal2ps, PFEGammaAlgo::ProtoEGObject::ecalclusters, PFEGammaAlgo::ProtoEGObject::firstBrem, linkRefinableObjectConvSecondaryKFsToSecondaryKFs(), PFEGammaAlgo::ProtoEGObject::localMap, LOGDRESSED, and PFEGammaAlgo::ProtoEGObject::nBremsWithClusters.

Referenced by buildAndRefineEGObjects(), and linkKFTrackToECAL().

                                                          {
   if( RO.brems.empty() ) return;
   int FirstBrem = -1;
   int TrajPos = -1;
   int lastBremTrajPos = -1;  
   for( auto& bremflagged : RO.brems ) {
     bool has_clusters = false;
     TrajPos = (bremflagged.first->indTrajPoint())-2;
     auto ECALbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
     auto ECALend = _splayedblock[reco::PFBlockElement::ECAL].end();
     NotCloserToOther<reco::PFBlockElement::BREM,reco::PFBlockElement::ECAL>
       BremToECALs(_currentblock,_currentlinks,bremflagged.first);
     // check for late brem using clusters already in the SC
     auto RSCBegin = RO.ecalclusters.begin();
     auto RSCEnd = RO.ecalclusters.end();
     auto notmatched_rsc = std::partition(RSCBegin,RSCEnd,BremToECALs);
     for( auto ecal = RSCBegin; ecal != notmatched_rsc; ++ecal ) {
       float deta = 
     std::abs( ecal->first->clusterRef()->positionREP().eta() -
           bremflagged.first->positionAtECALEntrance().eta() );
       if( deta < 0.015 ) {
     has_clusters = true;
     if( lastBremTrajPos == -1 || lastBremTrajPos < TrajPos ) {
       lastBremTrajPos = TrajPos;      
     }
     if( FirstBrem == -1 || TrajPos < FirstBrem ) { // set brem information
       FirstBrem = TrajPos;
       RO.firstBrem = TrajPos;
     }   
     LOGDRESSED("PFEGammaAlgo::linkBremToECAL()") 
       << "Found a cluster already in SC linked to brem extrapolation"
       << " at ECAL surface!" << std::endl;
     RO.localMap.push_back( ElementMap::value_type(ecal->first,bremflagged.first) );
     RO.localMap.push_back( ElementMap::value_type(bremflagged.first,ecal->first) );
       }
     }
     // grab new clusters from the block (ensured to not be late brem)
     auto notmatched_block = std::partition(ECALbegin,ECALend,BremToECALs);   
     for( auto ecal = ECALbegin; ecal != notmatched_block; ++ecal ) {
       float deta = 
     std::abs( ecal->first->clusterRef()->positionREP().eta() -
           bremflagged.first->positionAtECALEntrance().eta() );
       if( deta < 0.015 ) {  
     has_clusters = true;
     if( lastBremTrajPos == -1 || lastBremTrajPos < TrajPos ) {
       lastBremTrajPos = TrajPos;      
     }
     if( FirstBrem == -1 || TrajPos < FirstBrem ) { // set brem information
       
       FirstBrem = TrajPos;
       RO.firstBrem = TrajPos;
     }   
     const PFClusterElement* elemasclus =
       docast(const PFClusterElement*,ecal->first);    
     if( addPFClusterToROSafe(elemasclus,RO) ) {
       attachPSClusters(elemasclus,RO.ecal2ps[elemasclus]);
       
       RO.localMap.push_back( ElementMap::value_type(ecal->first,bremflagged.first) );
       RO.localMap.push_back( ElementMap::value_type(bremflagged.first,ecal->first) );
       ecal->second = false;
       LOGDRESSED("PFEGammaAlgo::linkBremToECAL()") 
         << "Found a cluster not already associated by brem extrapolation"
         << " at ECAL surface!" << std::endl;
     }
     
       }
     }
     if(has_clusters) {
       if( RO.nBremsWithClusters == -1 ) RO.nBremsWithClusters = 0;
       ++RO.nBremsWithClusters;
     }
   }  
 }

void PFEGammaAlgo::linkRefinableObjectConvSecondaryKFsToSecondaryKFs ( ProtoEGObject & RO )

private

Definition at line 1846 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, SoftLeptonByDistance_cfi::distance, docast, plotBeamSpotDB::first, training_settings::idx, linkRefinableObjectECALToSingleLegConv(), PFEGammaAlgo::ProtoEGObject::localMap, PFEGammaAlgo::ProtoEGObject::secondaryKFs, and reco::PFBlockElement::TRACK.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectBremTangentsToECAL().

                                                                      {
   IsConversionTrack<reco::PFBlockElementTrack> isConvKf; 
   auto KFbegin = _splayedblock[reco::PFBlockElement::TRACK].begin();
   auto KFend   = _splayedblock[reco::PFBlockElement::TRACK].end();
   auto BeginROskfs = RO.secondaryKFs.begin();
   auto EndROskfs   = RO.secondaryKFs.end();  
   auto ronotconv = std::partition(BeginROskfs,EndROskfs,isConvKf); 
   size_t convkfs_end = std::distance(BeginROskfs,ronotconv);  
   for( size_t idx = 0; idx < convkfs_end; ++idx ) { 
     const std::vector<PFKFFlaggedElement>& secKFs = RO.secondaryKFs; //we want the entry at the index but we allocate to secondaryKFs in loop which invalidates all iterators, references and pointers, hence we need to get the entry fresh each time
     NotCloserToOther<reco::PFBlockElement::TRACK,
                      reco::PFBlockElement::TRACK,
                      true> 
       TracksToTracks(_currentblock,_currentlinks, secKFs[idx].first); 
     auto notmatched = std::partition(KFbegin,KFend,TracksToTracks);    
     notmatched = std::partition(KFbegin,notmatched,isConvKf);    
     for( auto kf = KFbegin; kf != notmatched; ++kf ) {
       const reco::PFBlockElementTrack* elemaskf =
     docast(const reco::PFBlockElementTrack*,kf->first);      
       RO.secondaryKFs.push_back( std::make_pair(elemaskf,true) );
       RO.localMap.push_back( ElementMap::value_type(secKFs[idx].first,kf->first) );
       RO.localMap.push_back( ElementMap::value_type(kf->first,secKFs[idx].first) );
       kf->second = false;      
     }    
   }
 }

void PFEGammaAlgo::linkRefinableObjectECALToSingleLegConv	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		ProtoEGObject &	RO
	)

private

Definition at line 1874 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, cfg_, docast, digitizers_cfi::ecal, reco::PFBlockElement::ECAL, PFEGammaAlgo::ProtoEGObject::ecalclusters, EvaluateSingleLegMVA(), linkRefinableObjectSecondaryKFsToECAL(), PFEGammaAlgo::ProtoEGObject::localMap, PFEGammaAlgo::PFEGConfigInfo::mvaConvCut, PFEGammaAlgo::PFEGConfigInfo::primaryVtx, PFEGammaAlgo::ProtoEGObject::secondaryKFs, PFEGammaAlgo::ProtoEGObject::singleLegConversionMvaMap, and reco::PFBlockElement::TRACK.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectConvSecondaryKFsToSecondaryKFs().

                                                           { 
   IsConversionTrack<reco::PFBlockElementTrack> isConvKf;
   auto KFbegin = _splayedblock[reco::PFBlockElement::TRACK].begin();
   auto KFend = _splayedblock[reco::PFBlockElement::TRACK].end();  
   for( auto& ecal : RO.ecalclusters ) {
     NotCloserToOther<reco::PFBlockElement::ECAL,
                      reco::PFBlockElement::TRACK,
                      true>
       ECALToTracks(_currentblock,_currentlinks,ecal.first);           
     auto notmatchedkf  = std::partition(KFbegin,KFend,ECALToTracks);
     auto notconvkf     = std::partition(KFbegin,notmatchedkf,isConvKf);    
     // add identified KF conversion tracks
     for( auto kf = KFbegin; kf != notconvkf; ++kf ) {
       const reco::PFBlockElementTrack* elemaskf =
     docast(const reco::PFBlockElementTrack*,kf->first);
       RO.secondaryKFs.push_back( std::make_pair(elemaskf,true) );
       RO.localMap.push_back( ElementMap::value_type(ecal.first,elemaskf) );
       RO.localMap.push_back( ElementMap::value_type(elemaskf,ecal.first) );
       kf->second = false;
     }
     // go through non-conv-identified kfs and check MVA to add conversions
     for( auto kf = notconvkf; kf != notmatchedkf; ++kf ) {
       float mvaval = EvaluateSingleLegMVA(hoc,_currentblock, 
                                           *cfg_.primaryVtx, 
                                           kf->first->index());
       if(mvaval > cfg_.mvaConvCut) {
     const reco::PFBlockElementTrack* elemaskf =
       docast(const reco::PFBlockElementTrack*,kf->first);
     RO.secondaryKFs.push_back( std::make_pair(elemaskf,true) );
     RO.localMap.push_back( ElementMap::value_type(ecal.first,elemaskf) );
     RO.localMap.push_back( ElementMap::value_type(elemaskf,ecal.first) );
     kf->second = false;
         
         RO.singleLegConversionMvaMap.insert(std::make_pair(elemaskf, mvaval));
       }
     }    
   }
 }

void PFEGammaAlgo::linkRefinableObjectGSFTracksToKFs ( ProtoEGObject & RO )

private

Definition at line 1555 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, constexpr, docast, PFEGammaAlgo::ProtoEGObject::electronSeed, relativeConstraints::empty, edm::Ref< C, T, F >::isNull(), isPrimaryTrack(), linkRefinableObjectPrimaryKFsToSecondaryKFs(), PFEGammaAlgo::ProtoEGObject::localMap, PFEGammaAlgo::ProtoEGObject::primaryGSFs, PFEGammaAlgo::ProtoEGObject::primaryKFs, PFEGammaAlgo::ProtoEGObject::secondaryKFs, reco::PFBlockElement::T_FROM_GAMMACONV, reco::PFBlockElement::TRACK, reco::PFBlockElementTrack::trackType(), and reco::PFBlockElementGsfTrack::trackType().

Referenced by buildAndRefineEGObjects(), and mergeROsByAnyLink().

                                                      {
   constexpr reco::PFBlockElement::TrackType convType = 
     reco::PFBlockElement::T_FROM_GAMMACONV;
   if( _splayedblock[reco::PFBlockElement::TRACK].empty() ) return;
   auto KFbegin = _splayedblock[reco::PFBlockElement::TRACK].begin();
   auto KFend = _splayedblock[reco::PFBlockElement::TRACK].end();
   for( auto& gsfflagged : RO.primaryGSFs ) {
     const PFGSFElement* seedtk = gsfflagged.first;
     // don't process SC-only ROs or secondary seeded ROs
     if( RO.electronSeed.isNull() || seedtk->trackType(convType) ) continue;
     NotCloserToOther<reco::PFBlockElement::GSF,reco::PFBlockElement::TRACK>
       gsfTrackToKFs(_currentblock,_currentlinks,seedtk);
     // get KF tracks not closer to another and not already used
     auto notlinked = std::partition(KFbegin,KFend,gsfTrackToKFs);
     // attach tracks and set as used
     for( auto kft = KFbegin; kft != notlinked; ++kft ) {
       const PFKFElement* elemaskf = 
     docast(const PFKFElement*,kft->first);
       // don't care about things that aren't primaries or directly 
       // associated secondary tracks
       if( isPrimaryTrack(*elemaskf,*seedtk) &&
       !elemaskf->trackType(convType)       ) {
     kft->second = false;
     RO.primaryKFs.push_back(std::make_pair(elemaskf,true));
     RO.localMap.push_back( ElementMap::value_type(seedtk,elemaskf) );
     RO.localMap.push_back( ElementMap::value_type(elemaskf,seedtk) );
       } else if ( elemaskf->trackType(convType) ) {
     kft->second = false;
     RO.secondaryKFs.push_back(std::make_pair(elemaskf,true));
     RO.localMap.push_back( ElementMap::value_type(seedtk,elemaskf) );
     RO.localMap.push_back( ElementMap::value_type(elemaskf,seedtk) );
       }
     }// loop on closest KFs not closer to other GSFs
   } // loop on GSF primaries on RO  
 }

void PFEGammaAlgo::linkRefinableObjectKFTracksToECAL ( ProtoEGObject & RO )

private

Definition at line 1708 of file PFEGammaAlgo.cc.

References _splayedblock, reco::PFBlockElement::ECAL, relativeConstraints::empty, linkKFTrackToECAL(), PFEGammaAlgo::ProtoEGObject::primaryKFs, and PFEGammaAlgo::ProtoEGObject::secondaryKFs.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectPrimaryGSFTrackToHCAL().

                                                      {
   if( _splayedblock[reco::PFBlockElement::ECAL].empty() ) return;  
   for( auto& primkf : RO.primaryKFs ) linkKFTrackToECAL(primkf,RO);
   for( auto& secdkf : RO.secondaryKFs ) linkKFTrackToECAL(secdkf,RO);
 }

void PFEGammaAlgo::linkRefinableObjectPrimaryGSFTrackToECAL ( ProtoEGObject & RO )

private

Definition at line 1628 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, attachPSClusters(), docast, digitizers_cfi::ecal, reco::PFBlockElement::ECAL, PFEGammaAlgo::ProtoEGObject::ecal2ps, PFEGammaAlgo::ProtoEGObject::ecalclusters, PFEGammaAlgo::ProtoEGObject::electronClusters, relativeConstraints::empty, linkRefinableObjectPrimaryGSFTrackToHCAL(), PFEGammaAlgo::ProtoEGObject::localMap, LOGDRESSED, PFEGammaAlgo::ProtoEGObject::primaryGSFs, and groupFilesInBlocks::temp.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectPrimaryKFsToSecondaryKFs().

                                                             {
   if( _splayedblock[reco::PFBlockElement::ECAL].empty() ) {
     RO.electronClusters.push_back(nullptr);
     return; 
   }
   auto ECALbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
   auto ECALend = _splayedblock[reco::PFBlockElement::ECAL].end();
   for( auto& primgsf : RO.primaryGSFs ) {    
     NotCloserToOther<reco::PFBlockElement::GSF,reco::PFBlockElement::ECAL>
       gsfTracksToECALs(_currentblock,_currentlinks,primgsf.first);
     CompatibleEoPOut eoverp_test(primgsf.first);
     // get set of matching ecals not already in SC
     auto notmatched_blk = std::partition(ECALbegin,ECALend,gsfTracksToECALs);
     notmatched_blk = std::partition(ECALbegin,notmatched_blk,eoverp_test);
     // get set of matching ecals already in the RO
     auto notmatched_sc = std::partition(RO.ecalclusters.begin(),
                     RO.ecalclusters.end(),
                     gsfTracksToECALs);
     notmatched_sc = std::partition(RO.ecalclusters.begin(),
                    notmatched_sc,
                    eoverp_test);
     // look inside the SC for the ECAL cluster
     for( auto ecal = RO.ecalclusters.begin(); ecal != notmatched_sc; ++ecal ) {
       const PFClusterElement* elemascluster = 
     docast(const PFClusterElement*,ecal->first);    
       PFClusterFlaggedElement temp(elemascluster,true);
       LOGDRESSED("PFEGammaAlgo::linkGSFTracktoECAL()") 
     << "Found a cluster already in RO by GSF extrapolation"
     << " at ECAL surface!" << std::endl
     << *elemascluster << std::endl;
             
       RO.localMap.push_back(ElementMap::value_type(primgsf.first,temp.first));
       RO.localMap.push_back(ElementMap::value_type(temp.first,primgsf.first));
     }
     // look outside the SC for the ecal cluster
     for( auto ecal = ECALbegin; ecal != notmatched_blk; ++ecal ) {
       const PFClusterElement* elemascluster = 
     docast(const PFClusterElement*,ecal->first);    
       LOGDRESSED("PFEGammaAlgo::linkGSFTracktoECAL()") 
     << "Found a cluster not already in RO by GSF extrapolation"
     << " at ECAL surface!" << std::endl
     << *elemascluster << std::endl;
       if( addPFClusterToROSafe(elemascluster,RO) ) {
     attachPSClusters(elemascluster,RO.ecal2ps[elemascluster]);      
     RO.localMap.push_back(ElementMap::value_type(primgsf.first,elemascluster));
     RO.localMap.push_back(ElementMap::value_type(elemascluster,primgsf.first));
     ecal->second = false;    
       }
     }    
   }
 }

void PFEGammaAlgo::linkRefinableObjectPrimaryGSFTrackToHCAL ( ProtoEGObject & RO )

private

Definition at line 1682 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, docast, relativeConstraints::empty, digitizers_cfi::hcal, reco::PFBlockElement::HCAL, PFEGammaAlgo::ProtoEGObject::hcalClusters, linkRefinableObjectKFTracksToECAL(), PFEGammaAlgo::ProtoEGObject::localMap, LOGDRESSED, PFEGammaAlgo::ProtoEGObject::primaryGSFs, and groupFilesInBlocks::temp.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectPrimaryGSFTrackToECAL().

                                                             {
   if( _splayedblock[reco::PFBlockElement::HCAL].empty() ) return; 
   auto HCALbegin = _splayedblock[reco::PFBlockElement::HCAL].begin();
   auto HCALend = _splayedblock[reco::PFBlockElement::HCAL].end();
   for( auto& primgsf : RO.primaryGSFs ) {
     NotCloserToOther<reco::PFBlockElement::GSF,reco::PFBlockElement::HCAL>
       gsfTracksToHCALs(_currentblock,_currentlinks,primgsf.first);
     CompatibleEoPOut eoverp_test(primgsf.first);
     auto notmatched = std::partition(HCALbegin,HCALend,gsfTracksToHCALs);    
     for( auto hcal = HCALbegin; hcal != notmatched; ++hcal ) { 
       const PFClusterElement* elemascluster = 
     docast(const PFClusterElement*,hcal->first);    
       PFClusterFlaggedElement temp(elemascluster,true);    
       LOGDRESSED("PFEGammaAlgo::linkGSFTracktoECAL()") 
     << "Found an HCAL cluster associated to GSF extrapolation" 
     << std::endl;
       RO.hcalClusters.push_back(temp);
       RO.localMap.push_back( ElementMap::value_type(primgsf.first,temp.first) );
       RO.localMap.push_back( ElementMap::value_type(temp.first,primgsf.first) );
       hcal->second = false;
     }
   }
 }

void PFEGammaAlgo::linkRefinableObjectPrimaryKFsToSecondaryKFs ( ProtoEGObject & RO )

private

Definition at line 1592 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, constexpr, docast, relativeConstraints::empty, Exception, linkRefinableObjectPrimaryGSFTrackToECAL(), PFEGammaAlgo::ProtoEGObject::localMap, PFEGammaAlgo::ProtoEGObject::primaryKFs, PFEGammaAlgo::ProtoEGObject::secondaryKFs, reco::PFBlockElement::T_FROM_GAMMACONV, reco::PFBlockElement::TRACK, and reco::PFBlockElementTrack::trackType().

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectGSFTracksToKFs().

                                                                {
   constexpr reco::PFBlockElement::TrackType convType = 
     reco::PFBlockElement::T_FROM_GAMMACONV;
   if( _splayedblock[reco::PFBlockElement::TRACK].empty() ) return;
   auto KFbegin = _splayedblock[reco::PFBlockElement::TRACK].begin();
   auto KFend = _splayedblock[reco::PFBlockElement::TRACK].end();
   for( auto& kfflagged : RO.primaryKFs ) {
     const PFKFElement* primkf = kfflagged.first;
     // don't process SC-only ROs or secondary seeded ROs
     if( primkf->trackType(convType) ) {
       throw cms::Exception("PFEGammaAlgo::linkRefinableObjectPrimaryKFsToSecondaryKFs()")
     << "A KF track from conversion has been assigned as a primary!!"
     << std::endl;
     }
     NotCloserToOther<reco::PFBlockElement::TRACK,reco::PFBlockElement::TRACK,true>
     kfTrackToKFs(_currentblock,_currentlinks,primkf);
     // get KF tracks not closer to another and not already used
     auto notlinked = std::partition(KFbegin,KFend,kfTrackToKFs);
     // attach tracks and set as used
     for( auto kft = KFbegin; kft != notlinked; ++kft ) {
       const PFKFElement* elemaskf = 
     docast(const PFKFElement*,kft->first);
       // don't care about things that aren't primaries or directly 
       // associated secondary tracks
       if( elemaskf->trackType(convType) ) {
     kft->second = false;
     RO.secondaryKFs.push_back(std::make_pair(elemaskf,true));
     RO.localMap.push_back( ElementMap::value_type(primkf,elemaskf) );
     RO.localMap.push_back( ElementMap::value_type(elemaskf,primkf) );
       } 
     }// loop on closest KFs not closer to other KFs
   } // loop on KF primaries on RO
 }

void PFEGammaAlgo::linkRefinableObjectSecondaryKFsToECAL ( ProtoEGObject & RO )

private

Definition at line 1915 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, attachPSClusters(), docast, digitizers_cfi::ecal, reco::PFBlockElement::ECAL, PFEGammaAlgo::ProtoEGObject::ecal2ps, fillPFCandidates(), PFEGammaAlgo::ProtoEGObject::localMap, PFEGammaAlgo::ProtoEGObject::secondaryKFs, and reco::PFBlockElement::TRACK.

Referenced by buildAndRefineEGObjects(), and linkRefinableObjectECALToSingleLegConv().

                                                          {
   auto ECALbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
   auto ECALend = _splayedblock[reco::PFBlockElement::ECAL].end(); 
   for( auto& skf : RO.secondaryKFs ) {
     NotCloserToOther<reco::PFBlockElement::TRACK,
                      reco::PFBlockElement::ECAL,
                      false>
       TracksToECALwithCut(_currentblock,_currentlinks,skf.first,1.5f);
     auto notmatched = std::partition(ECALbegin,ECALend,TracksToECALwithCut);
     for( auto ecal = ECALbegin; ecal != notmatched; ++ecal ) {
       const reco::PFBlockElementCluster* elemascluster =
     docast(const reco::PFBlockElementCluster*,ecal->first);      
       if( addPFClusterToROSafe(elemascluster,RO) ) {
     attachPSClusters(elemascluster,RO.ecal2ps[elemascluster]);
     RO.localMap.push_back(ElementMap::value_type(skf.first,elemascluster));
     RO.localMap.push_back(ElementMap::value_type(elemascluster,skf.first));
     ecal->second = false;      
       }
     }
   }
 }

void PFEGammaAlgo::mergeROsByAnyLink ( std::list< ProtoEGObject > & )

private

Definition at line 1460 of file PFEGammaAlgo.cc.

Referenced by buildAndRefineEGObjects(), and removeOrLinkECALClustersToKFTracks().

                                                             {
    if( ROs.size() < 2 ) return; // nothing to do with one or zero ROs  
    bool check_for_merge = true;
    while( check_for_merge ) {   
      // bugfix for early termination merging loop (15 April 2014)
      // check all pairwise combinations in the list
      // if one has a merge shuffle it to the front of the list
      // if there are no merges left to do we can terminate
      for( auto it1 = ROs.begin(); it1 != ROs.end(); ++it1 ) {
        TestIfROMergableByLink mergeTest(*it1);
        auto find_start = it1; ++find_start;
        auto has_merge = std::find_if(find_start,ROs.end(),mergeTest);
        if( has_merge != ROs.end() && it1 != ROs.begin() ) {
      std::swap(*(ROs.begin()),*it1);
      break;
        }
      }// ensure mergables are shuffled to the front
      ProtoEGObject& thefront = ROs.front();
      TestIfROMergableByLink mergeTest(thefront);
      auto mergestart = ROs.begin(); ++mergestart;    
      auto nomerge = std::partition(mergestart,ROs.end(),mergeTest);
      if( nomerge != mergestart ) {
        LOGDRESSED("PFEGammaAlgo::mergeROsByAnyLink()")       
      << "Found objects " << std::distance(mergestart,nomerge)
      << " to merge by links to the front!" << std::endl;
        for( auto roToMerge = mergestart; roToMerge != nomerge; ++roToMerge) {
          //bugfix! L.Gray 14 Jan 2016 
          // -- check that the front is still mergeable!
          if( !thefront.ecalclusters.empty() && !roToMerge->ecalclusters.empty() ) {
            if( thefront.ecalclusters.front().first->clusterRef()->layer() !=   
                roToMerge->ecalclusters.front().first->clusterRef()->layer() ) {
              LOGWARN("PFEGammaAlgo::mergeROsByAnyLink") 
                << "Tried to merge EB and EE clusters! Skipping!";
              ROs.push_back(*roToMerge);
              continue;
            }
          }         
          //end bugfix
      thefront.ecalclusters.insert(thefront.ecalclusters.end(),
                       roToMerge->ecalclusters.begin(),
                       roToMerge->ecalclusters.end());
      thefront.ecal2ps.insert(roToMerge->ecal2ps.begin(),
                  roToMerge->ecal2ps.end());
      thefront.secondaryKFs.insert(thefront.secondaryKFs.end(),
                       roToMerge->secondaryKFs.begin(),
                       roToMerge->secondaryKFs.end());
 
      thefront.localMap.insert(thefront.localMap.end(),
                   roToMerge->localMap.begin(),
                   roToMerge->localMap.end());
      // TO FIX -> use best (E_gsf - E_clustersum)/E_GSF
      if( !thefront.parentSC && roToMerge->parentSC ) {
        thefront.parentSC = roToMerge->parentSC;
      }
      if( thefront.electronSeed.isNull() && 
          roToMerge->electronSeed.isNonnull() ) {
        thefront.electronSeed = roToMerge->electronSeed;
        thefront.primaryGSFs.insert(thefront.primaryGSFs.end(),
                        roToMerge->primaryGSFs.begin(),
                        roToMerge->primaryGSFs.end());
        thefront.primaryKFs.insert(thefront.primaryKFs.end(),
                       roToMerge->primaryKFs.begin(),
                       roToMerge->primaryKFs.end());
        thefront.brems.insert(thefront.brems.end(),
                  roToMerge->brems.begin(),
                  roToMerge->brems.end());
        thefront.electronClusters = roToMerge->electronClusters;
        thefront.nBremsWithClusters = roToMerge->nBremsWithClusters;
        thefront.firstBrem = roToMerge->firstBrem;
        thefront.lateBrem = roToMerge->lateBrem;
      } else if ( thefront.electronSeed.isNonnull() && 
              roToMerge->electronSeed.isNonnull()) {
        LOGDRESSED("PFEGammaAlgo::mergeROsByAnyLink")
          << "Need to implement proper merging of two gsf candidates!"
          << std::endl;
      }
        }      
        ROs.erase(mergestart,nomerge);
        // put the merged element in the back of the cleaned list
        ROs.push_back(ROs.front());
        ROs.pop_front();
      } else {       
        check_for_merge = false;    
      }
    }
    LOGDRESSED("PFEGammaAlgo::mergeROsByAnyLink()") 
      << "After merging by links there are: " << ROs.size() 
      << " refinable EGamma objects!" << std::endl;
  }

void PFEGammaAlgo::removeOrLinkECALClustersToKFTracks ( )

private

Definition at line 1365 of file PFEGammaAlgo.cc.

Referenced by buildAndRefineEGObjects(), and dumpCurrentRefinableObjects().

                                       {
    typedef std::multimap<double, unsigned> MatchedMap;
    typedef const reco::PFBlockElementGsfTrack* GsfTrackElementPtr;
    if( _splayedblock[reco::PFBlockElement::ECAL].empty() ||
        _splayedblock[reco::PFBlockElement::TRACK].empty()   ) return;
    MatchedMap matchedGSFs, matchedECALs;
    std::unordered_map<GsfTrackElementPtr,MatchedMap> gsf_ecal_cache;
    for( auto& kftrack : _splayedblock[reco::PFBlockElement::TRACK] ) {
      matchedGSFs.clear();
      _currentblock->associatedElements(kftrack.first->index(), _currentlinks,
                        matchedGSFs,
                        reco::PFBlockElement::GSF,
                        reco::PFBlock::LINKTEST_ALL);
      if( matchedGSFs.empty() ) { // only run this if we aren't associated to GSF
        LesserByDistance closestTrackToECAL(_currentblock,_currentlinks,
                        &kftrack);      
        auto ecalbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
        auto ecalend   = _splayedblock[reco::PFBlockElement::ECAL].end();
        std::partial_sort(ecalbegin,ecalbegin+1,ecalend,closestTrackToECAL);
        PFFlaggedElement& closestECAL = 
      _splayedblock[reco::PFBlockElement::ECAL].front();
        const float dist = _currentblock->dist(kftrack.first->index(), 
                           closestECAL.first->index(),
                           _currentlinks,
                           reco::PFBlock::LINKTEST_ALL);
        bool inSC = false;
        for( auto& sc : _splayedblock[reco::PFBlockElement::SC] ) {
      float dist_sc = _currentblock->dist(sc.first->index(), 
                          closestECAL.first->index(),
                          _currentlinks,
                          reco::PFBlock::LINKTEST_ALL);
      if( dist_sc != -1.0f) { inSC = true; break; }
        }
 
        if( dist != -1.0f && closestECAL.second ) {
      bool gsflinked = false;
      // check that this cluster is not associated to a GSF track
      for(const auto& gsfflag : _splayedblock[reco::PFBlockElement::GSF]) {
        const reco::PFBlockElementGsfTrack* elemasgsf =
          docast(const reco::PFBlockElementGsfTrack*,gsfflag.first);
        if(elemasgsf->trackType(reco::PFBlockElement::T_FROM_GAMMACONV)) {
          continue; // keep clusters that have a found conversion GSF near
        }
        // make sure cache exists
        if( !gsf_ecal_cache.count(elemasgsf) ) {
          matchedECALs.clear();
          _currentblock->associatedElements(elemasgsf->index(), _currentlinks,
                            matchedECALs,
                            reco::PFBlockElement::ECAL,
                            reco::PFBlock::LINKTEST_ALL);
          gsf_ecal_cache.emplace(elemasgsf,matchedECALs);
          MatchedMap().swap(matchedECALs);
        } 
        const MatchedMap& ecal_matches = gsf_ecal_cache[elemasgsf];     
        if( !ecal_matches.empty() ) {
          if( ecal_matches.begin()->second == closestECAL.first->index() ) {
            gsflinked = true;
            break;
          }
        }                
      } // loop over primary GSF tracks
      if( !gsflinked && !inSC) { 
        // determine if we should remove the matched cluster
        const reco::PFBlockElementTrack * kfEle = 
          docast(const reco::PFBlockElementTrack*,kftrack.first);
        const reco::TrackRef& trackref = kfEle->trackRef();
 
        const int nexhits = 
          trackref->hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS);
        bool fromprimaryvertex = false;
        for( auto vtxtks = cfg_.primaryVtx->tracks_begin();
         vtxtks != cfg_.primaryVtx->tracks_end(); ++ vtxtks ) {
          if( trackref == vtxtks->castTo<reco::TrackRef>() ) {
            fromprimaryvertex = true;
            break;
          }
        }// loop over tracks in primary vertex
         // if associated to good non-GSF matched track remove this cluster
        if( PFTrackAlgoTools::isGoodForEGMPrimary(trackref->algo()) && nexhits == 0 && fromprimaryvertex ) {
          closestECAL.second = false;
        } else { // otherwise associate the cluster and KF track
          _recoveredlinks.push_back( ElementMap::value_type(closestECAL.first,kftrack.first) );
          _recoveredlinks.push_back( ElementMap::value_type(kftrack.first,closestECAL.first) );
        }
 
 
 
 
      }
        } // found a good closest ECAL match
      } // no GSF track matched to KF
    } // loop over KF elements
  }

void PFEGammaAlgo::RunPFEG	(	const pfEGHelpers::HeavyObjectCache *	hoc,
		const reco::PFBlockRef &	blockRef,
		std::vector< bool > &	active
	)

Definition at line 728 of file PFEGammaAlgo.cc.

References buildAndRefineEGObjects(), Chatty, convGsfTrack_, egCandidate_, egExtra_, EvaluateSingleLegMVA(), fifthStepKfTrack_, and verbosityLevel_.

Referenced by isEGValidCandidate(), and setPhotonPrimaryVtx().

                                                     {  
 
   fifthStepKfTrack_.clear();
   convGsfTrack_.clear();
   
   egCandidate_.clear();
   egExtra_.clear();
  
   // define how much is printed out for debugging.
   // ... will be setable via CFG file parameter
   verbosityLevel_ = Chatty;          // Chatty mode.
   
   buildAndRefineEGObjects(hoc, blockRef);
 }

void PFEGammaAlgo::setAlphaGamma_ESplanes_fromDB ( const ESEEIntercalibConstants * esEEInterCalib )

inline

Definition at line 145 of file PFEGammaAlgo.h.

References cfg_, and PFEGammaAlgo::PFEGConfigInfo::thePFEnergyCalibration.

                                                                                    {
     cfg_.thePFEnergyCalibration->initAlphaGamma_ESplanes_fromDB(esEEInterCalib);
   }

void PFEGammaAlgo::setEEtoPSAssociation ( const edm::Handle< EEtoPSAssociation > & eetops )

inline

Definition at line 141 of file PFEGammaAlgo.h.

References eetops_.

                                                                         {
     eetops_ = eetops;
   }

void PFEGammaAlgo::setESChannelStatus ( const ESChannelStatus * channelStatus )

inline

Definition at line 149 of file PFEGammaAlgo.h.

References channelStatus_.

                                                                {
     channelStatus_ = channelStatus;
   }

void PFEGammaAlgo::setnPU ( int nVtx )

inline

Definition at line 153 of file PFEGammaAlgo.h.

References nVtx_.

                        {
     nVtx_=nVtx;
   }

void PFEGammaAlgo::setPhotonPrimaryVtx ( const reco::Vertex & primary )

inline

Definition at line 156 of file PFEGammaAlgo.h.

References cfg_, PFEGammaAlgo::PFEGConfigInfo::primaryVtx, and RunPFEG().

                                                      {
     cfg_.primaryVtx = & primary;
   }

void PFEGammaAlgo::unlinkRefinableObjectKFandECALMatchedToHCAL	(	ProtoEGObject &	RO,
		bool	removeFreeECAL = `false`,
		bool	removeSCECAL = `false`
	)

private

Definition at line 2529 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, reco::PFBlockElementCluster::clusterRef(), SoftLeptonByDistance_cfi::distance, digitizers_cfi::ecal, PFEGammaAlgo::ProtoEGObject::ecalclusters, f, spr::find(), spr::goodTrack(), reco::PFBlockElement::HCAL, PFTrackAlgoTools::isGoodForEGM(), reco::PFBlock::LINKTEST_ALL, PFEGammaAlgo::ProtoEGObject::localMap, LOGDRESSED, PFEGammaAlgo::ProtoEGObject::parentSC, and PFEGammaAlgo::ProtoEGObject::secondaryKFs.

Referenced by buildAndRefineEGObjects(), and unlinkRefinableObjectKFandECALWithBadEoverP().

                                            {
   std::vector<bool> cluster_in_sc;    
   auto ecal_begin = RO.ecalclusters.begin();
   auto ecal_end   = RO.ecalclusters.end();
   auto hcal_begin = _splayedblock[reco::PFBlockElement::HCAL].begin();
   auto hcal_end   = _splayedblock[reco::PFBlockElement::HCAL].end();
   for( auto secd_kf = RO.secondaryKFs.begin(); 
        secd_kf != RO.secondaryKFs.end(); ++secd_kf ) {
     bool remove_this_kf = false;
     NotCloserToOther<reco::PFBlockElement::TRACK,reco::PFBlockElement::HCAL>
       tracksToHCALs(_currentblock,_currentlinks,secd_kf->first);
     reco::TrackRef trkRef =   secd_kf->first->trackRef();
 
     bool goodTrack = PFTrackAlgoTools::isGoodForEGM(trkRef->algo());
     const float secpin = trkRef->p();       
     
     for( auto ecal = ecal_begin; ecal != ecal_end; ++ecal ) {
       const double ecalenergy = ecal->first->clusterRef()->correctedEnergy();
       // first check if the cluster is in the SC (use dist calc for fastness)
       const size_t clus_idx = std::distance(ecal_begin,ecal);
       if( cluster_in_sc.size() < clus_idx + 1) {
     float dist = -1.0f;
     if( RO.parentSC ) {
       dist = _currentblock->dist(secd_kf->first->index(),
                      ecal->first->index(),
                      _currentlinks,
                      reco::PFBlock::LINKTEST_ALL);
     } 
     cluster_in_sc.push_back(dist != -1.0f); 
       }
 
       ElementMap::value_type check_match(ecal->first,secd_kf->first);
       auto kf_matched = std::find(RO.localMap.begin(),
                   RO.localMap.end(),
                   check_match);
       // if we've found a secondary KF that matches this ecal cluster
       // now we see if it is matched to HCAL 
       // if it is matched to an HCAL cluster we take different 
       // actions if the cluster was in an SC or not
       if( kf_matched != RO.localMap.end() ) {
     auto hcal_matched = std::partition(hcal_begin,hcal_end,tracksToHCALs);
     for( auto hcalclus = hcal_begin; 
          hcalclus != hcal_matched; 
          ++hcalclus                 ) {
       const reco::PFBlockElementCluster * clusthcal =  
         dynamic_cast<const reco::PFBlockElementCluster*>(hcalclus->first); 
       const double hcalenergy = clusthcal->clusterRef()->energy();    
       const double hpluse = ecalenergy+hcalenergy;
       const bool isHoHE = ( (hcalenergy / hpluse ) > 0.1 && goodTrack );
       const bool isHoE  = ( hcalenergy > ecalenergy );
       const bool isPoHE = ( secpin > hpluse );  
       if( cluster_in_sc[clus_idx] ) {
         if(isHoE || isPoHE) {
           LOGDRESSED("PFEGammaAlgo")
         << "REJECTED TRACK FOR H/E or P/(H+E), CLUSTER IN SC"
         << " H/H+E " << (hcalenergy / hpluse)
         << " H/E " << (hcalenergy > ecalenergy)
         << " P/(H+E) " << (secpin/hpluse)
         << " HCAL ENE " << hcalenergy
         << " ECAL ENE " << ecalenergy
         << " secPIN " << secpin 
         << " Algo Track " << trkRef->algo() << std::endl;
           remove_this_kf = true;
         }
       } else {
         if(isHoHE){
           LOGDRESSED("PFEGammaAlgo")
         << "REJECTED TRACK FOR H/H+E, CLUSTER NOT IN SC"
         << " H/H+E " << (hcalenergy / hpluse)
         << " H/E " << (hcalenergy > ecalenergy)
         << " P/(H+E) " << (secpin/hpluse) 
         << " HCAL ENE " << hcalenergy
         << " ECAL ENE " << ecalenergy
         << " secPIN " << secpin 
         << " Algo Track " <<trkRef->algo() << std::endl;
           remove_this_kf = true;
         }
       }  
     }
       }
     }
     if( remove_this_kf ) {
       secd_kf = RO.secondaryKFs.erase(secd_kf);
       if( secd_kf == RO.secondaryKFs.end() ) break;
     }
   }  
 }

void PFEGammaAlgo::unlinkRefinableObjectKFandECALWithBadEoverP ( ProtoEGObject & RO )

private

Definition at line 2439 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, funct::abs(), PFEGammaAlgo::ProtoEGObject::brems, SoftLeptonByDistance_cfi::distance, digitizers_cfi::ecal, PFEGammaAlgo::ProtoEGObject::ecalclusters, PVValHelper::eta, f, spr::find(), reco::PFBlock::LINKTEST_ALL, PFEGammaAlgo::ProtoEGObject::localMap, LOGDRESSED, PFEGammaAlgo::ProtoEGObject::primaryGSFs, PFEGammaAlgo::ProtoEGObject::secondaryKFs, and unlinkRefinableObjectKFandECALMatchedToHCAL().

Referenced by buildAndRefineEGObjects(), and buildRefinedSuperCluster().

                                                                {  
   // this only means something for ROs with a primary GSF track
   if( RO.primaryGSFs.empty() ) return;  
   // need energy sums to tell if we've added crap or not
   const double Pin_gsf = RO.primaryGSFs.front().first->GsftrackRef()->pMode();
   const double gsfOuterEta  = 
     RO.primaryGSFs.front().first->positionAtECALEntrance().Eta();
   double tot_ecal= 0.0;  
   std::vector<double> min_brem_dists;
   std::vector<double> closest_brem_eta;    
   // first get the total ecal energy (we should replace this with a cache)
   for( const auto& ecal : RO.ecalclusters ) {
     tot_ecal += ecal.first->clusterRef()->correctedEnergy();
     // we also need to look at the minimum distance to brems
     // since energetic brems will be closer to the brem than the track
     double min_brem_dist = 5000.0; 
     double eta = -999.0;
     for( const auto& brem : RO.brems ) {
       const float dist = _currentblock->dist(brem.first->index(),
                          ecal.first->index(),
                          _currentlinks,
                          reco::PFBlock::LINKTEST_ALL);
       if( dist < min_brem_dist && dist != -1.0f ) {
     min_brem_dist = dist;
     eta = brem.first->positionAtECALEntrance().Eta();
       }
     }
     min_brem_dists.push_back(min_brem_dist);
     closest_brem_eta.push_back(eta);
   }  
   
   // loop through the ECAL clusters and remove ECAL clusters matched to
   // secondary track either in *or* out of the SC if the E/pin is bad
   for( auto secd_kf = RO.secondaryKFs.begin(); 
        secd_kf != RO.secondaryKFs.end(); ++secd_kf ) {
     reco::TrackRef trkRef =   secd_kf->first->trackRef();   
     const float secpin = secd_kf->first->trackRef()->p();  
     bool remove_this_kf = false;
     for( auto ecal = RO.ecalclusters.begin(); 
      ecal != RO.ecalclusters.end(); ++ecal ) {
       size_t bremidx = std::distance(RO.ecalclusters.begin(),ecal);
       const float minbremdist = min_brem_dists[bremidx];
       const double ecalenergy = ecal->first->clusterRef()->correctedEnergy();
       const double Epin = ecalenergy/secpin;
       const double detaGsf = 
     std::abs(gsfOuterEta - ecal->first->clusterRef()->positionREP().Eta());
       const double detaBrem = 
     std::abs(closest_brem_eta[bremidx] - 
          ecal->first->clusterRef()->positionREP().Eta());
       
       ElementMap::value_type check_match(ecal->first,secd_kf->first);
       auto kf_matched = std::find(RO.localMap.begin(),
                   RO.localMap.end(),
                   check_match);
       
       const float tkdist = _currentblock->dist(secd_kf->first->index(),
                            ecal->first->index(),
                            _currentlinks,
                            reco::PFBlock::LINKTEST_ALL);
       
       // do not reject this track if it is closer to a brem than the
       // secondary track, or if it lies in the delta-eta plane with the
       // gsf track or if it is in the dEta plane with the brems
       if( Epin > 3 && kf_matched != RO.localMap.end() && 
       tkdist != -1.0f && tkdist < minbremdist &&
       detaGsf > 0.05 && detaBrem > 0.015) {
     double res_with = std::abs((tot_ecal-Pin_gsf)/Pin_gsf);
     double res_without = std::abs((tot_ecal-ecalenergy-Pin_gsf)/Pin_gsf);
     if(res_without < res_with) {      
         LOGDRESSED("PFEGammaAlgo")
           << " REJECTED_RES totenergy " << tot_ecal
           << " Pin_gsf " << Pin_gsf 
           << " cluster to secondary " <<  ecalenergy
           << " res_with " <<  res_with
           << " res_without " << res_without << std::endl;
         tot_ecal -= ecalenergy;     
         remove_this_kf = true;   
         ecal = RO.ecalclusters.erase(ecal);
         if( ecal == RO.ecalclusters.end() ) break;      
     }
       }
     }
     if( remove_this_kf ) {
       secd_kf = RO.secondaryKFs.erase(secd_kf);
       if( secd_kf == RO.secondaryKFs.end() ) break;
     }
   }  
 }

bool PFEGammaAlgo::unwrapSuperCluster	(	const reco::PFBlockElementSuperCluster *	thesc,
		std::vector< PFClusterFlaggedElement > &	ecalclusters,
		ClusterMap &	ecal2ps
	)

private

Definition at line 1115 of file PFEGammaAlgo.cc.

References _currentblock, _currentlinks, _splayedblock, attachPSClusters(), TauDecayModes::dec, SoftLeptonByDistance_cfi::distance, docast, reco::PFBlockElementCluster::Dump(), reco::PFBlockElementSuperCluster::Dump(), reco::PFBlockElement::ECAL, Exception, spr::find(), reco::PFBlockElementSuperCluster::fromPFSuperCluster(), edm::Ref< C, T, F >::get(), reco::PFBlockElement::HGCAL, edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNonnull(), LOGDRESSED, LOGERR, LOGVERB, and reco::PFBlockElementSuperCluster::superClusterRef().

Referenced by initializeProtoCands().

                                  {
    ecalclusters.clear();
    ecal2ps.clear();
    LOGVERB("PFEGammaAlgo")
      << "Pointer to SC element: 0x" 
      << std::hex << thesc << std::dec << std::endl
      << "cleared ecalclusters and ecal2ps!" << std::endl;  
    auto ecalbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
    auto ecalend = _splayedblock[reco::PFBlockElement::ECAL].end(); 
    auto hgcalbegin = _splayedblock[reco::PFBlockElement::HGCAL].begin();
    auto hgcalend = _splayedblock[reco::PFBlockElement::HGCAL].end(); 
    if( ecalbegin == ecalend && hgcalbegin == hgcalend ) {
      LOGERR("PFEGammaAlgo::unwrapSuperCluster()")
        << "There are no ECAL elements in a block with imported SC!" 
        << " This is a bug we should fix this!" 
        << std::endl;
      return false;
    }
    reco::SuperClusterRef scref = thesc->superClusterRef();
    const bool is_pf_sc = thesc->fromPFSuperCluster();
    if( !(scref.isAvailable() && scref.isNonnull()) ) {
      throw cms::Exception("PFEGammaAlgo::unwrapSuperCluster()")
        << "SuperCluster pointed to by block element is null!" 
        << std::endl;
    }
    LOGDRESSED("PFEGammaAlgo")
      << "Got a valid super cluster ref! 0x" 
      << std::hex << scref.get() << std::dec << std::endl;
    const size_t nscclusters = scref->clustersSize();
    const size_t nscpsclusters = scref->preshowerClustersSize();
    size_t npfpsclusters = 0;
    size_t npfclusters = 0;
    LOGDRESSED("PFEGammaAlgo")
      << "Precalculated cluster multiplicities: " 
      << nscclusters << ' ' << nscpsclusters << std::endl;
    NotCloserToOther<reco::PFBlockElement::SC,reco::PFBlockElement::ECAL> 
      ecalClustersInSC(_currentblock,_currentlinks,thesc);
    NotCloserToOther<reco::PFBlockElement::SC,reco::PFBlockElement::HGCAL> 
      hgcalClustersInSC(_currentblock,_currentlinks,thesc);
    auto ecalfirstnotinsc = std::partition(ecalbegin,ecalend,ecalClustersInSC);
    auto hgcalfirstnotinsc = std::partition(hgcalbegin,hgcalend,hgcalClustersInSC);
    //reset the begin and end iterators
    ecalbegin = _splayedblock[reco::PFBlockElement::ECAL].begin();
    ecalend = _splayedblock[reco::PFBlockElement::ECAL].end();  
 
    hgcalbegin = _splayedblock[reco::PFBlockElement::HGCAL].begin();
    hgcalend = _splayedblock[reco::PFBlockElement::HGCAL].end();  
 
    //get list of associated clusters by det id and energy matching
    //(only needed when using non-pf supercluster)
    std::vector<const ClusterElement*> safePFClusters = is_pf_sc ? std::vector<const ClusterElement*>() : getSCAssociatedECALsSafe(scref,_splayedblock[reco::PFBlockElement::ECAL]);
    
    if( ecalfirstnotinsc == ecalbegin &&  
        hgcalfirstnotinsc == hgcalbegin) {
      LOGERR("PFEGammaAlgo::unwrapSuperCluster()")
        << "No associated block elements to SuperCluster!" 
        << " This is a bug we should fix!"
        << std::endl;
      return false;
    }
    npfclusters = std::distance(ecalbegin,ecalfirstnotinsc) + std::distance(hgcalbegin,hgcalfirstnotinsc);
    // ensure we have found the correct number of PF ecal clusters in the case
    // that this is a PF supercluster, otherwise all bets are off
    if( is_pf_sc && nscclusters != npfclusters ) {
      std::stringstream sc_err;
      thesc->Dump(sc_err,"\t");
      throw cms::Exception("PFEGammaAlgo::unwrapSuperCluster()")
        << "The number of found ecal elements ("
        << nscclusters << ") in block is not the same as"
        << " the number of ecal PF clusters reported by the PFSuperCluster"
        << " itself (" << npfclusters
        << ")! This should not happen!" << std::endl 
        << sc_err.str() << std::endl;
    }
    for( auto ecalitr = ecalbegin; ecalitr != ecalfirstnotinsc; ++ecalitr ) {    
      const PFClusterElement* elemascluster = 
        docast(const PFClusterElement*,ecalitr->first);
 
      // reject clusters that really shouldn't be associated to the SC
      // (only needed when using non-pf-supercluster)
      if(!is_pf_sc && std::find(safePFClusters.begin(),safePFClusters.end(),elemascluster) ==
     safePFClusters.end() ) continue;
 
      //add cluster
      ecalclusters.push_back(std::make_pair(elemascluster,true));
      //mark cluster as used
      ecalitr->second = false;     
      
      // process the ES elements
      // auto is a pair<Iterator,bool> here, bool is false when placing fails
      auto emplaceresult = ecal2ps.emplace(elemascluster,
                       ClusterMap::mapped_type());    
      if( !emplaceresult.second ) {
        std::stringstream clus_err;
        elemascluster->Dump(clus_err,"\t");
        throw cms::Exception("PFEGammaAlgo::unwrapSuperCluster()")
      << "List of pointers to ECAL block elements contains non-unique items!"
      << " This is very bad!" << std::endl
      << "cluster ptr = 0x" << std::hex << elemascluster << std::dec 
      << std::endl << clus_err.str() << std::endl;
      }    
      ClusterMap::mapped_type& eslist = emplaceresult.first->second;    
      npfpsclusters += attachPSClusters(elemascluster,eslist);    
    } // loop over ecal elements
 
    for( auto hgcalitr = hgcalbegin; hgcalitr != hgcalfirstnotinsc; ++hgcalitr ) {    
      const PFClusterElement* elemascluster = 
        docast(const PFClusterElement*,hgcalitr->first);
 
      // reject clusters that really shouldn't be associated to the SC
      // (only needed when using non-pf-supercluster)
      if(!is_pf_sc && std::find(safePFClusters.begin(),safePFClusters.end(),elemascluster) ==
     safePFClusters.end() ) continue;
 
      //add cluster
      ecalclusters.push_back(std::make_pair(elemascluster,true));
      //mark cluster as used
      hgcalitr->second = false;     
    } // loop over ecal elements
    
    /*
    if( is_pf_sc && nscpsclusters != npfpsclusters) {
      std::stringstream sc_err;
      thesc->Dump(sc_err,"\t");
      throw cms::Exception("PFEGammaAlgo::unwrapSuperCluster()")
        << "The number of found PF preshower elements (" 
        << npfpsclusters << ") in block is not the same as"
        << " the number of preshower clusters reported by the PFSuperCluster"
        << " itself (" << nscpsclusters << ")! This should not happen!" 
        << std::endl 
        << sc_err.str() << std::endl;
    }
    */
 
    LOGDRESSED("PFEGammaAlgo")
      << " Unwrapped SC has " << npfclusters << " ECAL sub-clusters"
      << " and " << npfpsclusters << " PreShower layers 1 & 2 clusters!" 
      << std::endl; 
    return true;
  }

Member Data Documentation

reco::PFCandidateCollection PFEGammaAlgo::_finalCandidates

private

Definition at line 220 of file PFEGammaAlgo.h.

Referenced by buildAndRefineEGObjects().

ElementMap PFEGammaAlgo::_recoveredlinks

private

Definition at line 205 of file PFEGammaAlgo.h.

Referenced by buildAndRefineEGObjects(), and removeOrLinkECALClustersToKFTracks().

std::list<ProtoEGObject> PFEGammaAlgo::_refinableObjects

private

Definition at line 218 of file PFEGammaAlgo.h.

Referenced by buildAndRefineEGObjects(), dumpCurrentRefinableObjects(), and initializeProtoCands().

std::vector<std::vector<PFFlaggedElement> > PFEGammaAlgo::_splayedblock

private

Definition at line 204 of file PFEGammaAlgo.h.

std::vector<unsigned int> PFEGammaAlgo::AddFromElectron_

private

Definition at line 398 of file PFEGammaAlgo.h.

PFEGConfigInfo PFEGammaAlgo::cfg_

private

Definition at line 313 of file PFEGammaAlgo.h.

Referenced by buildRefinedSuperCluster(), fillPFCandidates(), linkRefinableObjectECALToSingleLegConv(), PFEGammaAlgo(), removeOrLinkECALClustersToKFTracks(), setAlphaGamma_ESplanes_fromDB(), and setPhotonPrimaryVtx().

const ESChannelStatus* PFEGammaAlgo::channelStatus_

private

Definition at line 396 of file PFEGammaAlgo.h.

Referenced by buildRefinedSuperCluster(), and setESChannelStatus().

float PFEGammaAlgo::chi2

private

Definition at line 368 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

float PFEGammaAlgo::chi2_gsf

private

Definition at line 322 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::chi2_kf

private

Definition at line 322 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::Clus5x5ratio_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::ClusEta_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::ClusPhi_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::ClusR9_

private

Definition at line 374 of file PFEGammaAlgo.h.

std::vector< std::pair <unsigned int, unsigned int> > PFEGammaAlgo::convGsfTrack_

private

Definition at line 311 of file PFEGammaAlgo.h.

Referenced by RunPFEG().

float PFEGammaAlgo::CrysEta_

private

Definition at line 374 of file PFEGammaAlgo.h.

int PFEGammaAlgo::CrysIEta_

private

Definition at line 376 of file PFEGammaAlgo.h.

int PFEGammaAlgo::CrysIPhi_

private

Definition at line 376 of file PFEGammaAlgo.h.

float PFEGammaAlgo::CrysPhi_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::CrysX_

private

Definition at line 377 of file PFEGammaAlgo.h.

float PFEGammaAlgo::CrysY_

private

Definition at line 377 of file PFEGammaAlgo.h.

float PFEGammaAlgo::del_phi

private

Definition at line 368 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

float PFEGammaAlgo::dEta_

private

Definition at line 385 of file PFEGammaAlgo.h.

float PFEGammaAlgo::DEtaGsfEcalClust

private

Definition at line 329 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::dPhi_

private

Definition at line 385 of file PFEGammaAlgo.h.

float PFEGammaAlgo::dPtOverPt_gsf

private

Definition at line 322 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::DPtOverPt_gsf

private

Definition at line 322 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::DPtOverPt_kf

private

Definition at line 322 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::e1x3_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e1x5_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e2x5Bottom_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e2x5Left_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e2x5Max_

private

Definition at line 382 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e2x5Right_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e2x5Top_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e3x1_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e3x3_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::E3x3_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::e5x5Map[5][5]

private

Definition at line 371 of file PFEGammaAlgo.h.

float PFEGammaAlgo::earlyBrem

private

Definition at line 332 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::EB

private

Definition at line 378 of file PFEGammaAlgo.h.

float PFEGammaAlgo::ebottom_

private

Definition at line 381 of file PFEGammaAlgo.h.

edm::Handle<reco::PFCluster::EEtoPSAssociation> PFEGammaAlgo::eetops_

private

Definition at line 199 of file PFEGammaAlgo.h.

Referenced by attachPSClusters(), and setEEtoPSAssociation().

reco::PFCandidateCollection PFEGammaAlgo::egCandidate_

private

Definition at line 400 of file PFEGammaAlgo.h.

Referenced by isEGValidCandidate(), and RunPFEG().

reco::PFCandidateEGammaExtraCollection PFEGammaAlgo::egExtra_

private

Definition at line 404 of file PFEGammaAlgo.h.

Referenced by RunPFEG().

float PFEGammaAlgo::EGsfPoutMode

private

Definition at line 328 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::eleft_

private

Definition at line 381 of file PFEGammaAlgo.h.

float PFEGammaAlgo::EoverPt

private

Definition at line 368 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

float PFEGammaAlgo::eright_

private

Definition at line 381 of file PFEGammaAlgo.h.

float PFEGammaAlgo::eSeed_

private

Definition at line 380 of file PFEGammaAlgo.h.

float PFEGammaAlgo::Eta_gsf

private

Definition at line 319 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::etop_

private

Definition at line 381 of file PFEGammaAlgo.h.

float PFEGammaAlgo::EtotBremPinPoutMode

private

Definition at line 328 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::EtotPinMode

private

Definition at line 328 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::excluded_

private

Definition at line 395 of file PFEGammaAlgo.h.

std::vector< std::pair <unsigned int, unsigned int> > PFEGammaAlgo::fifthStepKfTrack_

private

Definition at line 310 of file PFEGammaAlgo.h.

Referenced by RunPFEG().

float PFEGammaAlgo::firstBrem

private

Definition at line 332 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

std::vector<bool> PFEGammaAlgo::GsfTrackSingleEcal_

private

Definition at line 309 of file PFEGammaAlgo.h.

float PFEGammaAlgo::HOverHE

private

Definition at line 333 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::HOverPin

private

Definition at line 333 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::HoverPt

private

Definition at line 368 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

bool PFEGammaAlgo::isvalid_

private

Definition at line 335 of file PFEGammaAlgo.h.

float PFEGammaAlgo::lateBrem

private

Definition at line 332 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::lnPt_gsf

private

Definition at line 319 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

std::vector<bool> PFEGammaAlgo::lockExtraKf_

private

Definition at line 308 of file PFEGammaAlgo.h.

float PFEGammaAlgo::logPFClusE_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::LowClusE_

private

Definition at line 385 of file PFEGammaAlgo.h.

std::vector<int> PFEGammaAlgo::match_ind

private

Definition at line 363 of file PFEGammaAlgo.h.

float PFEGammaAlgo::Mustache_Et_out_

private

Definition at line 395 of file PFEGammaAlgo.h.

float PFEGammaAlgo::Mustache_EtRatio_

private

Definition at line 395 of file PFEGammaAlgo.h.

float PFEGammaAlgo::MustE_

private

Definition at line 384 of file PFEGammaAlgo.h.

double PFEGammaAlgo::mvaValue

private

Definition at line 369 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

const char* PFEGammaAlgo::mvaWeightFile_

private

Definition at line 315 of file PFEGammaAlgo.h.

float PFEGammaAlgo::nhit_gsf

private

Definition at line 325 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::nhit_kf

private

Definition at line 325 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::nlayers

private

Definition at line 367 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

float PFEGammaAlgo::nlost

private

Definition at line 367 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

float PFEGammaAlgo::nPFClus_

private

Definition at line 385 of file PFEGammaAlgo.h.

float PFEGammaAlgo::nVtx_

private

Definition at line 387 of file PFEGammaAlgo.h.

Referenced by setnPU().

reco::PFCandidateCollection PFEGammaAlgo::outcands_

private

Definition at line 193 of file PFEGammaAlgo.h.

Referenced by buildAndRefineEGObjects(), and getCandidates().

reco::PFCandidateEGammaExtraCollection PFEGammaAlgo::outcandsextra_

private

Definition at line 194 of file PFEGammaAlgo.h.

Referenced by buildAndRefineEGObjects(), and getEGExtra().

std::vector< reco::PFCandidate > PFEGammaAlgo::permElectronCandidates_

private

Definition at line 366 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFCrysEtaCrack_

private

Definition at line 374 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoE_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoECorr_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoEt_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoEta_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoEtCorr_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoPhi_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoR9_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::PFPhoR9Corr_

private

Definition at line 384 of file PFEGammaAlgo.h.

const reco::Vertex* PFEGammaAlgo::primaryVertex_

private

Definition at line 348 of file PFEGammaAlgo.h.

float PFEGammaAlgo::RConv_

private

Definition at line 384 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderGC_

private

Definition at line 351 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderGCEB_

private

Definition at line 356 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderGCEEhR9_

private

Definition at line 357 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderGCEElR9_

private

Definition at line 358 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderLC_

private

Definition at line 350 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderLCEB_

private

Definition at line 354 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderLCEE_

private

Definition at line 355 of file PFEGammaAlgo.h.

const GBRForest* PFEGammaAlgo::ReaderRes_

private

Definition at line 352 of file PFEGammaAlgo.h.

reco::SuperClusterCollection PFEGammaAlgo::refinedscs_

private

Definition at line 195 of file PFEGammaAlgo.h.

Referenced by fillPFCandidates(), and getRefinedSCs().

float PFEGammaAlgo::RMSAll_

private

Definition at line 385 of file PFEGammaAlgo.h.

float PFEGammaAlgo::RMSMust_

private

Definition at line 385 of file PFEGammaAlgo.h.

float PFEGammaAlgo::SCEtaWidth_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::SCPhiWidth_

private

Definition at line 384 of file PFEGammaAlgo.h.

float PFEGammaAlgo::SigmaEtaEta

private

Definition at line 330 of file PFEGammaAlgo.h.

Referenced by calculate_ele_mva().

float PFEGammaAlgo::STIP

private

Definition at line 368 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

double PFEGammaAlgo::sumPtTrackIsoForPhoton_

private

Definition at line 361 of file PFEGammaAlgo.h.

double PFEGammaAlgo::sumPtTrackIsoSlopeForPhoton_

private

Definition at line 362 of file PFEGammaAlgo.h.

float PFEGammaAlgo::TotPS1_

private

Definition at line 386 of file PFEGammaAlgo.h.

float PFEGammaAlgo::TotPS2_

private

Definition at line 386 of file PFEGammaAlgo.h.

float PFEGammaAlgo::track_pt

private

Definition at line 368 of file PFEGammaAlgo.h.

Referenced by EvaluateSingleLegMVA().

verbosityLevel PFEGammaAlgo::verbosityLevel_

private

Definition at line 342 of file PFEGammaAlgo.h.

Referenced by RunPFEG().

float PFEGammaAlgo::VtxZ_

private

Definition at line 374 of file PFEGammaAlgo.h.

TH2D* PFEGammaAlgo::X0_inner

private

Definition at line 390 of file PFEGammaAlgo.h.

Referenced by PFEGammaAlgo().

TH2D* PFEGammaAlgo::X0_middle

private

Definition at line 391 of file PFEGammaAlgo.h.

Referenced by PFEGammaAlgo().

TH2D* PFEGammaAlgo::X0_outer

private

Definition at line 392 of file PFEGammaAlgo.h.

Referenced by PFEGammaAlgo().

TH2D* PFEGammaAlgo::X0_sum

private

Definition at line 389 of file PFEGammaAlgo.h.

Referenced by PFEGammaAlgo().

float PFEGammaAlgo::x0inner_

private

Definition at line 393 of file PFEGammaAlgo.h.

float PFEGammaAlgo::x0middle_

private

Definition at line 393 of file PFEGammaAlgo.h.

float PFEGammaAlgo::x0outer_

private

Definition at line 393 of file PFEGammaAlgo.h.

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation