NtupleReader/NtupleReader/MyParticleJet.ixx

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 24.10.2006, AUTHOR: OLIVER KORTNER
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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

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

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

inline void MyParticleJet::init(const TLorentzVector & p,
                                const int & rec_flag,
                                const int & index,
                                const double & tag_weight,
                                const int & truthflavour,
                                const bool & truthjet_flag,
                                const int & nb_tracks,
                                const std::vector <double> tracks_charge,       
                                const std::vector<TLorentzVector> tracks_tlv,
                                const std::vector<int>    tracks_vertex_index) {

    m_tlv = p;
    m_rec_flag = rec_flag;
    m_index = index;
    m_b_tag_weight = tag_weight;
    m_truthflavour = truthflavour;
    m_matchingflag = 0;
    m_nb_tracks = nb_tracks;
 
    for (unsigned int i=0;i<tracks_charge.size();i++) {
        m_tracks_charge.push_back(tracks_charge[i]);
        m_tracks_tlv.push_back(tracks_tlv[i]);
        m_tracks_vertex_index.push_back(tracks_vertex_index[i]);
    }
        
    if(truthjet_flag){  
        m_type = "truthparticle_jet";
    }
    else{ 
        m_type = "particle_jet";
    }

    m_charge = 0;
    m_pdgId  = 0;
        
    return;

  }

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

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

inline int MyParticleJet::reconstruction_flag(void) const {

    return m_rec_flag;

  }

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

  //:::::::::::::::::::::::::
  //:: METHOD b_tag_weight ::
  //:::::::::::::::::::::::::

inline double MyParticleJet::b_tag_weight(void) const {

    return m_b_tag_weight;

  }

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

  //:::::::::::::::::::::::::
  //:: METHOD truth_flavour ::
  //:::::::::::::::::::::::::

inline int MyParticleJet::truth_flavour(void) const{

    return m_truthflavour;

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

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

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

    m_rec_flag = flag;
    return;

  }

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

  //:::::::::::::::::::::::::::::
  //:: METHOD set_b_tag_weight ::
  //:::::::::::::::::::::::::::::

inline void MyParticleJet::set_b_tag_weight(const double & weight) {

    m_b_tag_weight = weight;
    return;

  }

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

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

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

    return;
  }

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

  //::::::::::::::::::::::
  //:: METHOD nb_tracks ::
  //::::::::::::::::::::::

inline int MyParticleJet::nb_tracks(void) const {

    return m_nb_tracks;

  }

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

  //::::::::::::::::::::::::::
  //:: METHOD tracks_charge ::
  //::::::::::::::::::::::::::

inline double MyParticleJet::tracks_charge(int itrack) const {

    if ( itrack>-1 && itrack<m_nb_tracks ){        
        return m_tracks_charge[itrack]; 
    }else{
        std::cerr<< " tracks_charge - WARNING: track not belonging to Jet\n";
        return -999;
    }
  }


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

  //:::::::::::::::::::::::
  //:: METHOD tracks_tlv ::
  //:::::::::::::::::::::::

inline TLorentzVector MyParticleJet::tracks_tlv(int itrack) const {

    TLorentzVector tmptlv;
    if ( itrack>-1 && itrack<m_nb_tracks ){ 
        return m_tracks_tlv[itrack];
    }else{
        std::cerr<< " tracks_tlv - WARNING: track not belonging to Jet\n";
        return tmptlv;
    }

}

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

  //::::::::::::::::::::::::::::::::
  //:: METHOD tracks_vertex_index ::
  //::::::::::::::::::::::::::::::::

inline int MyParticleJet::tracks_vertex_index(int itrack) const {
    
    if ( itrack>-1 && itrack<m_nb_tracks ){ 
        return m_tracks_vertex_index[itrack];
    }else{
        std::cerr<< " tracks_E - WARNING: track not belonging to Jet\n";
        return -999;
    }
    
}

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

  //:::::::::::::::::::::::::::
  //:: METHOD tracks_ptratio ::
  //:::::::::::::::::::::::::::

inline double MyParticleJet::tracks_ptratio(int vertex_index) const {
    
    double ptsum_vertex = 0.;
    double ptsum_all    = 0.;

    for (int k=0; k<m_nb_tracks; k++) {
        
        ptsum_all += m_tracks_tlv[k].Pt();
        
        if(m_tracks_vertex_index[k]<0){
            continue;
        }

        if(vertex_index<0){
            continue;
        }

        if(m_tracks_vertex_index[k] == vertex_index){
            ptsum_vertex += m_tracks_tlv[k].Pt(); 
        }
    }

    
    double ptratio = 1.;

    if(ptsum_all>0.){
        ptratio = ptsum_vertex/ptsum_all;
    }
    
    return ptratio;
  }

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

  //:::::::::::::::::::::::::::
  //:: METHOD tracks_ptratio ::
  //:::::::::::::::::::::::::::

inline double MyParticleJet::tracks_cmsptratio(int vertex_index) const {
    
    double ptsum_vertex = 0.;
    //double ptsum_all    = 0.;

    for (int k=0; k<m_nb_tracks; k++) {
        
        //ptsum_all += m_tracks_tlv[k].Pt();
        
        if(m_tracks_vertex_index[k]<0){
            continue;
        }

        if(vertex_index<0){
            continue;
        }

        if(m_tracks_vertex_index[k] == vertex_index){
            ptsum_vertex += m_tracks_tlv[k].Pt(); 
        }
    }

    
    double cmsptratio = 1.;

    if(this->tlv().Pt()>0.){
        cmsptratio = ptsum_vertex/this->tlv().Pt();
    }
    
    return cmsptratio;
  }



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

  //::::::::::::::::::::::
  //:: METHOD pt_pucorr ::
  //::::::::::::::::::::::

inline double MyParticleJet::pt_pucorr(int vertex_index) const {

    double pt      = this->tlv().Pt();
    double ptratio = this->tracks_ptratio(vertex_index);
    
    double pt_corr = pt*ptratio;
    
    return pt_corr;
}

---