Particle Flow Algorithm test bench for the electron team. More...

#include <PFAlgoTestBenchElectrons.h>

Inheritance diagram for PFAlgoTestBenchElectrons:

Public Member Functions
	PFAlgoTestBenchElectrons ()
	constructor More...

virtual	~PFAlgoTestBenchElectrons ()
	destructor More...

Public Member Functions inherited from PFAlgo
void	checkCleaning (const reco::PFRecHitCollection &cleanedHF)
	Check HF Cleaning. More...

PFMuonAlgo *	getPFMuonAlgo ()

	PFAlgo ()
	constructor More...

const std::auto_ptr < reco::PFCandidateCollection > &	pfCandidates () const

void	reconstructParticles (const reco::PFBlockHandle &blockHandle)

virtual void	reconstructParticles (const reco::PFBlockCollection &blocks)
	reconstruct particles More...

void	setAlgo (int algo)

void	setCandConnectorParameters (const edm::ParameterSet &iCfgCandConnector)

void	setCandConnectorParameters (bool bCorrect, bool bCalibPrimary, double dptRel_PrimaryTrack, double dptRel_MergedTrack, double ptErrorSecondary, const std::vector< double > &nuclCalibFactors)

void	setDebug (bool debug)

void	setDisplacedVerticesParameters (bool rejectTracks_Bad, bool rejectTracks_Step45, bool usePFNuclearInteractions, bool usePFConversions, bool usePFDecays, double dptRel_DispVtx)

void	setEGammaCollections (const edm::View< reco::PFCandidate > &pfEgammaCandidates, const edm::ValueMap< reco::GsfElectronRef > &valueMapGedElectrons, const edm::ValueMap< reco::PhotonRef > &valueMapGedPhotons)

void	setEGammaParameters (bool use_EGammaFilters, std::string ele_iso_path_mvaWeightFile, double ele_iso_pt, double ele_iso_mva_barrel, double ele_iso_mva_endcap, double ele_iso_combIso_barrel, double ele_iso_combIso_endcap, double ele_noniso_mva, unsigned int ele_missinghits, bool useProtectionsForJetMET, const edm::ParameterSet &ele_protectionsForJetMET, double ph_MinEt, double ph_combIso, double ph_HoE, double ph_sietaieta_eb, double ph_sietaieta_ee, const edm::ParameterSet &ph_protectionsForJetMET)

void	setEGElectronCollection (const reco::GsfElectronCollection &egelectrons)

void	setElectronExtraRef (const edm::OrphanHandle< reco::PFCandidateElectronExtraCollection > &extrah)

void	setHOTag (bool ho)

void	setMuonHandle (const edm::Handle< reco::MuonCollection > &)

void	setParameters (double nSigmaECAL, double nSigmaHCAL, const boost::shared_ptr< PFEnergyCalibration > &calibration, const boost::shared_ptr< PFEnergyCalibrationHF > &thepfEnergyCalibrationHF)

void	setPFEleParameters (double mvaEleCut, std::string mvaWeightFileEleID, bool usePFElectrons, const boost::shared_ptr< PFSCEnergyCalibration > &thePFSCEnergyCalibration, const boost::shared_ptr< PFEnergyCalibration > &thePFEnergyCalibration, double sumEtEcalIsoForEgammaSC_barrel, double sumEtEcalIsoForEgammaSC_endcap, double coneEcalIsoForEgammaSC, double sumPtTrackIsoForEgammaSC_barrel, double sumPtTrackIsoForEgammaSC_endcap, unsigned int nTrackIsoForEgammaSC, double coneTrackIsoForEgammaSC, bool applyCrackCorrections=false, bool usePFSCEleCalib=true, bool useEGElectrons=false, bool useEGammaSupercluster=true)

void	setPFMuonAlgo (PFMuonAlgo *algo)

void	setPFMuonAndFakeParameters (const edm::ParameterSet &pset)

void	setPFPhotonParameters (bool usePFPhoton, std::string mvaWeightFileConvID, double mvaConvCut, bool useReg, std::string X0_Map, const boost::shared_ptr< PFEnergyCalibration > &thePFEnergyCalibration, double sumPtTrackIsoForPhoton, double sumPtTrackIsoSlopeForPhoton)

void	setPFPhotonRegWeights (const GBRForest LCorrForestEB, const GBRForest LCorrForestEE, const GBRForest GCorrForestBarrel, const GBRForest GCorrForestEndcapHr9, const GBRForest GCorrForestEndcapLr9, const GBRForest PFEcalResolution)

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

void	setPhotonExtraRef (const edm::OrphanHandle< reco::PFCandidatePhotonExtraCollection > &pf_extrah)

void	setPostHFCleaningParameters (bool postHFCleaning, double minHFCleaningPt, double minSignificance, double maxSignificance, double minSignificanceReduction, double maxDeltaPhiPt, double minDeltaMet)

boost::shared_ptr < PFEnergyCalibration >	thePFEnergyCalibration ()
	return the pointer to the calibration function More...

std::auto_ptr < reco::PFCandidateCollection >	transferCandidates ()

std::auto_ptr < reco::PFCandidateCollection > &	transferCleanedCandidates ()

std::auto_ptr < reco::PFCandidateCollection >	transferElectronCandidates ()

std::auto_ptr < reco::PFCandidateElectronExtraCollection >	transferElectronExtra ()

std::auto_ptr < reco::PFCandidatePhotonExtraCollection >	transferPhotonExtra ()

virtual	~PFAlgo ()
	destructor More...

Protected Member Functions
virtual void	processBlock (const reco::PFBlockRef &blockref, std::list< reco::PFBlockRef > &hcalBlockRefs, std::list< reco::PFBlockRef > &ecalBlockRefs)

Protected Member Functions inherited from PFAlgo
void	associatePSClusters (unsigned iEcal, reco::PFBlockElement::Type psElementType, const reco::PFBlock &block, const edm::OwnVector< reco::PFBlockElement > &elements, const reco::PFBlock::LinkData &linkData, std::vector< bool > &active, std::vector< double > &psEne)
	Associate PS clusters to a given ECAL cluster, and return their energy. More...

bool	isFromSecInt (const reco::PFBlockElement &eTrack, std::string order) const

double	neutralHadronEnergyResolution (double clusterEnergy, double clusterEta) const
	todo: use PFClusterTools for this More...

double	nSigmaHCAL (double clusterEnergy, double clusterEta) const

void	postCleaning ()

unsigned	reconstructCluster (const reco::PFCluster &cluster, double particleEnergy, bool useDirection=false, double particleX=0., double particleY=0., double particleZ=0.)

unsigned	reconstructTrack (const reco::PFBlockElement &elt, bool allowLoose=false)

Additional Inherited Members
Protected Attributes inherited from PFAlgo
std::auto_ptr < reco::PFCandidateCollection >	pfCandidates_

std::auto_ptr < reco::PFCandidateCollection >	pfCleanedCandidates_

std::auto_ptr < reco::PFCandidateCollection >	pfElectronCandidates_
	the unfiltered electron collection More...

reco::PFCandidateElectronExtraCollection	pfElectronExtra_
	the unfiltered electron collection More...

std::auto_ptr < reco::PFCandidateCollection >	pfPhotonCandidates_
	the unfiltered photon collection More...

reco::PFCandidatePhotonExtraCollection	pfPhotonExtra_
	the extra photon collection More...

Detailed Description

Particle Flow Algorithm test bench for the electron team.

Author: Florian Beaudette, Daniele Benedetti, Michele Pioppi

Date: January 2006

Definition at line 18 of file PFAlgoTestBenchElectrons.h.

Constructor & Destructor Documentation

PFAlgoTestBenchElectrons::PFAlgoTestBenchElectrons ( )

inline

constructor

Definition at line 23 of file PFAlgoTestBenchElectrons.h.

23 {}

virtual PFAlgoTestBenchElectrons::~PFAlgoTestBenchElectrons ( )

inlinevirtual

destructor

Definition at line 26 of file PFAlgoTestBenchElectrons.h.

26 {}

Member Function Documentation

void PFAlgoTestBenchElectrons::processBlock	(	const reco::PFBlockRef &	blockref,
		std::list< reco::PFBlockRef > &	hcalBlockRefs,
		std::list< reco::PFBlockRef > &	ecalBlockRefs
	)

protectedvirtual

process one block. can be reimplemented in more sophisticated algorithms

Reimplemented from PFAlgo.

Definition at line 11 of file PFAlgoTestBenchElectrons.cc.

References reco::PFBlock::associatedElements(), createPayload::block, reco::PFBlockElement::BREM, reco::PFBlockElement::ECAL, reco::PFBlock::elements(), asciidump::elements, first, reco::PFBlockElement::GSF, getHLTprescales::index, reco::PFBlock::linkData(), edm::OwnVector< T, P >::push_back(), edm::second(), edm::OwnVector< T, P >::size(), and funct::true.

 {
 
   //cout<<"electron test bench: process block"
   //    <<(*blockref)<<endl;
  
 
   const reco::PFBlock& block = *blockref;
   PFBlock::LinkData linkData =  block.linkData();
   const edm::OwnVector< reco::PFBlockElement >&  elements = block.elements();
 
   std::vector<bool> active(elements.size(), true );
   vector<unsigned> mainecal_index;
   for(unsigned iEle=0; iEle<elements.size(); iEle++) {
     PFBlockElement::Type type = elements[iEle].type();
     if (type == reco::PFBlockElement::ECAL ) {
       mainecal_index.push_back(iEle);
     }
   }
   
   std::map<unsigned, unsigned> FinalBremECALIndex;
   unsigned ECALGSF_index = 1000;
   unsigned GSF_index = 1000;
   for(unsigned iEle=0; iEle<elements.size(); iEle++) {
     
     
     PFBlockElement::Type type = elements[iEle].type();
     
     if (type == reco::PFBlockElement::GSF ) {
       GSF_index = iEle;
       
       // linked ECAL clusters
       std::multimap<double, unsigned> ecalElems;
       block.associatedElements( iEle,  linkData,
                   ecalElems ,
                   reco::PFBlockElement::ECAL );     
       
       typedef std::multimap<double, unsigned>::iterator IE;
       
       float chi2GSFFinal = 1000;
       for(IE ie = ecalElems.begin(); ie != ecalElems.end(); ++ie ) {
     double   chi2  = ie->first;
     unsigned index = ie->second;
     if (chi2 <  chi2GSFFinal) {
       chi2GSFFinal = chi2;
       ECALGSF_index = index;
     }
       }
       
       std::multimap<double, unsigned> Brems;
       
       block.associatedElements( iEle,  linkData,
                   Brems ,
                   reco::PFBlockElement::BREM );
       typedef std::multimap<double, unsigned>::iterator IB;
        
       vector< pair<double, unsigned> > ecalindexforbrem;
       vector<unsigned> brem_index;
       for(IB iee = Brems.begin(); iee != Brems.end(); ++iee ) {
 
     unsigned index = iee->second;
 
     std::multimap<double, unsigned> ecalBrems;
     block.associatedElements( index,  linkData,
                     ecalBrems ,
                     reco::PFBlockElement::ECAL );
     typedef std::multimap<double, unsigned>::iterator IEB;
     float chi2BremFinal = 1000;
     unsigned ECALBREM_index = 1000;
     
     for(IEB ieb = ecalBrems.begin(); ieb != ecalBrems.end(); ++ieb ) {
       // Two cases: first there is a ecalGSF=brem chi2 < chi2ecalGSF ?
       
       
       if (ieb->second != ECALGSF_index) {
         
         double   chi2_eb  = ieb->first;
         unsigned index_eb = ieb->second;
         if (chi2_eb < chi2BremFinal) {
           chi2BremFinal = chi2_eb;
           ECALBREM_index = index_eb;
         }
       }
     }
     if (ECALBREM_index != 1000){
       ecalindexforbrem.push_back(make_pair(chi2BremFinal,ECALBREM_index));  
       // for each brem (same size that brems)
       brem_index.push_back(index);
     }
       }
       for (unsigned ie=0;ie<mainecal_index.size();ie++){
     unsigned c_brem = 0;
     
     double chi2best = 1000;
     unsigned final_ecal = 1000;
     unsigned final_brem = 1000;
     if (mainecal_index[ie] != ECALGSF_index) {
       for (unsigned i2eb = 0; i2eb < ecalindexforbrem.size(); i2eb++ ) {
         unsigned temp_ecal_index =  (ecalindexforbrem[i2eb]).second;
         double temp_chi2 = (ecalindexforbrem[i2eb]).first;
 
         if (temp_ecal_index == mainecal_index[ie] ) {
           if (temp_chi2 < chi2best ){
         chi2best = temp_chi2;
         final_ecal = temp_ecal_index;
         final_brem = brem_index[c_brem];
           }
         }
         c_brem++;
       }
       if (chi2best < 1000) {
         FinalBremECALIndex.insert(make_pair(final_brem,final_ecal)); 
       }
     }
     
       }
 
 
       
       bool ElectronId = false;
      
       // perform electron iD
       //Start  ***************************************
       ElectronId = true; 
       //End ***************************************
       
       // Lock the various elements 
       // NOTE very lose cuts!
       if (ElectronId) {
     if (chi2GSFFinal < 1000) {      
 
       active[iEle] = false;   //GSF 
       active[ECALGSF_index] = false;  // ECAL associated to GSF
       // Lock Brem and ECAL associated to brem
       typedef std::map<unsigned, unsigned>::iterator IT;
       for (map<unsigned, unsigned>::iterator it = FinalBremECALIndex.begin(); it != FinalBremECALIndex.end(); ++it ) {
         unsigned index_brem = it->first;
         unsigned index_ecalbrem = it->second;
         active[index_brem]=false;
         active[index_ecalbrem] = false;
       }
     }
       }  // End if Electron ID
     } // End GSF type
   } // Run on elements
    
 
   vector<pair< bool, vector<unsigned int> > > associate;
 
   for(unsigned iEle=0; iEle<elements.size(); iEle++) {
 
     if (active[iEle] == true) {
       vector<unsigned> assoel(0);
       associate.push_back(make_pair(active[iEle],assoel));
     }
     if (active[iEle] == false){
       PFBlockElement::Type type = elements[iEle].type();
       if (type == reco::PFBlockElement::GSF) {
     vector<unsigned> assoel(0);
     // push back tk track: to be done
     
     // push back ecal cluster associate to gsf track
     assoel.push_back(ECALGSF_index);
     // push back selected brems
     for (map<unsigned, unsigned>::iterator it = FinalBremECALIndex.begin(); it != FinalBremECALIndex.end(); ++it ) {
       unsigned index_brem = it->first;
       assoel.push_back(index_brem);
     }
     associate.push_back(make_pair(active[iEle],assoel));
     // push back hcal cluster to be done
     // push back ps cluster to be done
       }
       if (type == reco::PFBlockElement::BREM) {
     vector<unsigned> assoel(0);
     // push back GSF track
     assoel.push_back(GSF_index);
     
     // push_back ecal clusters associate to the brem
     for (map<unsigned, unsigned>::iterator it = FinalBremECALIndex.begin(); it != FinalBremECALIndex.end(); ++it ) {
       if (it->first == iEle) {
         unsigned index_ecalbrem = it->second;
         assoel.push_back(index_ecalbrem);
       }
     }
     associate.push_back(make_pair(active[iEle],assoel));
     
     // push back hcal cluster to be done
     // push back ps cluster to be done
       }
       if  (type == reco::PFBlockElement::ECAL) {
     if (iEle == ECALGSF_index) {
       // cluster associate to the gsf track
       // push back the associate gsf track
       vector<unsigned> assoel(0);
       assoel.push_back(GSF_index);
       associate.push_back(make_pair(active[iEle],assoel));
     }
     for (map<unsigned, unsigned>::iterator it = FinalBremECALIndex.begin(); it != FinalBremECALIndex.end(); ++it ) {
       unsigned index_ecalbrem = it->second;
       unsigned index_brem = it->first;
       if (iEle == index_ecalbrem) {    // push back the brems associate to ecal 
         vector<unsigned> assoel(0);
         assoel.push_back(index_brem);
         associate.push_back(make_pair(active[iEle],assoel));
       }
     }
       }
     }
   }
   // here create the object with the block and associate (and active if needed)
 
 } // End loop on Blocks

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation