NtupleReader/NtupleReader/MyMuon.ixx

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

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

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

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

inline void MyMuon::init( const TLorentzVector & p,
                          const double & mu_charge,
                          const int & alg_flag,
                          const int & rec_flag,
                          const int & index,
                          const double Et_cone[8],
                          const int nb_tracks_cone[8],
                          const double & fitChi2,
                          const int & fitNumberDoF,
                          const double & fitChi2OverDoF,
                          const double & matchChi2,
                          const int & matchNumberDoF,
                          const double & matchChi2OverDoF,
                          const int & hasCombMuonTrackParticle,
                          const std::vector<double> * track_Et_cone,
                          int vertex_index,
                          const std::vector<double> * trackIsolationEnergy) {

        m_tlv = p;
        m_charge = mu_charge;
        m_alg_flag = alg_flag;
        m_flag = rec_flag;
        m_index = index;
        m_type = "muon";
        m_pdgId = (int)m_charge*-13;
        for (unsigned int k=0; k<8; k++) {
                if (Et_cone!=0) {
                        m_Et_cone[k] = Et_cone[k];
                } else {
                        m_Et_cone[k] = 0.0;     
                }
                if (nb_tracks_cone!=0) {
                        m_nb_tracks_cone[k] = nb_tracks_cone[k];
                } else {
                        m_nb_tracks_cone[k] = 0;
                }
        }
        m_fitChi2 = fitChi2;
        m_fitNumberDoF = fitNumberDoF;
        m_fitChi2OverDoF = fitChi2OverDoF;
        m_matchChi2 = matchChi2;
        m_matchNumberDoF = matchNumberDoF;
        m_matchChi2OverDoF = matchChi2OverDoF;
        
        m_matchingflag = 0;
        
        m_hasCombinedMuonTrackParticle = (bool)hasCombMuonTrackParticle;
        m_vertex_index = vertex_index;
        
        if (track_Et_cone!=0) {
            if (track_Et_cone->size()!=8) {
                std::cerr << std::endl
                          << "Class MyMuon, method init: ERROR!\n"
                          << "Wrong dimension of track_et_cone!\n"
                          << "Size should be 8!\n"
                          << std::endl;
                exit(1);
            }
            for (unsigned int k=0; k<8; k++) {
                m_track_Et_cone[k] = (*track_Et_cone)[k];
            }
        } else {
            for (unsigned int k=0; k<8; k++) {
                m_track_Et_cone[k] = 0;
            }
        }
        if (trackIsolationEnergy!=0) {
            if (trackIsolationEnergy->size()!=8) {
                std::cerr << std::endl
                          << "Class MyMuon, method init: ERROR!\n"
                          << "Wrong dimension of trackIsolationEnergy!\n"
                          << "Size should be 8!\n"
                          << std::endl;
                exit(1);
            }
            for (unsigned int k=0; k<8; k++) {
                m_trackIsolationEnergy[k] = (*trackIsolationEnergy)[k];
            }
        } else {
            for (unsigned int k=0; k<8; k++) {
                m_trackIsolationEnergy[k] = 0;
            }
        }


        return;

}

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

//:::::::::::::::::::::::::::
//:: METHOD algorithm_flag ::
//:::::::::::::::::::::::::::

inline int MyMuon::algorithm_flag(void) const {

    return m_alg_flag;

}

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

//::::::::::::::::::::::::::::::::
//:: METHOD reconstruction_flag ::
//::::::::::::::::::::::::::::::::

inline int MyMuon::reconstruction_flag(void) const {

        return m_flag;

}

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

//:::::::::::::::::::::::::::::::::::::::::
//:: METHOD hasCombinedMuonTrackParticle ::
//:::::::::::::::::::::::::::::::::::::::::

inline bool MyMuon::hasCombinedMuonTrackParticle(void) const {
        return m_hasCombinedMuonTrackParticle;

}

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

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

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

// CHECK THE INDEX //

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

// RETURN THE REQUESTED TRANSVERSE ENERGY //

        return m_Et_cone[delta_R_index];

}

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

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

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

// CHECK THE INDEX //

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

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

}

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

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

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

// CHECK THE INDEX //

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

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

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

//::::::::::::::::::::::::::::::
//:: METHOD nb_tracks_in_cone ::
//::::::::::::::::::::::::::::::

inline int MyMuon::nb_tracks_in_cone(const int & delta_R_index) const {

// CHECK THE INDEX //

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

// RETURN THE REQUESTED TRANSVERSE ENERGY //

        return m_nb_tracks_cone[delta_R_index];

}

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

//::::::::::::::::::::
//:: METHOD fitChi2 ::
//::::::::::::::::::::

inline double MyMuon::fitChi2(void) const {

        return m_fitChi2;

}

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

//:::::::::::::::::::::::::
//:: METHOD fitNumberDoF ::
//:::::::::::::::::::::::::

inline int MyMuon::fitNumberDoF(void) const {

        return m_fitNumberDoF;

}

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

//:::::::::::::::::::::::::::
//:: METHOD  fitChi2OverDoF::
//:::::::::::::::::::::::::::

inline double MyMuon::fitChi2OverDoF(void) const {

        return m_fitChi2OverDoF;

}

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

//::::::::::::::::::::::
//:: METHOD matchChi2 ::
//::::::::::::::::::::::

inline double MyMuon::matchChi2(void) const {

        return m_matchChi2;

}

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

//:::::::::::::::::::::::::::
//:: METHOD matchNumberDoF ::
//:::::::::::::::::::::::::::

inline int MyMuon::matchNumberDoF(void) const {

        return m_matchNumberDoF;

}

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

//:::::::::::::::::::::::::::::
//:: METHOD matchChi2OverDoF ::
//:::::::::::::::::::::::::::::

inline double MyMuon::matchChi2OverDoF(void) const {

        return m_matchChi2OverDoF;

}

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

//::::::::::::::::::::::::::::::::::::
//:: METHOD set_reconstruction_flag ::
//::::::::::::::::::::::::::::::::::::

inline void MyMuon::set_reconstruction_flag(const int & flag) {

        m_flag = flag;
        return;

}

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

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

inline void MyMuon::set_Et_in_cone(const double Et_cone[8]) {

        for (unsigned int k=0; k<8; k++) {
                m_Et_cone[k] = Et_cone[k];
        }

        return;

}

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

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

inline void MyMuon::set_track_Et_in_cone(const double Et_cone[8]) {

        for (unsigned int k=0; k<8; k++) {
                m_track_Et_cone[k] = Et_cone[k];
        }

        return;

}

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

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

inline void MyMuon::set_trackIsolationEnergy(const double Et_cone[8]) {

        for (unsigned int k=0; k<8; k++) {
                m_trackIsolationEnergy[k] = Et_cone[k];
        }

        return;

}

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

//::::::::::::::::::::::::::::::::::
//:: METHOD set_nb_tracks_in_cone ::
//::::::::::::::::::::::::::::::::::

inline void MyMuon::set_nb_tracks_in_cone(const int nb_tracks_cone[8]) {

        for (unsigned int k=0; k<8; k++) {
                m_nb_tracks_cone[k] = nb_tracks_cone[k];
        }

        return;

}

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

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

inline void MyMuon::PrintParticle(std::string option) {


   //  std::cout << "algorithm flag:               " 
//          << Form("%i", this->algorithm_flag()) << std::endl;
//     std::cout << "reco flag, hasCombMuTrkPart:  " 
//          << Form("%i, %i",
//                  this->reconstruction_flag(),
//                  this->hasCombinedMuonTrackParticle() ) << std::endl;
    std::cout << "   alg, rec flag, CombMuTrkPart: " 
         << Form("%i, %i, %i",
                 this->algorithm_flag(),
                 this->reconstruction_flag(),
                 this->hasCombinedMuonTrackParticle() ) << std::endl;
    std::cout << "   fit: chi2, dof, chi2/dof:     "
         << Form("%.2f, %i, %.2f",
                 this->fitChi2(),
                 this->fitNumberDoF(),
                 this->fitChi2OverDoF()) << std::endl;
    std::cout << "   match: chi2, dof, chi2/dof:   "
         << Form("%.2f, %i, %.2f",
                 this->matchChi2(),
                 this->matchNumberDoF(),
                 this->matchChi2OverDoF()) << std::endl;

    
    if (option=="v"){
        std::cout << "   cone:                         " 
                  << "0.1\t  0.2\t  0.3\t  0.4\t  0.45\t  0.5\t  0.6\t  0.7" << std::endl
                  << "   Et:                           "
                  << Form("%.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f\t %.2f",
                          this->Et_in_cone(0),
                          this->Et_in_cone(1),
                          this->Et_in_cone(2),
                          this->Et_in_cone(3),
                          this->Et_in_cone(4),
                          this->Et_in_cone(5),
                          this->Et_in_cone(6),
                          this->Et_in_cone(7) ) 
                  << std::endl;
        std::cout << "   n_trk:                        "
                  << Form("%i\t  %i\t  %i\t  %i\t  %i\t  %i\t  %i\t  %i",
                          this->nb_tracks_in_cone(0),
                          this->nb_tracks_in_cone(1),
                          this->nb_tracks_in_cone(2),
                          this->nb_tracks_in_cone(3),
                          this->nb_tracks_in_cone(4),
                          this->nb_tracks_in_cone(5),
                          this->nb_tracks_in_cone(6),
                          this->nb_tracks_in_cone(7) ) 
                  << std::endl;
    }
    
    return;
}

---