---

PFElectronAlgo.h

Go to the documentation of this file.

#ifndef PFElectronAlgo_H
#define PFElectronAlgo_H

#include "DataFormats/ParticleFlowReco/interface/PFBlockFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlock.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h"
#include "RecoParticleFlow/PFClusterTools/interface/PFEnergyResolution.h"
#include "TMVA/Reader.h"
#include <iostream>
class reco::PFCandidate;

class PFElectronAlgo {
 public:
  
  //constructor
  PFElectronAlgo(const std::vector<double> chi2values,
                 const double mvaEleCut,
                 std::string  mvaWeightFileEleID);
                
  
  //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
  std::vector<reco::PFCandidate> getElectronCandidates() {return elCandidate_;};
  //std::vector<bool> getElectronActive() {return EleActive_;};
  
 private: 
  typedef  std::vector<std::pair< unsigned int, std::vector<unsigned int> > > AssMap;
  void RunPFElectron(const reco::PFBlockRef&  blockRef,
                     std::vector<bool>& active);

  uint FindClosestElement(const uint iele,
                          std::multimap<double, unsigned>& Elems, 
                          float& chi2cut,
                          std::vector<bool>& active,
                          const reco::PFBlockRef&  blockRef);
  

  bool findLinkPairs(const std::vector< std::pair<unsigned, double> >& MinRow, 
                     const std::vector<unsigned>& brem_it,
                     const std::vector<unsigned>& clust_it, 
                     std::map<unsigned, unsigned>& finallink, 
                     float chi2cut);
  
  uint FindClosestElementCond(const uint iele,
                              std::multimap<double, unsigned>& Elems, 
                              float& chi2cut,float chi2Comp, uint indexComp,
                              std::vector<bool>& active,
                              const reco::PFBlockRef&  blockRef);


  void MultipleGsfTrackAssociation(const reco::PFBlockRef&  blockRef);

  bool SetLinks(const reco::PFBlockRef&  blockRef,
                AssMap& associatedToGSF_,
                AssMap& associatedToBrems_,
                std::vector<bool>& active);
  
  void SetIDOutputs(const reco::PFBlockRef&  blockRef,
                    const AssMap& associatedToGSF_,
                    const AssMap& associatedToBrems_);

  void SetCandidates(const reco::PFBlockRef&  blockRef,
                     const AssMap& associatedToGSF_,
                     const AssMap& associatedToBrems_);
  
  void SetActive(const reco::PFBlockRef&  blockRef,
                 const AssMap& associatedToGSF_,
                 const AssMap& associatedToBrems_,
                 std::vector<bool>& active);
  
 /*  reco::PFBlock block_; */
/*   reco::PFBlockRef blockref_; */
  std::vector<reco::PFCandidate> elCandidate_;
  std::vector<double> BDToutput_;
  std::vector<double> chi2values_;
  std::vector<bool> GsfTrackSingleEcal_;

  double mvaEleCut_;
  TMVA::Reader    *tmvaReader_;
  const char  *mvaWeightFile_;
  // Observables for gsf
  float TEtotPinMode;
  float TEtotPinMean;
  float TEGsfPoutMode;
  float TDiffEtaGSFEcalEle;
  float TSigmaEtaEtaEle;
  float TChiEcalEle;
  // Observables for brems
  float TSumEBremPinPoutMode;
  float TSumEBremPinPoutMean;
  int TNumBrem;
  int TLateBrem;
  int TEarlyBrem;    
  
  bool isvalid_;
};
#endif

---