/data/refman/pasoursint/CMSSW_5_2_7_hltpatch2/src/RecoParticleFlow/PFProducer/interface/PFElectronAlgo.h

Go to the documentation of this file.

#ifndef PFProducer_PFElectronAlgo_H
#define PFProducer_PFElectronAlgo_H

#include "DataFormats/ParticleFlowReco/interface/PFBlockFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlock.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateElectronExtra.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementGsfTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementTrack.h"
#include "TMVA/Reader.h"
#include <iostream>


class PFSCEnergyCalibration;
class PFEnergyCalibration;

namespace reco { 
class PFCandidate;
}

class PFElectronAlgo {
 public:
  
  //constructor
  PFElectronAlgo(const double mvaEleCut,
                 std::string  mvaWeightFileEleID,
                 const boost::shared_ptr<PFSCEnergyCalibration>& thePFSCEnergyCalibration,
                 const boost::shared_ptr<PFEnergyCalibration>& thePFEnergyCalibration,
                 bool applyCrackCorrections,
                 bool usePFSCEleCalib,
                 bool useEGElectrons,
                 bool useEGammaSupercluster,
                 double sumEtEcalIsoForEgammaSC_barrel,
                 double sumEtEcalIsoForEgammaSC_endcap,
                 double coneEcalIsoForEgammaSC,
                 double sumPtTrackIsoForEgammaSC_barrel,
                 double sumPtTrackIsoForEgammaSC_endcap,
                 unsigned int nTrackIsoForEgammaSC,
                 double coneTrackIsoForEgammaSC);

  //destructor
  ~PFElectronAlgo(){delete tmvaReader_;};
  
  //check candidate validity
  bool isElectronValidCandidate(const reco::PFBlockRef&  blockRef,
                                std::vector<bool>&  active)
  {
    isvalid_=false;
    RunPFElectron(blockRef,active);
    return isvalid_;};
  
  //get electron PFCandidate
  const std::vector<reco::PFCandidate>& getElectronCandidates() {return elCandidate_;};

  //get all electron PFCandidate
  const std::vector<reco::PFCandidate>& getAllElectronCandidates() {return allElCandidate_;};

  //get the electron PFCandidateExtra (for all candidates)
  const std::vector< reco::PFCandidateElectronExtra>& getElectronExtra() {return electronExtra_;};

  // retrieve the list of pre-defined e/g electrons
  void setEGElectronCollection(const reco::GsfElectronCollection & egelectrons);

 private: 
  typedef  std::map< unsigned int, std::vector<unsigned int> >  AssMap;

  void RunPFElectron(const reco::PFBlockRef&  blockRef,
                     std::vector<bool>& active);

  unsigned int FindClosestElement(const unsigned int iele,
                          std::multimap<double, unsigned int>& Elems, 
                          float& chi2cut,
                          std::vector<bool>& active,
                          const reco::PFBlockRef&  blockRef);
  
  bool SetLinks(const reco::PFBlockRef&  blockRef,
                AssMap& associatedToGsf_,
                AssMap& associatedToBrems_,
                AssMap& associatedToEcal_,
                std::vector<bool>& active);
  
  void SetIDOutputs(const reco::PFBlockRef&  blockRef,
                    AssMap& associatedToGsf_,
                    AssMap& associatedToBrems_,
                    AssMap& associatedToEcal_);
  
  void SetCandidates(const reco::PFBlockRef&  blockRef,
                     AssMap& associatedToGsf_,
                     AssMap& associatedToBrems_,
                     AssMap& associatedToEcal_);
  
  void SetActive(const reco::PFBlockRef&  blockRef, 
                 AssMap& associatedToGsf_, 
                 AssMap& associatedToBrems_, 
                 AssMap& associatedToEcal_,
                 std::vector<bool>& active);
  
  unsigned int whichTrackAlgo(const reco::TrackRef& trackRef);

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

  std::vector<reco::PFCandidate> elCandidate_;
  std::vector<reco::PFCandidate> allElCandidate_;
  std::map<unsigned int,std::vector<reco::PFCandidate> > electronConstituents_;
  std::vector<double> BDToutput_;
  std::vector<reco::PFCandidateElectronExtra > electronExtra_;
  std::vector<bool> lockExtraKf_;
  std::vector<bool> GsfTrackSingleEcal_;
  std::vector< std::pair <unsigned int, unsigned int> > fifthStepKfTrack_;
  std::vector< std::pair <unsigned int, unsigned int> > convGsfTrack_;

  
  TMVA::Reader    *tmvaReader_;
  double mvaEleCut_;
  boost::shared_ptr<PFSCEnergyCalibration> thePFSCEnergyCalibration_; 
  boost::shared_ptr<PFEnergyCalibration> thePFEnergyCalibration_; 
  bool applyCrackCorrections_;
  bool usePFSCEleCalib_;
  bool useEGElectrons_;
  bool useEGammaSupercluster_;
  double sumEtEcalIsoForEgammaSC_barrel_;
  double sumEtEcalIsoForEgammaSC_endcap_;
  double coneEcalIsoForEgammaSC_;
  double sumPtTrackIsoForEgammaSC_barrel_;
  double sumPtTrackIsoForEgammaSC_endcap_;
  unsigned int nTrackIsoForEgammaSC_;
  double coneTrackIsoForEgammaSC_;

  const char  *mvaWeightFile_;

  // New BDT observables
  // Normalization 
  float lnPt_gsf,Eta_gsf;
  
  // Pure Tracking observ.
  float dPtOverPt_gsf,chi2_gsf,DPtOverPt_gsf,
    chi2_kf,DPtOverPt_kf;
  //  int nhit_gsf,nhit_kf;
  float nhit_gsf,nhit_kf;
  
  // Tracker-Ecal observ. 
  float EtotPinMode,EGsfPoutMode,EtotBremPinPoutMode;
  float DEtaGsfEcalClust;
  float SigmaEtaEta; 
  //int lateBrem,firstBrem,earlyBrem;
  float lateBrem,firstBrem,earlyBrem;
  float HOverHE,HOverPin;

  bool isvalid_;

  const std::vector<reco::GsfElectron> * theGsfElectrons_;
};


#endif