PFAlgoTestBenchElectrons Class Reference

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...
	PFAlgo ()
	constructor More...
const std::auto_ptr < reco::PFCandidateCollection > &	pfCandidates () const
void	postMuonCleaning (const edm::Handle< reco::MuonCollection > &muonh, const reco::VertexCollection &primaryVertices)
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, 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	setEGElectronCollection (const reco::GsfElectronCollection &egelectrons)
void	setElectronExtraRef (const edm::OrphanHandle< reco::PFCandidateElectronExtraCollection > &extrah)
void	setHOTag (bool ho)
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	setPFMuonAndFakeParameters (std::vector< double > muonHCAL, std::vector< double > muonECAL, std::vector< double > muonHO, double nSigmaTRACK, double ptError, std::vector< double > factors45, bool usePFMuonMomAssign, bool useBestMuonTrack)
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 >	transferAddedMuonCandidates ()
std::auto_ptr < reco::PFCandidateCollection >	transferCandidates ()
std::auto_ptr < reco::PFCandidateCollection > &	transferCleanedCandidates ()
std::auto_ptr < reco::PFCandidateCollection >	transferCleanedTrackerAndGlobalMuonCandidates ()
std::auto_ptr < reco::PFCandidateCollection >	transferCosmicsMuonCleanedCandidates ()
std::auto_ptr < reco::PFCandidateCollection >	transferElectronCandidates ()
std::auto_ptr < reco::PFCandidateElectronExtraCollection >	transferElectronExtra ()
std::auto_ptr < reco::PFCandidateCollection >	transferFakeMuonCleanedCandidates ()
std::auto_ptr < reco::PFCandidatePhotonExtraCollection >	transferPhotonExtra ()
std::auto_ptr < reco::PFCandidateCollection >	transferPunchThroughHadronCleanedCandidates ()
std::auto_ptr < reco::PFCandidateCollection >	transferPunchThroughMuonCleanedCandidates ()
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)

Additional Inherited Members
Protected Attributes inherited from PFAlgo
std::auto_ptr < reco::PFCandidateCollection >	pfAddedMuonCandidates_
	the collection of added muon candidates More...
std::auto_ptr < reco::PFCandidateCollection >	pfCandidates_
std::auto_ptr < reco::PFCandidateCollection >	pfCleanedCandidates_
std::auto_ptr < reco::PFCandidateCollection >	pfCleanedTrackerAndGlobalMuonCandidates_
	the collection of tracker/global cleaned muon candidates More...
std::auto_ptr < reco::PFCandidateCollection >	pfCosmicsMuonCleanedCandidates_
	the collection of cosmics cleaned muon candidates More...
std::auto_ptr < reco::PFCandidateCollection >	pfElectronCandidates_
	the unfiltered electron collection More...
reco::PFCandidateElectronExtraCollection	pfElectronExtra_
	the unfiltered electron collection More...
std::auto_ptr < reco::PFCandidateCollection >	pfFakeMuonCleanedCandidates_
	the collection of fake cleaned muon candidates More...
std::auto_ptr < reco::PFCandidateCollection >	pfPhotonCandidates_
	the unfiltered photon collection More...
reco::PFCandidatePhotonExtraCollection	pfPhotonExtra_
	the extra photon collection More...
std::auto_ptr < reco::PFCandidateCollection >	pfPunchThroughHadronCleanedCandidates_
	the collection of punch-through cleaned neutral hadron candidates More...
std::auto_ptr < reco::PFCandidateCollection >	pfPunchThroughMuonCleanedCandidates_
	the collection of punch-through cleaned muon candidates 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.

{}

virtual PFAlgoTestBenchElectrons::~PFAlgoTestBenchElectrons ( )

inlinevirtual

destructor

Definition at line 26 of file PFAlgoTestBenchElectrons.h.

{}

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