NtupleReader/NtupleReader/MyTrack.ixx

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 22.10.2006, AUTHOR: OLIVER KORTNER
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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

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

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

inline void MyTrack::init(const int & SCThit,
                          const int & Phit,
                          const int & BLayerhit,
                          const int & TRThit,
                          const int & MDThit,
                          const int & CSChit_eta,
                          const int & TGChit_eta,
                          const int & RPChit_eta,
                          const int & CSChit_phi,
                          const int & TGChit_phi,
                          const int & RPChit_phi,
                          const double & d0,
                          const double & z0,
                          const double & chi2,
                          const double & nDoF,
                          const std::vector<double> * trackIsolationEnergy) {

        m_SCThit = SCThit;
        m_Phit = Phit;
        m_BLayerhit = BLayerhit;
        m_TRThit = TRThit;
        m_CSChit_eta = CSChit_eta;
        m_TGChit_eta = TGChit_eta;
        m_RPChit_eta = RPChit_eta;
        m_CSChit_phi = CSChit_phi;
        m_TGChit_phi = TGChit_phi;
        m_RPChit_phi = RPChit_phi;
        m_d0 = d0;
        m_z0 = z0;
        m_chi2 = chi2;
        m_nDoF = nDoF;
        
        if (trackIsolationEnergy!=0) {
            if (trackIsolationEnergy->size()!=5) {
                std::cerr << std::endl
                          << "Class MyTrack, method init: ERROR!\n"
                          << "Wrong dimension of trackIsolationEnergy!\n"
                          << "Size should be 5!\n"
                          << std::endl;
                exit(1);
            }
            for (unsigned int k=0; k<5; k++) {
                m_trackIsolationEnergy[k] = (*trackIsolationEnergy)[k];
            }
        } else {
            for (unsigned int k=0; k<5; k++) {
                m_trackIsolationEnergy[k] = 0;
            }
        }
        return;

}

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

//:::::::::::::::::::
//:: METHOD SCThit ::
//:::::::::::::::::::

inline int MyTrack::SCThit(void) const {

    return m_SCThit;

}

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

//:::::::::::::::::
//:: METHOD Phit ::
//:::::::::::::::::

inline int MyTrack::Phit(void) const {

    return m_Phit;

}

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

//::::::::::::::::::::::
//:: METHOD BLayerhit ::
//::::::::::::::::::::::

inline int MyTrack::BLayerhit(void) const {

    return m_BLayerhit;

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

//:::::::::::::::::::
//:: METHOD TRThit ::
//:::::::::::::::::::

inline int MyTrack::TRThit(void) const {

    return m_TRThit;

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

//:::::::::::::::::::
//:: METHOD MDThit ::
//:::::::::::::::::::

inline int MyTrack::MDThit(void) const {

    return m_MDThit;

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

//:::::::::::::::::::::::
//:: METHOD CSChit_eta ::
//:::::::::::::::::::::::

inline int MyTrack::CSChit_eta(void) const {

    return m_CSChit_eta;

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

//:::::::::::::::::::::::
//:: METHOD TGChit_eta ::
//:::::::::::::::::::::::

inline int MyTrack::TGChit_eta(void) const {

    return m_TGChit_eta;

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

//:::::::::::::::::::::::
//:: METHOD CSChit_phi ::
//:::::::::::::::::::::::

inline int MyTrack::CSChit_phi(void) const {

    return m_CSChit_phi;

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

//:::::::::::::::::::::::
//:: METHOD TGChit_phi ::
//:::::::::::::::::::::::

inline int MyTrack::TGChit_phi(void) const {

    return m_TGChit_phi;

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

//:::::::::::::::::::::::
//:: METHOD RPChit_phi ::
//:::::::::::::::::::::::

inline int MyTrack::RPChit_phi(void) const {

    return m_RPChit_phi;

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

//:::::::::::::::
//:: METHOD d0 ::
//:::::::::::::::

inline double MyTrack::d0(void) const {

    return m_d0;

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

//:::::::::::::::
//:: METHOD z0 ::
//:::::::::::::::

inline double MyTrack::z0(void) const {

    return m_z0;

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

//:::::::::::::::::
//:: METHOD chi2 ::
//:::::::::::::::::

inline double MyTrack::chi2(void) const {

    return m_chi2;

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

//:::::::::::::::::
//:: METHOD nDoF ::
//:::::::::::::::::

inline double MyTrack::nDoF(void) const {

    return m_nDoF;

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

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

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

// CHECK THE INDEX //

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

// RETURN THE REQUESTED TRANSVERSE ENERGY //
    
    return m_trackIsolationEnergy[delta_R_index];

}

---