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

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

#ifndef __TPHOTONISEMSELECTOR__
#define __TPHOTONISEMSELECTOR__

// 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 AsgPhotonIsEMSelector;

namespace Root {
  class TPhotonIsEMSelector : public TSelectorToolBase,public asg::AsgMessaging
  {
    
    friend class ::AsgPhotonIsEMSelector;
    

  public: 
    TPhotonIsEMSelector(const char* name="TPhotonIsEMSelector");
    
    ~TPhotonIsEMSelector();

    // 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,
                // transverse energy in 1st scintillator of hadronic calorimeter/ET
                float Rhad1,
                // transverse energy in hadronic calorimeter/ET
                float Rhad,
                // E(7*7) in 2nd sampling
                float e277,
                // E(3*7)/E(7*7) in 2nd sampling
                float Reta,
                // E(3*3)/E(3*7) in 2nd sampling
                float Rphi,
                // shower width in 2nd sampling
                float weta2c,
                // fraction of energy reconstructed in strips
                float f1,
                // (E of 1st max in strips-E of 2nd max)/(E of 1st max+E of 2nd max)
                float Eratio,
                // E(2nd max)-E(min) in strips
                float DeltaE,
                //  E of 2nd max between max and min in strips
                // float emax2,
                // shower width in 3 strips in 1st sampling
                float weta1c,
                // total shower width in strips
                float wtot,
                // E(+/-3)-E(+/-1)/E(+/-1)
                float fracm,
                // fraction of energy reconstructed in the 3rd sampling
                float f3,
                // E/p
                double ep,
                // is it a conversion
                bool isConversion) ;

    // 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,
              // transverse energy in 1st scintillator of hadronic calorimeter/ET
              float Rhad1,
              // transverse energy in hadronic calorimeter/ET
              float Rhad,
              // E(7*7) in 2nd sampling
              float e277,
              // E(3*7)/E(7*7) in 2nd sampling
              float Reta,
              // E(3*3)E(3*7) in 2nd sampling
              float Rphi,
              // shower width in 2nd sampling
              float weta2c,
              // fraction of energy reconstructed in strips
              float f1,
              // (E of 1st max in strips-E of 2nd max)/(E of 1st max+E of 2nd max)
              float Eratio,
              // E(2nd max)-E(min) in strips
              float DeltaE,
              // shower width in 3 strips in 1st sampling
              //  E of 2nd max between max and min in strips
              // shower width in 3 strips in 1st sampling
              float weta1c,
              // total shower width in strips
              float wtot,
              // E(+/-3)-E(+/-1)/E(+/-1)
              float fracm,
              // fraction of energy reconstructed in the 3rd sampling
              float f3,
              // E/p
              double ep,
              // is it a conversion
              bool isConversion ) const ;

    unsigned int calocuts_photonsConverted(
                       // eta position in second sampling
                       float eta2,
                       // transverse energy in calorimeter 
                       double et,
                       // hadronic leakage ratios
                       float Rhad1,
                       float Rhad,
                       // E(7*7) in 2nd sampling
                       float e277,
                       // ratios
                       float Reta,
                       float Rphi,
                       // shower width in 2nd sampling
                       float weta2c,
                       // fraction of energy reconstructed in strips
                       float f1,
                       // (Emax1-Emax2)/(Emax1+Emax2)
                       float Eratio,
                       // difference of energy between max and min
                       float DeltaE,
                       // parametrization of E(2nd max)
                       //float deltaemax2,
                       // shower width in 3 strips in 1st sampling
                       float weta1c,
                       // total shower width in strips
                       float wtot,
                       // E(+/-3)-E(+/-1)/E(+/-1)
                       float fracm,
                       // fraction of energy reconstructed in the 3rd sampling
                       float f3,
                       // E/p
                       double ep,
                       unsigned int iflag) const;

    unsigned int calocuts_photonsNonConverted(
                          // eta position in second sampling
                          float eta2,
                          // transverse energy in calorimeter 
                          double et,
                          // hadronic leakage ratios
                          float Rhad1,
                          float Rhad,
                          // E(7*7) in 2nd sampling
                          float e277,
                          // ratios
                          float Reta,
                          float Rphi,
                          // shower width in 2nd sampling
                          float weta2c,
                          // fraction of energy reconstructed in strips
                          float f1,
                          // (Emax1-Emax2)/(Emax1+Emax2)
                          float Eratio,
                          // difference of energy between max and min
                          float DeltaE,
                          // parametrization of E(2nd max)
                          //float deltaemax2,
                          // shower width in 3 strips in 1st sampling
                          float weta1c,
                          // total shower width in strips
                          float wtot,
                          // E(+/-3)-E(+/-1)/E(+/-1)
                          float fracm,
                          // fraction of energy reconstructed in the 3rd sampling
                          float f3,
                          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 forceConvertedPhotonPID;
    bool forceNonConvertedPhotonPID;

    
    //
    // selection for non-converted photons
    //
    std::vector<float> CutBinEta_photonsNonConverted;
    std::vector<float> CutBinEnergy_photonsNonConverted;
    std::vector<float> e277_photonsNonConverted;
    std::vector<float> CutHadLeakage_photonsNonConverted;
    std::vector<float> Reta37_photonsNonConverted;
    std::vector<float> Rphi33_photonsNonConverted;
    std::vector<float> weta2_photonsNonConverted;
    
    std::vector<float> CutBinEtaStrips_photonsNonConverted;
    std::vector<float> CutBinEnergyStrips_photonsNonConverted;
    std::vector<float> f1_photonsNonConverted;
    // std::vector<float> emax2r_photonsNonConverted;
    std::vector<float> deltae_photonsNonConverted;
    std::vector<float> DEmaxs1_photonsNonConverted;
    std::vector<float> wtot_photonsNonConverted;
    std::vector<float> fracm_photonsNonConverted;
    std::vector<float> w1_photonsNonConverted;
    std::vector<float> CutF3_photonsNonConverted;

    //
    // selection for converted photons
    //
    std::vector<float> CutBinEta_photonsConverted;
    std::vector<float> CutBinEnergy_photonsConverted;
    std::vector<float> e277_photonsConverted;
    std::vector<float> CutHadLeakage_photonsConverted;
    std::vector<float> Reta37_photonsConverted;
    std::vector<float> Rphi33_photonsConverted;
    std::vector<float> weta2_photonsConverted;
    
    std::vector<float> CutBinEtaStrips_photonsConverted;
    std::vector<float> CutBinEnergyStrips_photonsConverted;
    std::vector<float> f1_photonsConverted;
    // std::vector<float> emax2r_photonsConverted;
    std::vector<float> deltae_photonsConverted;
    std::vector<float> DEmaxs1_photonsConverted;
    std::vector<float> wtot_photonsConverted;
    std::vector<float> fracm_photonsConverted;
    std::vector<float> w1_photonsConverted;
    std::vector<float> CutminEp_photonsConverted;
    std::vector<float> CutmaxEp_photonsConverted;
    std::vector<float> CutF3_photonsConverted;



    // 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();

    bool CheckVar(std::vector<float> vec, int choice) const;
    bool CheckVar(std::vector<int> vec, int choice) const;

    unsigned int m_isEM;

    // the cut positions

    int m_cutPositionClusterEtaRange_Photon;
    int m_cutPositionClusterBackEnergyFraction_Photon;
    int m_cutPositionClusterHadronicLeakage_Photon;
    int m_cutPositionClusterMiddleEnergy_Photon;
    int m_cutPositionClusterMiddleEratio37_Photon;
    int m_cutPositionClusterMiddleEratio33_Photon;
    int m_cutPositionClusterMiddleWidth_Photon;
    int m_cutPositionClusterStripsEratio_Photon;
    // int m_cutPositionClusterStripsDeltaEmax2_Photon;
    int m_cutPositionClusterStripsDeltaE_Photon;
    int m_cutPositionClusterStripsWtot_Photon;
    int m_cutPositionClusterStripsFracm_Photon;
    int m_cutPositionClusterStripsWeta1c_Photon;
    int m_cutPositionClusterStripsDEmaxs1_Photon;
    int m_cutPositionTrackMatchEoverP_Photon;
    int m_cutPositionAmbiguityResolution_Photon;
    int m_cutPositionIsolation_Photon;
    int m_cutPositionClusterIsolation_Photon;
    int m_cutPositionTrackIsolation_Photon;

    // the cut names

    const TString m_cutNameClusterEtaRange_Photon;
    const TString m_cutNameClusterBackEnergyFraction_Photon;
    const TString m_cutNameClusterHadronicLeakage_Photon;
    const TString m_cutNameClusterMiddleEnergy_Photon;
    const TString m_cutNameClusterMiddleEratio37_Photon;
    const TString m_cutNameClusterMiddleEratio33_Photon;
    const TString m_cutNameClusterMiddleWidth_Photon;
    const TString m_cutNameClusterStripsEratio_Photon;
    // const TString m_cutNameClusterStripsDeltaEmax2_Photon;
    const TString m_cutNameClusterStripsDeltaE_Photon;
    const TString m_cutNameClusterStripsWtot_Photon;
    const TString m_cutNameClusterStripsFracm_Photon;
    const TString m_cutNameClusterStripsWeta1c_Photon;
    const TString m_cutNameClusterStripsDEmaxs1_Photon;
    const TString m_cutNameTrackMatchEoverP_Photon;
    const TString m_cutNameAmbiguityResolution_Photon;
    const TString m_cutNameIsolation_Photon;
    const TString m_cutNameClusterIsolation_Photon;
    const TString m_cutNameTrackIsolation_Photon;

  }; // End: class definition

} // End: namespace Root

#endif 

---