Jet.cxx

Go to the documentation of this file.

// Jet implementation
//

#include "AtlfastEvent/Jet.h"
#include "AtlfastEvent/ReconstructedParticle.h"
#include "AtlfastEvent/ParticleCodes.h"
#include "Navigation/NavigationToken.h"
#include <iomanip>

namespace Atlfast {
  Jet::Jet(const  ICluster& cluster):
    AODNavigationImp(), 

    m_momentum(cluster.momentum()),
    m_pdg_id(ParticleCodes::UQUARK),
    m_tagged(true),
    m_dRbquark(999.),
    m_dRcquark(999.),
    m_dRhadtau(999.){
    
    IAOO* iaoo = this;
    iaoo->associate(&cluster);
    m_clusters.push_back(&cluster);
  }

  Jet::Jet( const HepLorentzVector& vec, ICluster& cluster ): 
    AODNavigationImp(), 
    
    m_momentum(vec), 
    m_pdg_id(ParticleCodes::UQUARK),
    m_tagged(true),
    m_dRbquark(999.),
    m_dRcquark(999.),
    m_dRhadtau(999.){
    // Here we fill the related cells vector with pointers to the cells
    // from which it was constructed.
    IAOO* iaoo = this;
    iaoo->associate( &cluster );
    m_clusters.push_back(&cluster);
  }

  Jet::Jet(const Jet& rhs):
    Atlfast::IAOO(rhs),
    INavigable(rhs),
    I4Momentum(rhs),
    INavigable4Momentum(rhs),
    Atlfast::IKinematic(rhs),
    Atlfast::IAODNavigation(rhs),
    AODNavigationImp(rhs){
    m_momentum = rhs.m_momentum;
    m_pdg_id   = rhs.m_pdg_id;
    m_tagged   = rhs.m_tagged;
    m_dRbquark = rhs.m_dRbquark;
    m_dRcquark = rhs.m_dRcquark;
    m_dRhadtau = rhs.m_dRhadtau;
    m_clusters = rhs.m_clusters;
    m_muons    = rhs.m_muons;
  }
  

  Jet& Jet::operator=(const Jet& rhs){
    if(this == &rhs) return *this;

    AODNavigationImp::operator=(rhs);
    
    m_momentum = rhs.m_momentum;
    m_pdg_id   = rhs.m_pdg_id;
    m_tagged   = rhs.m_tagged;
    m_dRbquark = rhs.m_dRbquark;
    m_dRcquark = rhs.m_dRcquark;
    m_dRhadtau = rhs.m_dRhadtau;
    m_clusters = rhs.m_clusters;
    m_muons    = rhs.m_muons;

    return *this;
  }
    

  void Jet::setMomentum(const HepLorentzVector& vec) {m_momentum=vec;}


  void Jet::addMuon(const ReconstructedParticle* p) {

    m_momentum += p->momentum();
    this->associate(p);
    this->m_muons.push_back(p); 
  }

  HepLorentzVector Jet::momentum() const {return m_momentum; } 
  double  Jet::eta() const { return m_momentum.pseudoRapidity() ;}
  double  Jet::phi() const { return m_momentum.phi() ;  } 
  double  Jet::pT()  const { return m_momentum.perp() ;}
  double  Jet::eT()  const { 
    return m_momentum.e()*m_momentum.perp()/m_momentum.rho() ;} 
  double  Jet::mT()  const { return m_momentum.mt(); } 
  IKinematic* Jet::clone() const{
    IKinematic* ik = new Jet(*this);
    return ik;
  }
  //
  double  Jet::px()  const { return m_momentum.px(); } 
  double  Jet::py()  const { return m_momentum.py(); } 
  double  Jet::pz()  const { return m_momentum.pz(); } 
      
  double  Jet::e()   const { return m_momentum.e(); } 
    
  
  
  // methods to set and get label - the 'true' jet flavour  
  void Jet::setPdg_id(int pdg_id){
    m_pdg_id = pdg_id;
  }

  int Jet::pdg_id() const{
    return m_pdg_id;
  }

  // methods from b-tagging part of AtlfastB
  void Jet::setBTagged(std::string tagname) {
    m_isBTagged[tagname] = true;
    m_tagged=true;
  }

  bool Jet::isBTagged() const {
    return !m_isBTagged.empty();
  }

  bool Jet::isBTagged(std::string tagname) const {
    std::map<std::string,double>::const_iterator itr = m_isBTagged.find(tagname);
    return itr == m_isBTagged.end() ? false : itr->second;
  }

  void Jet::setBTagCorrFactor(std::string tagname, double factor){
    m_bCorrFactors[tagname] = factor;
  }

  double Jet::bTagCorrFactor() const {
    return m_bCorrFactors.empty() ? 0 : (*(m_bCorrFactors.begin())).second;
  }
  
  double Jet::bTagCorrFactor(std::string tagname) const {
    std::map<std::string,double>::const_iterator itr = m_bCorrFactors.find(tagname);
    return itr == m_bCorrFactors.end() ? 0 : itr->second;
  }
  
  void Jet::setLightTagCorrFactor(std::string tagname, double factor){
    m_lCorrFactors[tagname] = factor;
  }

  double Jet::lTagCorrFactor() const {
    return m_lCorrFactors.empty() ? 0 : (*(m_lCorrFactors.begin())).second;
  }
  
  double Jet::lTagCorrFactor(std::string tagname) const {
    std::map<std::string,double>::const_iterator itr = m_lCorrFactors.find(tagname);
    return itr == m_lCorrFactors.end() ? 0 : itr->second;
  }
  
  void Jet::setTauTagged(std::string tagname){
    m_isTauTagged[tagname] = true;
    m_tagged=true;
  }
  
  bool Jet::isTauTagged() const {
    return !m_isTauTagged.empty();
  }
  
  bool Jet::isTauTagged(std::string tagname) const {
    std::map<std::string,double>::const_iterator itr = m_isTauTagged.find(tagname);
    return itr == m_isTauTagged.end() ? false : itr->second;    
  }

  void Jet::setTauTagCorrFactor(std::string tagname, double factor){
    m_tauCorrFactors[tagname] = factor;
    return;
  }

  double Jet::tauTagCorrFactor() const {
    return m_tauCorrFactors.empty() ? 0 : (*(m_tauCorrFactors.begin())).second;
  }
  
  double Jet::tauTagCorrFactor(std::string tagname) const {
    std::map<std::string,double>::const_iterator itr = m_tauCorrFactors.find(tagname);
    return itr == m_tauCorrFactors.end() ? 0 : itr->second;
  }
  
  // Labelling parameter methods
  void Jet::setdRbquark(double dRbquark){
    m_dRbquark = dRbquark;
  }
  
  double Jet::getdRbquark() const {
    return m_dRbquark;
  }

  void Jet::setdRcquark(double dRcquark){
    m_dRcquark = dRcquark;
  }

  double Jet::getdRcquark() const {
    return m_dRcquark;
  }

  void Jet::setdRhadtau(double dRhadtau){
    m_dRhadtau = dRhadtau;
  }

  double Jet::getdRhadtau() const {
    return m_dRhadtau;
  }


  void Jet::print(const std::string& coor, std::string t) const{
    AODNavigationImp::print(coor, t);
    std::cout<<t<<"pdg: "<<std::setw(12)
             <<pdg_id()<<std::string(56,' ')<<"Jet"<<std::endl;
  }
  void Jet::fillToken( INavigationToken &token ) const{
        NavigationToken<I4Momentum>* i4Token =
      dynamic_cast< NavigationToken<I4Momentum>* >(&token);
    if ( i4Token == 0 ) return;
    
    // ask clusters to fill token
    std::vector<const ICluster*>::const_iterator citer = m_clusters.begin();
    for(;citer!=m_clusters.end();++citer){ (*citer)->fillToken(token);}

    // add the muons to the token
    std::vector<const ReconstructedParticle*>::const_iterator miter = 
      m_muons.begin();
    for(;miter!=m_muons.end();++miter){i4Token->setObject((*miter));}
  }
} // end of namespace bracket

---