MyHtautauAnalysis/MyHtautauAnalysis/MyHtautauAnalysis.h

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 06.12.2006, AUTHOR: MANFRED GROH
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#ifndef MyHtautauAnalysisH
#define MyHtautauAnalysisH

//:::::::::::::::::::::::::::::
//:: CLASS MyHtautauAnalysis ::
//:::::::::::::::::::::::::::::


//::::::::::::::::::
//:: HEADER FILES ::
//::::::::::::::::::

// ROOT //
#include "TFile.h"
#include "TH1.h"
#include "TH2.h"
#include "TNtuple.h"
#include "TProfile2D.h"

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
    #include "TDirectoryFile.h"
#else
    #include "TDirectory.h"
#endif

// analysis base class //
#include "NtupleReader/MyAnalysis.h"
#include "NtupleReader/MyDatasetInfo.h"
#include "NtupleReader/MyTrigger.h"
#include "NtupleReader/MyTruthParticleManager.h"
#include "NtupleReader/MyCollinearApproximation.h"
#include "NtupleReader/MyParticlePair.h"
#include "NtupleReader/MyTools.h"
#include "NtupleReader/MyTextFileReader.h"
#include "NtupleReader/MyVBFCandidate.h"



class MyHtautauAnalysis : public MyAnalysis {

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

    ~MyHtautauAnalysis(void) {
        destruct();
        }

// Methods //
    void initialize(void);
    void analyse_event(const MyEvent & event);
    void end_of_analysis(void);
    TString settingsFilename;
    TString filename;  // name of ROOT file

private:
    
// The MyDatasetInfo object 
    MyDatasetInfo *m_dataset_info;
    
    TString met_ana_obj;
    // name of the met object that should be used in the analysis
    // before changing to the new MET design this was realized with overwriting
    // the met_final variables
    
    std::vector<int> evt_nb_passed;

    const MyEvent * m_event;
    
    // Number of the entry, starting with 1
    int entry_nb;
    
    double weight;

    bool ev_has_fake_taus;

    int nb_e25i_triggers;
    int nb_m20i_triggers;
    int nb_e25i_not_triggers;
    int nb_m20i_not_triggers;
    int nb_both_triggers;

    int event_flavour;
        // 0 if event isnt triggered
        // 1 if the triggered high pt lepton is an electron
        // 2 if it is a muon
    
    std::string generator;
    
    static const double GeV=1.0;
//    static const double GeV=0.001;
    TFile *m_tfile; // ROOT file
    
    bool switch_truth_lepton_filter;
    int truth_lepton_filter_min_nb_leptons;
    bool switch_analyse_truth_decay;
    bool switch_truth_decay_mode_filter;
    bool truth_decay_mode_filter_only_higgs;
    bool truth_decay_mode_filter_analyse_ll;
    bool truth_decay_mode_filter_analyse_lh;
    bool truth_decay_mode_filter_analyse_hh;
    
    double e_presel_pt_min;
    double e_presel_eta_max;
    double e_presel_eoverp_min;
    double e_presel_eoverp_max;
    bool   e_presel_require_isem_0;
    bool   e_presel_require_isem_0x3FF;
    bool   e_presel_require_isem_mod16_0;
    double e_presel_min_NeuralNet;
    double e_presel_max_etCone02;
    double e_presel_max_etCone02_rel;
    bool   e_presel_noisolation_eta14165;
    double e_truth_presel_min_pt;
    double e_truth_presel_max_eta;
    
    std::string reco_muons_name;
    double mu_presel_pt_min;
    double mu_presel_eta_max;
    double mu_presel_max_etCone04;
    double mu_presel_max_etCone045;
    double mu_presel_max_etCone02_rel;
    bool   mu_presel_use_combined;
    bool   mu_presel_use_standalone;
    bool   mu_presel_use_lowpt;
    bool   mu_presel_require_hasCombinedMuonTrackParticle;
    double mu_presel_min_matchChi2;
    double mu_presel_max_matchChi2;
    double mu_presel_max_matchChi2OverDoF;
    double mu_presel_max_fitChi2OverDoF;
    double mu_truth_presel_min_pt;
    double mu_truth_presel_max_eta;
    
    
    bool   switch_mu_delete_doubles;
    bool   switch_mu_remove_overlap_e;
    double dr_mu_remove_overlap_e;

    double taujet_truth_presel_min_pt;
    double taujet_truth_presel_max_eta;
    
    bool    apply_taujet_correction;
    double taujet_presel_min_pt;
    double taujet_presel_max_eta;
    double taujet_presel_min_llh;
    bool   taujet_presel_require_charge_1;
    bool   taujet_presel_require_nb_tracks_13;
    bool   taujet_presel_require_TRTHitRatio;
    double taujet_presel_min_e_over_p;
    double taujet_presel_e_ethadoveret_min;
    
    double jet_presel_min_pt;
    double jet_presel_max_eta;
    
    double jet_truth_presel_min_pt;
    double jet_truth_presel_max_eta;
    
    bool switch_taujet_reco_remove_overlap_e;
    bool switch_taujet_reco_remove_overlap_mu;
    double dr_taujet_reco_remove_overlap_e;
    double dr_taujet_reco_remove_overlap_mu;
    
    bool switch_jet_reco_remove_overlap_e;
    double dr_jet_reco_remove_overlap_e;
    bool switch_jet_reco_remove_overlap_mu;
    double dr_jet_reco_remove_overlap_mu;
    bool switch_jet_reco_remove_overlap_taujet;
    double dr_jet_reco_remove_overlap_taujet;
    
    bool switch_jet_truth_remove_overlap_e;
    double dr_jet_truth_remove_overlap_e;
    bool switch_jet_truth_remove_overlap_mu;
    double dr_jet_truth_remove_overlap_mu;
    bool switch_jet_truth_remove_overlap_taujet;
    double dr_jet_truth_remove_overlap_taujet;
    
    std::string recalculate_met_muons;
    std::string met_option;
    std::string met_muon_contribution;
    // is set in: add_recalculated_missinget
    // according to the given met_option

    bool switch_ana_use_e_truth;
    bool switch_ana_use_mu_truth;
    bool switch_ana_use_taujet_truth;
    bool switch_ana_use_jet_truth;
    
    bool switch_only_highpt_jetpair;
    
    int ana_require_trigger_flavour;
    
    int output_level_cand_ntuple;
    
    unsigned int ana_e_nb_min;
    unsigned int ana_e_nb_max;
    unsigned int ana_mu_nb_min;
    unsigned int ana_mu_nb_max;
    unsigned int ana_emu_nb_min;
    unsigned int ana_emu_nb_max;
    unsigned int ana_taujet_nb_min;
    unsigned int ana_taujet_nb_max;
    
    
    double deltaR_jetmatching_cut;
    int cuts_total_nb;
    std::string cuts[20];

    Double_t min_etmiss;
    Double_t min_e_pt;
    Double_t min_mu_pt;
    Double_t min_taujet_pt;
    
    Double_t min_leptons_cosdphi;
    Double_t max_leptons_dr;
    Double_t min_lept_x;
    Double_t min_had_x;
    Double_t max_lept_x;
    Double_t max_had_x;
    Double_t max_x_squaresum;
    Double_t max_transverse_mass;
    Double_t min_jet1_pt;
    Double_t min_jet2_pt;
    Double_t min_jets_deta;
    Double_t max_jets_dphi;
    Double_t min_jets_mass;
    Double_t max_bjet_weight;
    Double_t min_cj_pt;
    Double_t max_cj_eta;
    Bool_t   switch_cj_between_fwdjets;
    Double_t min_leptons_jets_deta;
    Double_t max_pt_balance;
    Double_t min_mass_window;
    Double_t max_mass_window;


#include "HtautauHistos.h"
    
    std::vector<MyParticle*> v_e_reco_aod;
    std::vector<MyParticle*> v_e_reco_presel;
    
    std::vector<MyParticle*> v_mu_reco_aod;
    std::vector<MyParticle*> v_mu_reco_orm;
    std::vector<MyParticle*> v_mu_reco_presel;
     std::vector<MyParticle*> v_mu_reco_matched;
    
    std::vector<MyParticle*> v_taujet_reco_aod;
    std::vector<MyParticle*> v_garbage;
    std::vector<MyParticle*> v_taujet_reco_orm;
    std::vector<MyParticle*> v_taujet_reco_presel;
    std::vector<MyParticle*> v_taujet_reco_fake;
    
    
    std::vector<MyParticle*> v_jet_reco_aod;
    std::vector<MyParticle*> v_jet_reco_orm;
    std::vector<MyParticle*> v_jet_reco_presel;
    
    std::vector<MyParticle*> v_e_truth_aod;
    std::vector<MyParticle*> v_e_truth_presel;
    
    std::vector<MyParticle*> v_mu_truth_aod;
    std::vector<MyParticle*> v_mu_truth_presel;
     std::vector<MyParticle*> v_mu_truth_matched;
    
    std::vector<MyParticle*> v_tau_truth_aod;
    
    std::vector<MyParticle*> v_jet_truth_aod;
    std::vector<MyParticle*> v_jet_truth_orm;
    std::vector<MyParticle*> v_jet_truth_presel;
    
    std::vector<MyParticle*> v_taujet_truth;
        // the objects in this vector have to be deleted
        // after every event !!!
    std::vector<MyParticle*> v_taujet_truth_all;
    std::vector<MyParticle*> v_taujet_truth_orm;
    std::vector<MyParticle*> v_taujet_truth_presel;



    // vectors on which the analysis is performed:
    std::vector<MyParticle*> v_e_ana;
    std::vector<MyParticle*> v_mu_ana;
    std::vector<MyParticle*> v_taujet_ana;
    std::vector<MyParticle*> v_jet_ana;
    MyMissingEtManager missinget_ana;
    std::vector<MyVBFCandidate*> v_candidates_ana;
    bool has_leptonpair;
    bool has_jetpair;

    
    // The CollinearApproximationObjects
    std::vector<MyCollinearApproximation> v_coll_app;

    // The Tools
    MyTools m_tools;
    // The Truth Manager //
    MyTruthParticleManager m_truth_manager;
    // Decay Modes //
    int primary_particle_mode;// primary particles (W, Z, H...)
                // Mode -1: unknown
                // Mode 0: H
                // Mode 1: Z
                // Mode 2: W+,W-
    int primary_particle_decay_mode;
    int tau_0_decay_mode; // Mode numbering scheme according to ATL-PHYS-PUB-2006-008
                // Table 2 on Page 8
                // e-> 1
                // mu-> 2
                // picharged -> 3
                // 1prong -> 3-7
                // 3prong -> 8-10
                // extension to this:
                // less than two taus -> -1
    int tau_1_decay_mode; // Michael Heldmann: "An improved Tau-Identification ..."
    int higgs_decay_mode; // 1 for ll, 2 for lh, 3 for hh
    
    TString decay_mode_string;
    int decay_mode; // the one that is used for the analysis
                // needed for handling col. app.
                // value is derived from decay_mode_string



// methods //
    void init(void); // initialization routine
    void clear_event_data(void); // reset variables like:
                             // primary_particle_mode
                     // tau_0_decay_mode...
    void destruct(void); // destruction routine
    
    void cut_based_anlysis(
        const MyMissingEtManager missinget_in);
    std::vector<MyVBFCandidate*> 
        build_candidates( std::vector<MyParticle*> v_e_cand,
                          std::vector<MyParticle*> v_mu_cand,
                          std::vector<MyParticle*> v_tau_cand,
                          std::vector<MyParticle*> v_jet_cand,
                          MyMissingEt missing_et);

    void cut_offline_trigger(MyVBFCandidate* candidate);
    void cut_online_trigger(MyVBFCandidate* candidate);
    void cut_number_emu(MyVBFCandidate* candidate);
    void cut_number_taujets(MyVBFCandidate* candidate);
    void cut_number_jets(MyVBFCandidate* candidate);
    void cut_etmiss(MyVBFCandidate* candidate);
    void cut_lepton_pt(MyVBFCandidate* candidate);
    void cut_leptons_charge(MyVBFCandidate* candidate);
    void cut_leptons_dphi(MyVBFCandidate* candidate);
    void cut_leptons_dr(MyVBFCandidate* candidate);
    void cut_collinear_approximation(MyVBFCandidate* candidate);
    void cut_transverse_mass(MyVBFCandidate* candidate);
    void cut_jets_pt(MyVBFCandidate* candidate);
    void cut_jets_hemisphere(MyVBFCandidate* candidate);
    void cut_jets_deta(MyVBFCandidate* candidate);
    void cut_jets_dphi(MyVBFCandidate* candidate);
    void cut_jets_mass(MyVBFCandidate* candidate);
    void cut_bjet_veto(MyVBFCandidate* candidate);
    void cut_central_jet_veto(MyVBFCandidate* candidate);
    void cut_leptons_jets_deta(MyVBFCandidate* candidate);
    void cut_pt_balance(MyVBFCandidate* candidate);
    void cut_mass_window(MyVBFCandidate* candidate);
    MyVBFCandidate* choose_candidate(std::vector<MyVBFCandidate*> v_candidates_tmp);

    void fill_raw_aod_content_histos(void);
        // fill histos for the raw AOD content
        
    std::vector<MyParticle*> preselect_electrons(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_truth_electrons(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_muons(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_truth_muons(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_taujets(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_truth_taujets(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_jets(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    std::vector<MyParticle*> preselect_truth_jets(
        const std::vector<MyParticle*> v_particle);
        // returns the given vector of particles after
        // pt, eta cut (and isolation?)
    MyParticle visible_part_of_decay_products(MyTruthParticle* part_in);
        // returns the sum of all visible decay products as a MyParticle
    std::vector<MyParticle*> create_truth_taujets(std::vector<MyParticle*> v_particle);
        // takes the incoming vector of truth taus and creates for each truth tau
        // a new vector that contains one particle for each tau with the sum of
        // all visible decay products of the tau
    std::vector<MyParticle*> create_corrected_taujets(std::vector<MyParticle*> v_particle);
        // takes the incoming vector of tau jets and returns a new vector that contains
        // the same tau jets with corrected energy
    void delete_truth_taujets(void);
        // deletes the objects created by create_truth_taujets
    void match_electrons(
        std::vector<MyParticle*> v_e_reco, std::vector<MyParticle*> v_e_truth);
        // match recornstructed electrons with truth electrons
    void match_muons(
        std::vector<MyParticle*> v_mu_reco, std::vector<MyParticle*> v_mu_truth);
        // match recornstructed muons with truth muons
    void match_taujets(
        std::vector<MyParticle*> v_taujet_reco, std::vector<MyParticle*> v_taujet_truth);
        // match recornstructed taujets with truth taujets
    void match_jets(
        std::vector<MyParticle*> v_jet_reco, std::vector<MyParticle*> v_jet_truth);
        // match recornstructed jets with truth jets
    void match_fake_taujets(void);
        // match faked tau jets to several kind of things
    void add_recalculated_missinget(MyMissingEtManager *orig_missing_et);
        // recalculate a missing Et object, add it to the MET-Manager as recalculated
    int n_pt_above(const std::vector<MyParticle*> v_particle, const double ptcut);
        // return number of particles in vector with pt above ptcut
    int tau_decay_mode(MyTruthParticle* truth_tau);
    void calculate_decay_mode(void);
    void fill_decay_mode_hists(bool print_info);
    void fill_lepton_hists(const std::vector<MyVBFCandidate*> v_candidates_tmp, const int cut_number);
    void fill_jet_hists(const std::vector<MyVBFCandidate*> v_candidates_tmp, const int cut_number);
        // returns the number of truth leptons that pased the lepton filter
    int check_truth_lepton_filter(void);
    void analyse_truth_decay(void);
    void fill_all_ana_histos(const std::vector<MyVBFCandidate*> v_candidates_tmp, const int cut_number);
    void fill_candidate_ntuple(const std::vector<MyVBFCandidate*> v_candidates_tmp);

    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);
    std::vector<MyParticle*>
            get_centraljet_candidates(std::vector<MyParticle*> vec_jets_tmp, MyVBFCandidate* candidate);
    double get_transverse_mass(MyVBFCandidate* candidate_tmp);
    double get_max_btag_weight(MyVBFCandidate* candidate_tmp, std::vector<MyParticle*> vec_jets_tmp);
    void   check_bjet_performance(std::vector<MyParticle*> v_jet_reco_presel);
    MyTruthParticle* get_next_mother(MyTruthParticle* part);
    bool TTbarLeptonFilter();

    TH1F* h_Wplus_Jetcharge;
    TH1F* h_Wminus_Jetcharge;
    TH1F* h_Wplus_JetpdgIds;
    TH1F* h_Wminus_JetpdgIds;
    void JetOriginInvest(std::vector<MyParticle*> jets_to_invest);
};

#endif

---