/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/ElectronPhotonSelectorTools/ElectronPhotonSelectorTools/TElectronIsEMSelector.h

// Dear emacs, this is -*-c++-*-

#ifndef __TELECTRONISEMSELECTOR__
#define __TELECTRONISEMSELECTOR__

// ROOT includes
#include <TString.h>
// Include the return object and the base class
#include "PATCore/TAccept.h"
#include "PATCore/TSelectorToolBase.h"
#include "ElectronPhotonSelectorTools/egammaPIDdefs.h"
#include "AsgTools/AsgMessaging.h"
#include <vector>

class AsgElectronIsEMSelector;

namespace Root {
  class TElectronIsEMSelector : public TSelectorToolBase, public asg::AsgMessaging
  {

    friend class ::AsgElectronIsEMSelector;

  public: 
    TElectronIsEMSelector(const char* name="TElectronIsEMSelector");

    ~TElectronIsEMSelector();
    

    // Main methods
    int initialize();

    inline int finalize() { return 1 ;};

    const Root::TAccept& accept(
                // eta position in second sampling
                float eta2,
                // transverse energy in calorimeter (using eta position in second sampling)
                double et,
                // E(3*3) in 2nd sampling
                float Reta, //e233,
                // E(3*7) in 2nd sampling
                float Rphi, //e237,
                // transverse energy in 1st scintillator of hadronic calorimeter
                float Rhad1, //ethad1,
                // transverse energy in hadronic calorimeter
                float Rhad, //ethad,
                // E(7*7) in 2nd sampling
                float e277,
                // shower width in 3 strips in 1st sampling
                float weta1c,
                // shower width in 2nd sampling
                float weta2c,
                // fraction of energy reconstructed in the 1st sampling
                float f1,
                // E of 2nd max between max and min in strips
                float emax2,
                // E of 1st max in strips
                float Eratio, //emax,
                // E(min) in strips
                float DeltaE, //emin,
                // total shower width in 1st sampling
                float wtot,
                // E(+/-3)-E(+/-1)/E(+/-1)
                float fracm,
                // fraction of energy reconstructed in the 3rd sampling
                float f3,
                                // is effective number of BL hits+outliers at least 1?
                                bool passBLayerRequirement,
                                // number of pixel hits + dead sensors
                                int nPixHitsPlusDeadSensors,
                                // number of silicon hits + dead sensors
                                int nSiHitsPlusDeadSensors,
                // TRT hits
                int nTRThigh,
                int nTRThighOutliers,
                int nTRT,
                int nTRTOutliers,
                int nTRTXenonHits,
                float TRT_PID,
                // transverse impact parameter
                float trackd0,
                // Delta eta,phi matching
                float deltaeta,
                float deltaphi,
                // E/p
                double ep) const;

    // calculate the isEM. (Used internally by accept)
    unsigned int calcIsEm(
              // eta position in second sampling
              float eta2,
              // transverse energy in calorimeter (using eta position in second sampling)
              double et,
              // E(3*3) in 2nd sampling
              float Reta, //e233,
              // E(3*7) in 2nd sampling
              float Rphi, //e237,
              // transverse energy in 1st scintillator of hadronic calorimeter
              float Rhad1, //ethad1,
              // transverse energy in hadronic calorimeter
              float Rhad, //ethad,
              // E(7*7) in 2nd sampling
              float e277,
              // shower width in 3 strips in 1st sampling
              float weta1c,
              // shower width in 2nd sampling
              float weta2c,
              // fraction of energy reconstructed in the 1st sampling
              float f1,
              // E of 2nd max between max and min in strips
              float emax2,
              // E of 1st max in strips
              float Eratio, //emax,
              // E(min) in strips
              float DeltaE, //emin,
              // total shower width in 1st sampling
              float wtot,
              // E(+/-3)-E(+/-1)/E(+/-1)
              float fracm,
              // fraction of energy reconstructed in the 3rd sampling
              float f3,
                          // is effective number of BL hits+outliers at least 1?
                          bool passBLayerRequirement,
                          // number of pixel hits + dead sensors
                          int nPixHitsPlusDeadSensors,
                          // number of silicon hits + dead sensors
                          int nSiHitsPlusDeadSensors,
              // TRT hits
              int nTRThigh,
              int nTRThighOutliers,
              int nTRT,
              int nTRTOutliers,
              int nTRTXenonHits,
              float TRT_PID,
              // transverse impact parameter
              float trackd0,
              // Delta eta,phi matching
              float deltaeta,
              float deltaphi,
              // E/p
              double ep) const;

    // used internally by calcIsEm, but left public because it can be useful for users. Note that
    // it doesn't necessarily zero all the values that pass, so make sure that the input iflag
    // bits that you are concerned with start out with 0.
    unsigned int calocuts_electrons(
                    // eta position in second sampling
                    float eta2,
                    // transverse energy in calorimeter (using eta position in second sampling)
                    double et,
                    // E(3*3) in 2nd sampling
                    float Reta, //e233,
                    // E(3*7) in 2nd sampling
                    float Rphi, //e237,
                    // transverse energy in 1st scintillator of hadronic calorimeter
                    float Rhad1, //ethad1,
                    // transverse energy in hadronic calorimeter
                    float Rhad, //ethad,
                    // E(7*7) in 2nd sampling
                    float e277,
                    // shower width in 3 strips in 1st sampling
                    float weta1c,
                    // shower width in 2nd sampling
                    float weta2c,
                    // fraction of energy reconstructed in the 1st sampling
                    float f1,
                    // E of 2nd max between max and min in strips
                    float emax2,
                    // E of 1st max in strips
                    float Eratio, //emax,
                    // E(min) in strips
                    float DeltaE, //emin,
                    // total shower width in 1st sampling
                    float wtot,
                    // E(+/-3)-E(+/-1)/E(+/-1)
                    float fracm,
                    // fraction of energy reconstructed in the 3rd sampling
                    float f3,
                    // the starting isEM (should be 0 if new)
                    unsigned int iflag,
                                    // trigETthr : threshold in ET to apply the cuts at trigger level
                                    double trigEtTh=0
                    ) const;

    // used internally by calcIsEm, but left public because it can be useful for users. Note that
    // it doesn't necessarily zero all the values that pass, so make sure that the input iflag
    // bits that you are concerned with start out with 0.
    unsigned int TrackCut(  
              // eta of the cluster in the 2nd sampling
              float eta2,
              // transverse energy in calorimeter (using eta position in second sampling)
              double et,
                          // is effective number of BL hits+outliers at least 1?
                          bool passBLayerRequirement,
                          // number of pixel hits + dead sensors
                          int nPixHitsPlusDeadSensors,
                          // number of silicon hits + dead sensors
                          int nSiHitsPlusDeadSensors,
              // TRT hits
              int nTRThigh,
              int nTRThighOutliers,
              int nTRT,
              int nTRTOutliers,
              int nTRTXenonHits,
              float TRT_PID,
              // transverse impact parameter
              float trackd0,
              // Delta eta,phi matching
              float deltaeta,
              float deltaphi,
              // E/p
              double ep,
              unsigned int iflag) const;


    unsigned int isEM() const {return m_isEM; };
    //unsigned int isEMMask() const {return m_isEMMask; } // user should not need this

    // Public members (the cut values)

    unsigned int isEMMask;

    bool useTRTOutliers;
    bool useTRTXenonHits; 

    std::vector<float> CutBinEta;
    std::vector<float> CutBinET;
    std::vector<float> CutF1;
    std::vector<float> CutHadLeakage;
    std::vector<float> CutReta37;
    std::vector<float> CutRphi33;
    std::vector<float> CutWeta2c;
    std::vector<float> CutDeltaEmax2;
    std::vector<float> CutDeltaE;
    std::vector<float> CutDEmaxs1;
    std::vector<float> CutWtot;
    std::vector<float> CutWeta1c;
    std::vector<float> CutFracm;
    
    std::vector<float> CutF3;

    std::vector<int> CutBL;
    std::vector<int> CutPi;
    std::vector<int> CutSi;
    std::vector<float> CutA0;
    std::vector<float> CutA0Tight;
    std::vector<float> CutDeltaEta;
    std::vector<float> CutDeltaEtaTight;
    std::vector<float> CutminDeltaPhi;
    std::vector<float> CutmaxDeltaPhi;
    std::vector<float> CutminEp;
    std::vector<float> CutmaxEp;
    
    std::vector<float> CutBinEta_TRT;
    std::vector<float>  CutBinET_TRT;
    std::vector<float> CutNumTRT;
    std::vector<float> CutTRTRatio;
    std::vector<float> CutTRTRatio90;
    std::vector<float> CutEProbabilityHT;

    // Private members
  private:

    // would ideally be protected: only to be used by ARASelector
    void setIsEM(unsigned int isEM) { m_isEM = isEM; };
    const Root::TAccept& fillAccept() const;

    std::vector<int> FindEtEtaBin(double et, double eta2) const;

    template<typename T>
    bool CheckVar(const std::vector<T>& vec, int choice) const;

    mutable unsigned int m_isEM;

    // the cut positions

    int m_cutPositionClusterEtaRange_Electron;
    
    int m_cutPositionConversionMatch_Electron;
    
    int m_cutPositionClusterHadronicLeakage_Electron;
    int m_cutPositionClusterMiddleEnergy_Electron;
    int m_cutPositionClusterMiddleEratio37_Electron;
    int m_cutPositionClusterMiddleEratio33_Electron;
    int m_cutPositionClusterMiddleWidth_Electron;

    int m_cutPositionClusterBackEnergyFraction_Electron;

    int m_cutPositionClusterStripsEratio_Electron;
    int m_cutPositionClusterStripsDeltaEmax2_Electron;
    int m_cutPositionClusterStripsDeltaE_Electron;
    int m_cutPositionClusterStripsWtot_Electron;
    int m_cutPositionClusterStripsFracm_Electron;
    int m_cutPositionClusterStripsWeta1c_Electron;

    int m_cutPositionClusterStripsDEmaxs1_Electron;
    int m_cutPositionTrackBlayer_Electron;
    int m_cutPositionTrackPixel_Electron;
    int m_cutPositionTrackSi_Electron;
    int m_cutPositionTrackA0_Electron;
    int m_cutPositionTrackMatchEta_Electron;
    int m_cutPositionTrackMatchPhi_Electron;
    int m_cutPositionTrackMatchEoverP_Electron;
    int m_cutPositionTrackTRTeProbabilityHT_Electron;
    int m_cutPositionTrackTRThits_Electron;
    int m_cutPositionTrackTRTratio_Electron;
    int m_cutPositionTrackTRTratio90_Electron;

    int m_cutPositionTrackA0Tight_Electron;
    int m_cutPositionTrackMatchEtaTight_Electron;

    int m_cutPositionIsolation_Electron;
    int m_cutPositionClusterIsolation_Electron;
    int m_cutPositionTrackIsolation_Electron;

    // the cut names

    const TString m_cutNameClusterEtaRange_Electron;
    
    const TString m_cutNameConversionMatch_Electron;
    
    const TString m_cutNameClusterHadronicLeakage_Electron;
    const TString m_cutNameClusterMiddleEnergy_Electron;
    const TString m_cutNameClusterMiddleEratio37_Electron;
    const TString m_cutNameClusterMiddleEratio33_Electron;
    const TString m_cutNameClusterMiddleWidth_Electron;

    const TString m_cutNameClusterBackEnergyFraction_Electron;

    const TString m_cutNameClusterStripsEratio_Electron;
    const TString m_cutNameClusterStripsDeltaEmax2_Electron;
    const TString m_cutNameClusterStripsDeltaE_Electron;
    const TString m_cutNameClusterStripsWtot_Electron;
    const TString m_cutNameClusterStripsFracm_Electron;
    const TString m_cutNameClusterStripsWeta1c_Electron;

    const TString m_cutNameClusterStripsDEmaxs1_Electron;
    const TString m_cutNameTrackBlayer_Electron;
    const TString m_cutNameTrackPixel_Electron;
    const TString m_cutNameTrackSi_Electron;
    const TString m_cutNameTrackA0_Electron;
    const TString m_cutNameTrackMatchEta_Electron;
    const TString m_cutNameTrackMatchPhi_Electron;
    const TString m_cutNameTrackMatchEoverP_Electron;
    const TString m_cutNameTrackTRTeProbabilityHT_Electron;
    const TString m_cutNameTrackTRThits_Electron;
    const TString m_cutNameTrackTRTratio_Electron;
    const TString m_cutNameTrackTRTratio90_Electron;

    const TString m_cutNameTrackA0Tight_Electron;
    const TString m_cutNameTrackMatchEtaTight_Electron;

    const TString m_cutNameIsolation_Electron;
    const TString m_cutNameClusterIsolation_Electron;
    const TString m_cutNameTrackIsolation_Electron;



  }; // End: class definition

} // End: namespace Root

#endif

---