NtupleReader/NtupleReader/MyEvent.ixx

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

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

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

inline void MyEvent::init(const int & run_nb,
                          const int & event_nb,
                          const double & ev_weight,
                          const std::vector<MyParticle*> & rec_electron,
                          const std::vector<MyParticle*> & rec_photon,
                          const std::vector<MyParticle*> & rec_muon,
                          const std::vector<MyParticle*> & rec_jet,
                          const std::vector<MyParticle*> & rec_taujet,
                          const std::vector<MyParticle*> & truth_particle,
                          const std::vector<MyParticle*> & truth_jet, 
                          const MyMissingEtManager & met_manager,
                          const MyTrigger & trigger,
                           std::vector<MyParticle*> * track_jet,
                           std::vector<MyParticle*> * tracks,
                           std::vector<MyParticle*> * truth_track_jet,
                          const std::vector<MyVertex*> * vertices,
                          const std::vector<MyVertex*> * truth_vertices,
                          const std::vector<MyParticle*> * trigger_muon) {

    m_run_nb = run_nb;
    m_event_nb = event_nb;
    m_event_weight = ev_weight;
    m_rec_electron = rec_electron;
    m_rec_photon = rec_photon;
    m_rec_muon = rec_muon;
    m_rec_jet = rec_jet;
    m_rec_taujet = rec_taujet;
    m_truth_particle = truth_particle;
    m_truth_jet = truth_jet;
    m_met_manager = met_manager;
    m_trigger = trigger;
    m_trigger_muon = trigger_muon;
    m_vertices = vertices;
    m_truth_vertices = truth_vertices;
    m_track_jet = track_jet;
    m_tracks = tracks;
    m_truth_track_jet = truth_track_jet;
    
    m_dataset_info = &MyDatasetInfo::Instance();

    return;

  }

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

  //:::::::::::::::::::::::
  //:: METHOD run_number ::
  //:::::::::::::::::::::::

inline int MyEvent::run_number(void) const {

    return m_run_nb;

  }

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

  //:::::::::::::::::::::::::
  //:: METHOD event_number ::
  //:::::::::::::::::::::::::

inline int MyEvent::event_number(void) const {

    return m_event_nb;

  }

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

  //:::::::::::::::::::::::::
  //:: METHOD event_weight ::
  //:::::::::::::::::::::::::

inline double MyEvent::event_weight(void) const {

    return m_event_weight;

  }

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

  //:::::::::::::::::::::::::::
  //:: METHOD reco_electrons ::
  //:::::::::::::::::::::::::::

inline std::vector<MyParticle*> MyEvent::reco_electrons(void) const {

    return m_rec_electron;

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

  //:::::::::::::::::::::::::::
  //:: METHOD reco_photons ::
  //:::::::::::::::::::::::::::

inline std::vector<MyParticle*> MyEvent::reco_photons(void) const {

    return m_rec_photon;

  }

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

  //:::::::::::::::::::::::
  //:: METHOD reco_muons ::
  //:::::::::::::::::::::::

  // inline std::vector<MyParticle*> MyEvent::reco_muons(void) const {

  //    return m_rec_muon;

  // }


inline std::vector<MyParticle*> 
MyEvent::reco_muons(int alg_flag) const {

    if(alg_flag==-1){
        return m_rec_muon;
    }
    
    std::vector<MyParticle*> return_vector(0);
    
    for (unsigned int k=0; k<m_rec_muon.size(); k++) {
        
        if( ((MyMuon*)(m_rec_muon[k]))->algorithm_flag() == alg_flag ){
            return_vector.push_back(m_rec_muon[k]);
        }
    }
    
    return return_vector;

  }

inline std::vector<MyParticle*> 
MyEvent::reco_muons(std::string alg_string) const {

    std::vector<MyParticle*> return_vector(0);

    //AtlFast
    if(m_dataset_info->get_AtlFastFlag()){
        
        return_vector = this->reco_muons(1);
    }
    else{

        //default
        if(alg_string=="default"){
            return_vector = this->reco_muons(3);
        }
        else if(alg_string=="all"){
            return_vector = this->reco_muons(-1);
        }
        else if(alg_string=="atlfast"){
            return_vector = this->reco_muons(1);
        }
        else if(alg_string=="muid"){
            return_vector = this->reco_muons(2);
        }
        else if(alg_string=="staco"){
            return_vector = this->reco_muons(3); 
        }
        else{
            std::cerr << "In MyEvent: Muons with name \"" << alg_string 
                      << "\" not known!" 
                      << std::endl;
            exit(1);
        }

    }

    return return_vector;

}


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

  //::::::::::::::::::::::
  //:: METHOD reco_jets ::
  //::::::::::::::::::::::

inline std::vector<MyParticle*> MyEvent::reco_jets(void) const {

    return m_rec_jet;

  }

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

  //::::::::::::::::::::::
  //:: METHOD reco_jets ::
  //::::::::::::::::::::::

inline std::vector<MyParticle*> MyEvent::reco_taujets(void) const {

    return m_rec_taujet;

  }

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

  //::::::::::::::::::::::::::::
  //:: METHOD truth_electrons ::
  //::::::::::::::::::::::::::::

inline std::vector<MyParticle*> MyEvent::truth_particles(void) const {

    return m_truth_particle;
    
  }

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

  //:::::::::::::::::::::::
  //:: METHOD truth_jets ::
  //:::::::::::::::::::::::

inline std::vector<MyParticle*> MyEvent::truth_jets(void) const {

    return m_truth_jet;

  }


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

  //::::::::::::::::::::::::
  //:: METHOD met_manager ::
  //::::::::::::::::::::::::

inline MyMissingEtManager MyEvent::met_manager(void) const {
    
    return m_met_manager;
    
  }

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

  //::::::::::::::::::::
  //:: METHOD trigger ::
  //::::::::::::::::::::

inline MyTrigger MyEvent::trigger(void) const {

    return m_trigger;

  }

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

//:::::::::::::::::::::::::
//:: METHOD trigger_muon ::
//:::::::::::::::::::::::::

inline const std::vector<MyParticle*> * MyEvent::trigger_muon(void) const {

    return m_trigger_muon;

}

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

//:::::::::::::::::::::::::::::
//:: METHOD primary_vertices ::
//:::::::::::::::::::::::::::::

inline const std::vector<MyVertex*> * MyEvent::primary_vertices(void) const {

    return m_vertices;

}

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

//:::::::::::::::::::::::::::
//:: METHOD truth_vertices ::
//:::::::::::::::::::::::::::

inline const std::vector<MyVertex*> * MyEvent::truth_vertices(void) const {

    return m_truth_vertices;

}

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

//:::::::::::::::::::::::
//:: METHOD track_jets ::
//:::::::::::::::::::::::

inline std::vector<MyParticle*> * MyEvent::track_jets(void) const {

    return m_track_jet;

}

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

//:::::::::::::::::::::::
//:: METHOD tracks ::
//:::::::::::::::::::::::

inline std::vector<MyParticle*> * MyEvent::tracks(void) const {

    return m_tracks;

}

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

//:::::::::::::::::::::::::::::
//:: METHOD truth_track_jets ::
//:::::::::::::::::::::::::::::

inline std::vector<MyParticle*> * MyEvent::truth_track_jets(void) const {

    return m_truth_track_jet;

}

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

  //::::::::::::::::::
  //:: METHOD Print ::
  //::::::::::::::::::

inline void MyEvent::Print(std::string option) const {
          
    std::cout << std::endl
              << "event, weight, run:              "
              << Form("%i, %.2f, %i", 
                      this->event_number(), 
                      this->event_weight(), 
                      this->run_number() ) 
              << std::endl;

    std::cout << " nb_reco_electrons:              " 
              << this->reco_electrons().size() << std::endl; 
    MyTools::PrintVector(this->reco_electrons(), option);
    
    std::cout << " nb_reco_photons:              " 
              << this->reco_photons().size() << std::endl; 
    MyTools::PrintVector(this->reco_photons(), option);
    
    std::cout << " nb_reco_muons:                  " 
              << this->reco_muons().size() << std::endl; 
    MyTools::PrintVector(this->reco_muons("all"), option);
    
    std::cout << " nb_reco_jets:                   " 
              << this->reco_jets().size() << std::endl;
    MyTools::PrintVector(this->reco_jets(), option);
    
    std::cout << " nb_reco_taujets:                " 
              << this->reco_taujets().size() << std::endl;
    MyTools::PrintVector(this->reco_taujets(), option);
   
    std::cout << " nb_truth_jets:                  " 
              << this->truth_jets().size() << std::endl;
    MyTools::PrintVector(this->truth_jets(), option);
    
    if(option=="v"){
        std::cout << " nb_truth_particles:         " 
                  << this->truth_particles().size() << std::endl;
        MyTools::PrintVector(this->truth_particles(), option);
    }
    
    this->met_manager().Print(option);
    

    return;

  }

---