NtupleReader/NtupleReader/MyElectron.ixx

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

//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
//:: IMPLEMENTATION OF INLINE METHODS DEFINED IN THE CLASS MyElectron ::
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

//*****************************************************************************

  //:::::::::::::::::
  //:: METHOD init ::
  //:::::::::::::::::

inline void MyElectron::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) {

    m_tlv = p;
    m_tlv_track = p_track;
    m_charge = echarge;
    m_egamma_flag = egamma_flag;
    m_softe_flag = softe_flag;
    m_E_over_p = eoverp;
    m_isEM = (int)isem;
    m_NeuralNet = neuralnet;
    m_index = index;
    m_type = "electron";
    m_pdgId = (int)m_charge*-11;
    for (unsigned int k=0; k<4; k++) {
        if (et_cone!=0) {
            m_Et_in_cone[k] = et_cone[k];
        } else {
            m_Et_in_cone[k] = 0.0;
        }
    }
    m_matchingflag = 0;
    m_ethad1 = ethad1;
    m_vertex_index = vertex_index;

    if (track_et_cone!=0) {
        if (track_et_cone->size()!=4) {
            std::cerr << std::endl
                      << "Class MyElectron, method init: ERROR!\n"
                      << "Wrong dimension of track_et_cone!\n"
                      << "Size should be 4!\n"
                      << std::endl;
            exit(1);
        }
        m_track_Et_in_cone[0] = (*track_et_cone)[0];
        m_track_Et_in_cone[1] = (*track_et_cone)[1];
        m_track_Et_in_cone[2] = (*track_et_cone)[2];
        m_track_Et_in_cone[3] = (*track_et_cone)[3];
    } else {
        m_track_Et_in_cone[0] = 0;
        m_track_Et_in_cone[1] = 0;
        m_track_Et_in_cone[2] = 0;
        m_track_Et_in_cone[3] = 0;
    }
    if (trackIsolationEnergy!=0) {
        if (trackIsolationEnergy->size()!=4) {
            std::cerr << std::endl
                      << "Class MyElectron, method init: ERROR!\n"
                      << "Wrong dimension of trackIsolationEnergy!\n"
                      << "Size should be 4!\n"
                      << std::endl;
            exit(1);
        }
        m_trackIsolationEnergy[0] = (*trackIsolationEnergy)[0];
        m_trackIsolationEnergy[1] = (*trackIsolationEnergy)[1];
        m_trackIsolationEnergy[2] = (*trackIsolationEnergy)[2];
        m_trackIsolationEnergy[3] = (*trackIsolationEnergy)[3];
    } else {
        m_trackIsolationEnergy[0] = 0;
        m_trackIsolationEnergy[1] = 0;
        m_trackIsolationEnergy[2] = 0;
        m_trackIsolationEnergy[3] = 0;
    }

    m_id_flag = -1;

    return;

  }

//*****************************************************************************

  //:::::::::::::::::::::::::
  //:: METHOD e_gamma_flag ::
  //:::::::::::::::::::::::::

inline bool MyElectron::e_gamma_flag(void) const {

    return m_egamma_flag;

  }

//*****************************************************************************

  //::::::::::::::::::
  //:: METHOD is_em ::
  //::::::::::::::::::

inline int MyElectron::is_em(void) const {

    return m_isEM;

  }
//*****************************************************************************

  //::::::::::::::::::::::
  //:: METHOD NeuralNet ::
  //::::::::::::::::::::::

inline double MyElectron::NeuralNet(void) const {

    return m_NeuralNet;

  }
//*****************************************************************************

  //::::::::::::::::::::::::
  //:: METHOD soft_e_flag ::
  //::::::::::::::::::::::::

inline bool MyElectron::soft_e_flag(void) const {

    return m_softe_flag;

  }

//*****************************************************************************

  //:::::::::::::::::::::
  //:: METHOD e_over_p ::
  //:::::::::::::::::::::

inline double MyElectron::e_over_p(void) const {

    return m_E_over_p;

  }

//*****************************************************************************

  //:::::::::::::::::::::::
  //:: METHOD Et_in_cone ::
  //:::::::::::::::::::::::

inline double MyElectron::Et_in_cone(const int & delta_R_index) const {

    // CHECK INDEX //

    if (delta_R_index<0 || delta_R_index>4) {
        std::cerr << "\n"
                  << "Class MyElectron, method Et_in_cone: ERROR!\n"
                  << "Wrong delta_R_index " << delta_R_index
                  << ", must be >=0 and <=3.\n";
        exit(1);
    }

    // RETURN THE REQUESTED ENERGY //

    return m_Et_in_cone[delta_R_index];

  }

//*****************************************************************************

  //:::::::::::::::::::
  //:: METHOD ethad1 ::
  //:::::::::::::::::::

inline double MyElectron::ethad1(void) const {

    return m_ethad1;

  }


//*****************************************************************************

//:::::::::::::::::::::::::::::
//:: METHOD track_Et_in_cone ::
//:::::::::::::::::::::::::::::

inline double MyElectron::track_Et_in_cone(const int & delta_R_index) const {

// CHECK INDEX //

    if (delta_R_index<0 || delta_R_index>4) {
        std::cerr << "\n"
                  << "Class MyElectron, "
                  << "method track_Et_in_cone: ERROR!\n"
                  << "Wrong delta_R_index " << delta_R_index
                  << ", must be >=0 and <=3.\n";
        exit(1);
    }
    
// RETURN THE REQUESTED ENERGY //

    return m_track_Et_in_cone[delta_R_index];

}

//*****************************************************************************

//:::::::::::::::::::::::::::::::::
//:: METHOD trackIsolationEnergy ::
//:::::::::::::::::::::::::::::::::

inline double MyElectron::trackIsolationEnergy(const int & delta_R_index) const {

// CHECK INDEX //

    if (delta_R_index<0 || delta_R_index>4) {
        std::cerr << "\n"
                  << "Class MyElectron, "
                  << "method trackIsolationEnergy: ERROR!\n"
                  << "Wrong delta_R_index " << delta_R_index
                  << ", must be >=0 and <=3.\n";
        exit(1);
    }
    
// RETURN THE REQUESTED ENERGY //

    return m_trackIsolationEnergy[delta_R_index];

}

//*****************************************************************************

  //::::::::::::::::::::
  //:: METHOD id_flag ::
  //::::::::::::::::::::

inline int MyElectron::id_flag(void) const {

    return m_id_flag;

  }

//*****************************************************************************

  //:::::::::::::::::::::::::::::
  //:: METHOD set_e_gamma_flag ::
  //:::::::::::::::::::::::::::::

inline void MyElectron::set_e_gamma_flag(const bool & flag) {

    m_egamma_flag = flag;
    return;

  }

//*****************************************************************************

  //::::::::::::::::::::::::::::
  //:: METHOD set_soft_e_flag ::
  //::::::::::::::::::::::::::::

inline void MyElectron::set_soft_e_flag(const bool & flag) {

    m_softe_flag = flag;
    return;

  }

//*****************************************************************************

  //::::::::::::::::::
  //:: set_e_over_p ::
  //::::::::::::::::::

inline void MyElectron::set_e_over_p(const double & eoverp) {

    m_E_over_p = eoverp;
    return;

  }

//*****************************************************************************

  //:::::::::::::::::::::::::::
  //:: METHOD set_Et_in_cone ::
  //:::::::::::::::::::::::::::

inline void MyElectron::set_Et_in_cone(const double et_in_cone[4]) {

    for (int k=0; k<4; k++) {
        m_Et_in_cone[k] = et_in_cone[k];
    }

    return;

  }

//*****************************************************************************

  //::::::::::::::::
  //:: set_ethad1 ::
  //::::::::::::::::

inline void MyElectron::set_ethad1(const double & ethad1) {

    m_ethad1 = ethad1;
    return;

  }


//*****************************************************************************

//:::::::::::::::::::::::::::::::::
//:: METHOD set_track_Et_in_cone ::
//:::::::::::::::::::::::::::::::::

inline void MyElectron::set_track_Et_in_cone(const double et_in_cone[4]) {

    for (int k=0; k<4; k++) {
        m_track_Et_in_cone[k] = et_in_cone[k];
    }
    
    return;
    
  }

//*****************************************************************************

//:::::::::::::::::::::::::::::::::::::
//:: METHOD set_trackIsolationEnergy ::
//:::::::::::::::::::::::::::::::::::::

inline void MyElectron::set_trackIsolationEnergy(const double et_in_cone[4]) {

    for (int k=0; k<4; k++) {
        m_trackIsolationEnergy[k] = et_in_cone[k];
    }
    
    return;
    
  }

//*****************************************************************************

  //::::::::::::::::::::::::
  //:: METHOD set_id_flag ::
  //::::::::::::::::::::::::

inline void MyElectron::set_id_flag(const int & flag) {

    m_id_flag = flag;
    return;

  }

//*****************************************************************************

  //::::::::::::::::::::::::::
  //:: METHOD PrintParticle ::
  //::::::::::::::::::::::::::

inline void MyElectron::PrintParticle(std::string option) {
    
    if(option=="v"){
        std::cout << "   ethad1:                       " 
                  << m_ethad1 << std::endl;
    }
    
    return;
  }

//*****************************************************************************

//::::::::::::::::::::
//:: METHOD p_track ::
//::::::::::::::::::::

inline TLorentzVector MyElectron::tlv_track(void) const {

    return m_tlv_track;

}

---