NtupleReader/NtupleReader/MyElectron.h

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 23.10.2006, AUTHOR: OLIVER KORTNER
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#ifndef MyElectronH
#define MyElectronH

//::::::::::::::::::::::
//:: CLASS MyElectron ::
//::::::::::::::::::::::


//::::::::::::::::::
//:: HEADER FILES ::
//::::::::::::::::::

// standard C++ //
#include <iostream>

// ROOT //
#include "TLorentzVector.h"

// MyParticle base class //
#include "MyParticle.h"

class MyElectron : public MyParticle {

public:
    // Constructors //
    MyElectron(void) {
        init( TLorentzVector(0.0, 0.0, 0.0, 0.0),TLorentzVector(0.0, 0.0, 0.0, 0.0), 
              0.0, false, false, 0.0, 0.0, 0.0, 0, 0, 0.0, 0, -1, 0);
    }
    MyElectron(const TLorentzVector & p,
               const TLorentzVector & p_track,
               const double & echarge,
               const bool & egamma_flag,
               const bool & softe_flag,
               const double & eoverp,
               const double & isem,
               const double & neuralnet,
               const int & index,
               const double et_cone[4],
               const double ethad1,
               const std::vector<double> * et_track_cone=0,
               int vertex_index=-1,
               const std::vector<double> * trackIsolationEnergy=0) {
    
        init(p, p_track, echarge, egamma_flag, softe_flag, eoverp, 
             isem, neuralnet, index, et_cone, ethad1,
             et_track_cone, vertex_index, trackIsolationEnergy);
    }

    // Methods //
    // get methods //
    inline bool e_gamma_flag(void) const;
    inline int is_em(void) const;
    inline double NeuralNet(void) const;
    inline bool soft_e_flag(void) const;
    inline double e_over_p(void) const;
    inline double Et_in_cone(const int & delta_R_index) const;
    inline double ethad1(void) const;

    inline double track_Et_in_cone(const int & delta_r_index) const;
    
    inline double trackIsolationEnergy(const int & delta_r_index) const;

    inline int id_flag(void) const; 

    // set methods //
    inline void set_e_gamma_flag(const bool & flag);
    inline void set_soft_e_flag(const bool & flag);
    inline void set_e_over_p(const double & eoverp);
    inline void set_Et_in_cone(const double et_in_cone[4]);
    inline void set_ethad1(const double & ethad1);
    inline void set_track_Et_in_cone(const double et_in_cone[4]);
    inline void set_trackIsolationEnergy(const double et_in_cone[4]);

    inline void set_id_flag(const int & flag);

    inline void PrintParticle(std::string option = "");
    inline TLorentzVector tlv_track(void) const;
    
    private:
    // electron data //
    bool m_egamma_flag; // m_egamma_flag = true, if author==1, a track is 
    // associated with the electron, a neural-network 
    // output>0.1, and isEM%16==0
    bool m_softe_flag; // m_softe_flag = true, if author==2,  a track is 
    // associated with the electron, and isEM%16==0
    double m_E_over_p; // E(calorimeter)/p(inner tracker)
    int m_isEM;         // isEM variable
    double m_NeuralNet;         // NeuralNet variable (up to 11.x.x this was epiNN)
    double m_Et_in_cone[4]; // transverse energy in a cone around the 
    // electron;
    // m_Et_in_cone[0]: a cone of 0.20,
    // m_Et_in_cone[1]: a cone of 0.30,
    // m_Et_in_cone[2]: a cone of 0.40,
    // m_Et_in_cone[3]: a cone of 0.45
    double m_ethad1; // ethad1

    double m_track_Et_in_cone[4]; // transverse energy of tracks from the
                                  // same vertex in a cone around the 
                                  // electron;
                                  // m_track_Et_in_cone[0]: a cone of 0.20,
                                  // m_track_Et_in_cone[1]: a cone of 0.30,
                                  // m_track_Et_in_cone[2]: a cone of 0.40,
                                  // m_track_Et_in_cone[3]: a cone of 0.45   
    
    double m_trackIsolationEnergy[4]; // transverse energy of tracks 
                                      // m_track_Et_in_cone[0]: a cone of 0.20,
                                      // m_track_Et_in_cone[1]: a cone of 0.30,
                                      // m_track_Et_in_cone[2]: a cone of 0.40,
                                      // m_track_Et_in_cone[3]: a cone of 0.45   


    int m_id_flag; //id flag
    
    TLorentzVector m_tlv_track; //track of the electron
    
    // private methods //
    inline void init(const TLorentzVector & p,
                     const TLorentzVector & p_track,
                     const double & echarge,
                     const bool & egamma_flag,
                     const bool & softe_flag,
                     const double & eoverp,
                     const double & isem,
                     const double & neuralnet,
                     const int & index,
                     const double et_cone[4],
                     const double & ethad1,
                     const std::vector<double> * track_et_cone,
                     int vertex_index,
                     const std::vector<double> * trackIsolationEnergy);
    // initialization method,
    // set the fourmomentum of the electron
    // to p;
    // echarge: charge of the particle
    // egamma_flag = true, if the e-gamma
    // algorithm identified the particle as
    // electron;
    // softe_flag = true, if the particle
    // was identified as soft electron,
    // eoverp = E(calorimeter)/
    //                    p(inner tracker);
    // et_cone[0]: Et in a cone of 0.20,
    // et_cone[1]: Et in a cone of 0.30,
    // et_cone[2]: Et in a cone of 0.40,
    // et_cone[3]: Et in a cone of 0.45
    // ethad1
    // track_et_cone[0]: track Et in a cone
    //                   of 0.20,
    // track_et_cone[1]: track Et in a cone
    //                   of 0.30,
    // track_et_cone[2]: track Et in a cone
    //                   of 0.40,
    // track_et_cone[3]: track Et in a cone
    //                   of 0.45;
    // vertex_index: index of the associated
    //               primary vertex                                

};

//::::::::::::::::::::::::::::::::::::::
//:: IMPLEMENTATION OF INLINE METHODS ::
//::::::::::::::::::::::::::::::::::::::

#include "MyElectron.ixx"

#endif

---