MyHtoWWAnalysis/MyHtoWWAnalysis/MyHtoWWAnalysis.h

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 03/2007, AUTHOR: STEFFEN KAISER
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#ifndef MyHtoWWAnalysisH
#define MyHtoWWAnalysisH

//:::::::::::::::::::::::::::::
//:: CLASS MyAnalysisExample ::
//:::::::::::::::::::::::::::::



//::::::::::::::::::
//:: HEADER FILES ::
//::::::::::::::::::
#include <iostream>
#include <fstream>

// ROOT //
#include "TFile.h"
#include "TTree.h"
#include "TH1.h"
#include "TH2.h"
#include "TNtuple.h"
#include "TLorentzVector.h"
#include "TVectorT.h"

// analysis base class //
#include "NtupleReader/MyAnalysis.h"

// NtupleReader //
#include "NtupleReader/MyParticlePair.h"
#include "NtupleReader/MyParticle.h"
#include "NtupleReader/MyTextFileReader.h"
#include "NtupleReader/MyTools.h"
#include "NtupleReader/MyDatasetInfo.h"
#include "NtupleReader/MyTruthParticleManager.h"
#include "NtupleReader/MyCollinearApproximation.h"
#include "NtupleReader/MyVBFCandidate.h"
#include "NtupleReader/MyTrigger.h"
#include "NtupleReader/MyVertex.h"

class MyHtoWWAnalysis : public MyAnalysis {

 public:
    // Constructors //
    MyHtoWWAnalysis(void) {
        init();
    }

    ~MyHtoWWAnalysis(void) {
        destruct();
    }

    // Methods //
    void initialize(void);
    void analyse_event(const MyEvent & event);
    void end_of_analysis(void);

        
    TString filename;   // name of ROOT file
    TString outputpath; // path of the outputfile
    TString addon;      // filename addon
    bool overwrite;     // if true: if file exists overwrite 
    TString m_cutfile;    // name of cut value definition file
    TString m_cutstring;  // string with cuts to be applied separated by ','

    TString m_decay_mode;

 private:

    // objects //

    MyTools m_tools;
    MyTruthParticleManager m_truth_manager;

    MyMissingEt truth_missinget;
    

    // counter //
        
    //int nb_multiple_matchedparticles;
    //int nb_foundoverlaps;

    // ROOT file //
  
    TFile *m_tfile;    // ROOT file
    TTree *m_config_tree;
    TTree *m_cut_order_tree;

    //TDirectory *dir_cut_info;
    //TTree *tree_cut_order;
    
    // histograms //
   
    #include "HtoWWHistos.h"


    // variables //

    static const double invGeV = 1.;
    static const double GeV    = 1.;

    static const int nb_cuts_max = 25;

    std::string m_generator;
    double weight;
    int m_release;

    int m_event;
    int m_entry;
    
    Bool_t m_AtlFastFlag;
    Bool_t m_1mmFix_flag;
    Bool_t m_trackjet_flag;

    Int_t nb_cuts;
    Int_t nb_cuts_applied;
    
    TString cuts[nb_cuts_max];
    Int_t   nb_events[nb_cuts_max];
    Int_t   nb_candidates[nb_cuts_max];
    Bool_t  flag_evt_selected[nb_cuts_max+2];

    int m_primary_vertex_index;
    int m_primary_truth_vertex_index;

    //Double_t deltaR_jetmatching_cut;
    Double_t m_cutvalue_etmiss_min;
    Double_t m_cutvalue_bjet_weight_max;
    //Double_t m_cutvalue_truthjet_pt_min;
    Double_t m_cutvalue_jet_abseta_min;
    Double_t m_cutvalue_lepton1_pt_min;
    Double_t m_cutvalue_lepton2_pt_min;
    Double_t m_cutvalue_lepton_pt_max;
    Double_t m_cutvalue_leptons_dphi_max;
    Double_t m_cutvalue_leptons_dr_max;
    Double_t m_cutvalue_leptons_costheta_min;
    Double_t m_cutvalue_leptons_mass_max;
    Double_t m_cutvalue_leptons_pt_max;

    Double_t m_cutvalue_jet_eta_max;
    Double_t m_cutvalue_jet_pt_min;
    Double_t m_cutvalue_jet_pt_max;
    Double_t m_cutvalue_trackjet_pt_min;
    Double_t m_cutvalue_trackjet_pt_max;
    Double_t m_cutvalue_jet1_pt_min;
    Double_t m_cutvalue_jet2_pt_min;

    Double_t m_cutvalue_jets_absdeta_min;
    Double_t m_cutvalue_jets_absdphi_max;
    Double_t m_cutvalue_jets_mass_min;
    Double_t m_cutvalue_jets_mass_max;
    Double_t m_cutvalue_cjet_eta_max;
    Double_t m_cutvalue_mtllnu_min;
    Double_t m_cutvalue_pt_balance_max;
    
    Double_t m_cutvalue_x1_max;
    Double_t m_cutvalue_x2_max;
    Double_t m_cutvalue_tautau_Z_dm_min;

    Double_t m_cutvalue_mt_min; 
    Double_t m_cutvalue_mt_max;
    
    Double_t m_cutvalue_jet_match_dR;

    Bool_t   m_switch_cjet_between_fwdjets;
    Int_t    m_flag_cjv_track_jets;
    Int_t    m_flag_cjv_stdjet_corrpt;
    Int_t    m_flag_cjv_trkstdjet_match;
    Double_t m_cutvalue_cjv_stdjet_pt_min;
    Double_t m_cutvalue_cjv_trkjet_pt_min;
    Double_t m_cutvalue_cjv_ptratio_min;
    Double_t m_cutvalue_cjv_cmsptratio_min;
    
    Int_t    m_cutvalue_nb_vertices_min;
    Int_t    m_cutvalue_nb_vertices_max;


    //TString m_decay_mode;
    Bool_t  m_truth_ana_flag;

    // vectors //
    std::vector<MyParticle*> v_centraljet_ana;
    std::vector<MyParticle*> v_track_jet_reco_fake;

    std::vector<MyParticle*> v_trackjet_forcjvmatch;

    std::vector< std::vector<MyVBFCandidate> > v_cut_candidates;

    // methods //

    void init(void); // initialization routine
    void destruct(void); // destruction routine

    // my methods //  
    

    Double_t get_cutvalue(TString variable, MyTextFileReader *txtfile_reader);

    // preselection

    std::vector<MyParticle*> 
    preselect_electrons(const std::vector<MyParticle*> vec_particle, double pt_min);
    std::vector<MyParticle*> 
    preselect_electrons_for_orm(const std::vector<MyParticle*> vec_particle, double pt_min);
    std::vector<MyParticle*> 
    preselect_truth_electrons(const std::vector<MyParticle*> vec_particle, double pt_min);
    std::vector<MyParticle*> 
    preselect_muons(const std::vector<MyParticle*> vec_particle, double pt_min);
    std::vector<MyParticle*> 
    preselect_truth_muons(const std::vector<MyParticle*> vec_particle, double pt_min);
   

    // matching

    void match_electrons( std::vector<MyParticle*> vec_e_reco, 
                          std::vector<MyParticle*> vec_e_truth);
    
    void match_muons( std::vector<MyParticle*> vec_mu_reco, 
                      std::vector<MyParticle*> vec_mu_truth);
    
    void match_jets( std::vector<MyParticle*> vec_jet_reco, 
                     std::vector<MyParticle*> vec_jet_truth);

    void match_track_jets( std::vector<MyParticle*> vec_track_jet_reco, 
                           std::vector<MyParticle*> vec_track_jet_truth);

    void match_fake_track_jets( std::vector<MyParticle*> vec_e, 
                                std::vector<MyParticle*> vec_mu);


    void match_track_with_std_jets( std::vector<MyParticle*> vec_track_jet, 
                                    std::vector<MyParticle*> vec_std_jet);
    void match_truth_track_with_std_jets( std::vector<MyParticle*> vec_truth_track_jet, 
                                          std::vector<MyParticle*> vec_truth_std_jet);


    //btag efficiency
    
    void jet_btag_eff( std::vector<MyParticle*> vec_reco_jets, 
                       MyTruthParticleManager *truth_manager);
    
    void lepton_isolation_study( std::vector<MyParticle*> vec_leptons,
                                 MyTruthParticleManager *truth_manager);

    // analysis

    void cut_based_analysis( std::vector<MyParticle*> vec_e_in,
                             std::vector<MyParticle*> vec_mu_in,
                             std::vector<MyParticle*> vec_jet_in,
                             std::vector<MyParticle*> vec_track_jet_in,
                             MyMissingEt missinget_in,
                             MyTrigger trigger
                             );
    
    
    std::vector<MyVBFCandidate> 
        build_candidates( std::vector<MyParticle*> vec_jets,
                          std::vector<MyParticle*> vec_leptons,
                          MyMissingEt missing_et);

    Bool_t select_candidate(MyVBFCandidate candidate);
 
    MyVBFCandidate choose_candidate(std::vector<MyVBFCandidate> candidates);

    std::vector<MyParticle*>
        build_centraljet_vector(std::vector<MyParticle*> vec_std_jets,
                                std::vector<MyParticle*> vec_trk_jets);
    
    
    std::vector<MyParticlePair> 
        get_tagjet_pairs(std::vector<MyVBFCandidate> vec_candidates);

    std::vector<MyParticlePair> 
        get_lepton_pairs(std::vector<MyVBFCandidate> vec_candidates);

    std::vector<MyParticle*> 
        get_tagjets(std::vector<MyParticlePair> vec_tagjet_pairs);
             
    std::vector<MyParticle*> 
        get_leptons(std::vector<MyParticlePair> vec_lepton_pairs);

  
    // fill histograms
    void fill_vertex_histos( const std::vector<MyVertex*> *vertices, 
                             const std::vector<MyVertex*> *truth_vertices);

    void fill_raw_aod_content_histos( std::vector<MyParticle*> v_e_reco_aod,
                                      std::vector<MyParticle*> v_mu_reco_aod,
                                      std::vector<MyParticle*> v_jet_reco_aod,
                                      std::vector<MyParticle*> v_e_truth_aod,
                                      std::vector<MyParticle*> v_mu_truth_aod,
                                      std::vector<MyParticle*> v_jet_truth_aod);


    //void fill_final_histos(MyVBFCandidate candidate);

    void fill_all_ana_histos(int iCut, MyMissingEt missinget);


    // cuts on event basis

    bool cut_offline_trigger(std::vector<MyParticle*> vec_e,
                             std::vector<MyParticle*> vec_mu);

    bool cut_online_trigger(std::vector<MyParticle*> vec_e,
                            std::vector<MyParticle*> vec_mu,
                            MyTrigger trigger);
    
    bool cut_nb_objects(std::vector<MyParticle*> vec_e,
                        std::vector<MyParticle*> vec_mu,
                        std::vector<MyParticle*> vec_jet);

    bool cut_nb_leptons(std::vector<MyParticle*> vec_e,
                        std::vector<MyParticle*> vec_mu);

    bool cut_nb_jets(std::vector<MyParticle*> vec_jet);


    bool cut_bjet_veto(std::vector<MyParticle*> vec_jet);
    bool cut_etmiss(MyMissingEt missing_et);
    
    // cuts on the candidates
    bool cut_etmiss(MyVBFCandidate candidate);
    bool cut_tagjet_no_bjet(MyVBFCandidate candidate);
    bool cut_lepton_pt(MyVBFCandidate candidate);
    bool cut_leptons_charge(MyVBFCandidate candidate);                  
    bool cut_leptons_dphi(MyVBFCandidate candidate);                    
    bool cut_leptons_dr(MyVBFCandidate candidate);
    bool cut_leptons_theta(MyVBFCandidate candidate);
    bool cut_leptons_mass(MyVBFCandidate candidate);
    bool cut_leptons_pt(MyVBFCandidate candidate);
    bool cut_tau_veto(MyVBFCandidate candidate);                
    bool cut_jets_pt(MyVBFCandidate candidate);                         
    bool cut_jets_hemisphere(MyVBFCandidate candidate);                 
    bool cut_jets_deta(MyVBFCandidate candidate);                       
    bool cut_jets_dphi(MyVBFCandidate candidate);                       
    bool cut_jets_mass(MyVBFCandidate candidate);                       
    bool cut_central_jet_veto(MyVBFCandidate candidate);                
    bool cut_leptons_jets_deta(MyVBFCandidate candidate);
    bool cut_transverse_mass(MyVBFCandidate candidate);
    bool cut_pt_balance(MyVBFCandidate candidate);

    
};

#endif

---