TElectronIsEMSelector.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
#ifndef __TELECTRONISEMSELECTOR__
#define __TELECTRONISEMSELECTOR__
 
// Include the return object and the base class
#include "PATCore/AcceptInfo.h"
#include "PATCore/AcceptData.h"
#include "ElectronPhotonSelectorTools/egammaPIDdefs.h"
#include "AsgMessaging/AsgMessaging.h"
#include "AsgMessaging/StatusCode.h"
#include <vector>
#include <string>
 
class AsgElectronIsEMSelector;
 
namespace Root {
  class TElectronIsEMSelector : public asg::AsgMessaging
  {
 
    friend class ::AsgElectronIsEMSelector;
 
  public: 
    TElectronIsEMSelector(const char* name="TElectronIsEMSelector");
 
    ~TElectronIsEMSelector();
    
 
    // Main methods
    StatusCode initialize();
 
    asg::AcceptData 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;
 
      asg::AcceptData accept() const { return asg::AcceptData(&m_acceptInfo); }
 
      // 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;
 
 
    // Public members (the cut values)
 
    unsigned int m_isEMMask;
 
    bool m_useTRTOutliers;
    bool m_useTRTXenonHits; 
 
    std::vector<float> m_cutBinEta;
    std::vector<float> m_cutBinET;
    std::vector<float> m_cutF1;
    std::vector<float> m_cutHadLeakage;
    std::vector<float> m_cutReta37;
    std::vector<float> m_cutRphi33;
    std::vector<float> m_cutWeta2c;
    std::vector<float> m_cutDeltaEmax2;
    std::vector<float> m_cutDeltaE;
    std::vector<float> m_cutDEmaxs1;
    std::vector<float> m_cutWtot;
    std::vector<float> m_cutWeta1c;
    std::vector<float> m_cutFracm;
    
    std::vector<float> m_cutF3;
 
    std::vector<int> m_cutBL;
    std::vector<int> m_cutPi;
    std::vector<int> m_cutSi;
    std::vector<float> m_cutA0;
    std::vector<float> m_cutA0Tight;
    std::vector<float> m_cutDeltaEta;
    std::vector<float> m_cutDeltaEtaTight;
    std::vector<float> m_cutminDeltaPhi;
    std::vector<float> m_cutmaxDeltaPhi;
    std::vector<float> m_cutminEp;
    std::vector<float> m_cutmaxEp;
    
    std::vector<float> m_cutBinEta_TRT;
    std::vector<float>  m_cutBinET_TRT;
    std::vector<float> m_cutNumTRT;
    std::vector<float> m_cutTRTRatio;
    std::vector<float> m_cutTRTRatio90;
    std::vector<float> m_cutEProbabilityHT;
 
    const asg::AcceptInfo& getAcceptInfo() const { return m_acceptInfo; }
      
    // Private members
  private:
 
    // would ideally be protected: only to be used by ARASelector
    asg::AcceptData fillAccept(unsigned int isEM) const;
 
    std::vector<int> FindEtEtaBin(double et, double eta2) const;
 
    template<typename T>
    bool CheckVar(const std::vector<T>& vec, int choice) const;
 
    asg::AcceptInfo     m_acceptInfo;
      
    // 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 std::string m_cutNameClusterEtaRange_Electron;
    
    const std::string m_cutNameConversionMatch_Electron;
    
    const std::string m_cutNameClusterHadronicLeakage_Electron;
    const std::string m_cutNameClusterMiddleEnergy_Electron;
    const std::string m_cutNameClusterMiddleEratio37_Electron;
    const std::string m_cutNameClusterMiddleEratio33_Electron;
    const std::string m_cutNameClusterMiddleWidth_Electron;
 
    const std::string m_cutNameClusterBackEnergyFraction_Electron;
 
    const std::string m_cutNameClusterStripsEratio_Electron;
    const std::string m_cutNameClusterStripsDeltaEmax2_Electron;
    const std::string m_cutNameClusterStripsDeltaE_Electron;
    const std::string m_cutNameClusterStripsWtot_Electron;
    const std::string m_cutNameClusterStripsFracm_Electron;
    const std::string m_cutNameClusterStripsWeta1c_Electron;
 
    const std::string m_cutNameClusterStripsDEmaxs1_Electron;
    const std::string m_cutNameTrackBlayer_Electron;
    const std::string m_cutNameTrackPixel_Electron;
    const std::string m_cutNameTrackSi_Electron;
    const std::string m_cutNameTrackA0_Electron;
    const std::string m_cutNameTrackMatchEta_Electron;
    const std::string m_cutNameTrackMatchPhi_Electron;
    const std::string m_cutNameTrackMatchEoverP_Electron;
    const std::string m_cutNameTrackTRTeProbabilityHT_Electron;
    const std::string m_cutNameTrackTRThits_Electron;
    const std::string m_cutNameTrackTRTratio_Electron;
    const std::string m_cutNameTrackTRTratio90_Electron;
 
    const std::string m_cutNameTrackA0Tight_Electron;
    const std::string m_cutNameTrackMatchEtaTight_Electron;
 
    const std::string m_cutNameIsolation_Electron;
    const std::string m_cutNameClusterIsolation_Electron;
    const std::string m_cutNameTrackIsolation_Electron;
 
 
 
  }; // End: class definition
 
} // End: namespace Root
 
#endif