csander/HEPTutorial/MyAnalysis.C

#define MyAnalysis_cxx
// The class definition in MyAnalysis.h has been generated automatically
// by the ROOT utility TTree::MakeSelector(). This class is derived
// from the ROOT class TSelector. For more information on the TSelector
// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.

// The following methods are defined in this file:
//    Begin():        called every time a loop on the tree starts,
//                    a convenient place to create your histograms.
//    SlaveBegin():   called after Begin(), when on PROOF called only on the
//                    slave servers.
//    Process():      called for each event, in this function you decide what
//                    to read and fill your histograms.
//    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
//                    called only on the slave servers.
//    Terminate():    called at the end of the loop on the tree,
//                    a convenient place to draw/fit your histograms.
//
// To use this file, try the following session on your Tree T:
//
// Root > T->Process("MyAnalysis.C")
// Root > T->Process("MyAnalysis.C","some options")
// Root > T->Process("MyAnalysis.C+")
//

#include "MyAnalysis.h"
#include <iostream>
#include <TH1F.h>
#include <TLatex.h>

using namespace std;

void MyAnalysis::BuildEvent() {

        MHT.SetXYZM(0., 0., 0., 0.);
        HT = 0;
        Jet_Mult = 0;
        BJet_Mult = 0;
        IsoEle_Mult = 0;
        IsoMu_Mult = 0;
        IsoPho_Mult = 0;
        DeltaPhiJet1MHT = 0;
        DeltaPhiJet2MHT = 0;
        DeltaPhiJet3MHT = 0;
        hasBadJet = false;
        deltaPhiCut = false;

        Jets.clear();
        for (int i = 0; i < NJet; ++i) {
                MyJet jet(Jet_Px[i], Jet_Py[i], Jet_Pz[i], Jet_E[i]);
                jet.SetBTagDiscriminator(Jet_btag[i]);
                jet.SetJetID(Jet_ID[i]);
                jet.SetMatchedGenJet(Jet_Px_gen[i], Jet_Py_gen[i], Jet_Pz_gen[i], Jet_E_gen[i]);
                jet.SetFlavor(Jet_Flavor_gen[i]);
                Jets.push_back(jet);
                if (!(jet.GetJetID()) && jet.Pt() > 30)
                        hasBadJet = true;
                if (jet.Pt() > 30)
                        MHT -= jet;
                if (jet.Pt() > 50 && fabs(jet.Eta()) < 2.5) {
                        HT += jet.Pt();
                        ++Jet_Mult;
                }
                //// Apply b-Tag MC/Data reweighting
        }
        Muons.clear();
        for (int i = 0; i < NMuon; ++i) {
                MyMuon muon(Muon_Px[i], Muon_Py[i], Muon_Pz[i], Muon_E[i]);
                muon.SetIsolation(Muon_Iso[i]);
                muon.SetCharge(Muon_Charge[i]);
                muon.SetChargeGen(Muon_Charge_gen[i]);
                muon.SetMatchedGenMuon(Muon_Px_gen[i], Muon_Py_gen[i], Muon_Pz_gen[i], Muon_E_gen[i]);
                Muons.push_back(muon);
                if (muon.Pt() > 10 && muon.IsIsolated() && fabs(muon.Eta()) < 2.4)
                        ++IsoMu_Mult;
                bool isNoJet = true;
                if (muon.Pt() > 30) {
                        //// Cross cleaning from jets
                        for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
                                if (it->DeltaR(muon) < 0.5)
                                        isNoJet = false;
                        }
                        if (isNoJet)
                                MHT -= muon;
                }
                if (muon.Pt() > 50 && fabs(muon.Eta()) < 2.5) {
                        if (isNoJet)
                                HT += muon.Pt();
                }
        }
        Electrons.clear();
        for (int i = 0; i < NElectron; ++i) {
                MyElectron electron(Electron_Px[i], Electron_Py[i], Electron_Pz[i], Electron_E[i]);
                electron.SetIsolation(Electron_Iso[i]);
                electron.SetCharge(Electron_Charge[i]);
                electron.SetChargeGen(Electron_Charge_gen[i]);
                electron.SetMatchedGenElectron(Electron_Px_gen[i], Electron_Py_gen[i], Electron_Pz_gen[i], Electron_E_gen[i]);
                Electrons.push_back(electron);
                if (electron.Pt() > 10 && electron.IsIsolated() && fabs(electron.Eta()) < 2.5 && !(fabs(electron.Eta()) < 1.566 && fabs(electron.Eta()) > 1.444))
                        ++IsoEle_Mult;
                bool isNoJet = true;
                if (electron.Pt() > 30) {
                        //// Cross cleaning from jets
                        for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
                                if (it->DeltaR(electron) < 0.5)
                                        isNoJet = false;
                        }
                        if (isNoJet)
                                MHT -= electron;
                }
                if (electron.Pt() > 50 && fabs(electron.Eta()) < 2.5) {
                        if (isNoJet)
                                HT += electron.Pt();
                }
        }
        Photons.clear();
        for (int i = 0; i < NPhoton; ++i) {
                MyPhoton photon(Photon_Px[i], Photon_Py[i], Photon_Pz[i], Photon_E[i]);
                photon.SetIsolation(Photon_Iso[i]);
                photon.SetMatchedGenPhoton(Photon_Px_gen[i], Photon_Py_gen[i], Photon_Pz_gen[i], Photon_E_gen[i]);
                Photons.push_back(photon);
                if (photon.IsIsolated())
                        ++IsoPho_Mult;
                bool isNoJet = true;
                bool isNoElectron = true;
                if (photon.Pt() > 30) {
                        //// Cross cleaning from jets
                        for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
                                if (it->DeltaR(photon) < 0.5)
                                        isNoJet = false;
                        }
                        //// Cross cleaning from electrons
                        for (vector<MyElectron>::iterator it = Electrons.begin(); it != Electrons.end(); ++it) {
                                if (it->DeltaR(photon) < 0.1)
                                        isNoElectron = false;
                        }
                        if (isNoJet && isNoElectron)
                                MHT -= photon;
                }
                if (photon.Pt() > 50 && fabs(photon.Eta()) < 2.5) {
                        if (isNoJet && isNoElectron)
                                HT += photon.Pt();
                }
        }
        Taus.clear();
        for (int i = 0; i < NTau; ++i) {
                MyTau tau(Tau_Px[i], Tau_Py[i], Tau_Pz[i], Tau_E[i]);
                tau.SetTauID(Tau_ID[i]);
                tau.SetMatchedGenJet(Tau_Px_gen[i], Tau_Py_gen[i], Tau_Pz_gen[i], Tau_E_gen[i]);
                Taus.push_back(tau);
        }
        Partons.clear();
        for (int i = 0; i < NParton; ++i) {
                MyParton parton(Parton_Px[i], Parton_Py[i], Parton_Pz[i], Parton_E[i]);
                parton.SetPid(Parton_Pid[i]);
                parton.SetNo(Parton_No[i]);
                Partons.push_back(parton);
        }
        met.SetXYZM(MET_px, MET_py, 0., 0.);
        genmet.SetXYZM(MET_px_gen, MET_py_gen, 0., 0.);

        EventWeight *= weight_factor;

        int N_Jet = 0;
        deltaPhiCut = false;
        for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
                ++N_Jet;
                if (N_Jet == 1) {
                        DeltaPhiJet1MHT = MHT.DeltaPhi(*it);
                        if (fabs(DeltaPhiJet1MHT) < 0.5)
                                deltaPhiCut = true;
                } else if (N_Jet == 2) {
                        DeltaPhiJet2MHT = MHT.DeltaPhi(*it);
                        if (fabs(DeltaPhiJet2MHT) < 0.5)
                                deltaPhiCut = true;
                } else if (N_Jet == 3) {
                        DeltaPhiJet3MHT = MHT.DeltaPhi(*it);
                        if (fabs(DeltaPhiJet3MHT) < 0.3)
                                deltaPhiCut = true;
                }
        }

        mTele = 0;
        if (NElectron > 0) {
                mTele = sqrt(2 * met.Et() * Electrons.at(0).Et() * (1 - cos(met.DeltaPhi(Electrons.at(0)))));
        };

        mTmu = 0;
        if (NMuon > 0) {
                mTmu = sqrt(2 * met.Et() * Muons.at(0).Et() * (1 - cos(met.DeltaPhi(Muons.at(0)))));
        };

        MHTf = MHT.Pt();
        HTf = HT;

}

void MyAnalysis::Begin(TTree * /*tree*/) {
        // The Begin() function is called at the start of the query.
        // When running with PROOF Begin() is only called on the client.
        // The tree argument is deprecated (on PROOF 0 is passed).

        TString option = GetOption();

}

void MyAnalysis::SlaveBegin(TTree * /*tree*/) {
        // The SlaveBegin() function is called after the Begin() function.
        // When running with PROOF SlaveBegin() is called on each slave server.
        // The tree argument is deprecated (on PROOF 0 is passed).

        TString option = GetOption();

        h_Mmumu = new TH1F("Mmumu", "Invariant di-muon mass", 100, 0, 1000);
        h_Mmumu->SetXTitle("m_{#mu#mu} [GeV]");
        h_Mmumu->Sumw2();
        histograms.push_back(h_Mmumu);

        h_NJet = new TH1F("NJet", "Number of jets", 20, 0, 20);
        h_NJet->SetXTitle("N_{Jets}");
        h_NJet->Sumw2();
        histograms.push_back(h_NJet);

        h_NBJet = new TH1F("NBJet", "Number of b-jets", 5, 0, 5);
        h_NBJet->SetXTitle("N_{b-Jets}");
        h_NBJet->Sumw2();
        histograms.push_back(h_NBJet);

        h_Jet1_Pt = new TH1F("Jet1Pt", "Pt of jet1", 50, 0, 2000);
        h_Jet1_Pt->SetXTitle("p_{T,jet1} [GeV]");
        h_Jet1_Pt->Sumw2();
        histograms.push_back(h_Jet1_Pt);

        h_Jet2_Pt = new TH1F("Jet2Pt", "Pt of jet2", 50, 0, 2000);
        h_Jet2_Pt->SetXTitle("p_{T,jet2} [GeV]");
        h_Jet2_Pt->Sumw2();
        histograms.push_back(h_Jet2_Pt);

        h_Jet3_Pt = new TH1F("Jet3Pt", "Pt of jet3", 50, 0, 1000);
        h_Jet3_Pt->SetXTitle("p_{T,jet3} [GeV]");
        h_Jet3_Pt->Sumw2();
        histograms.push_back(h_Jet3_Pt);

        h_Jet1_Eta = new TH1F("Jet1Eta", "#eta of jet1", 50, -5, 5);
        h_Jet1_Eta->SetXTitle("#eta_{jet1}");
        h_Jet1_Eta->Sumw2();
        histograms.push_back(h_Jet1_Eta);

        h_Jet2_Eta = new TH1F("Jet2Eta", "#eta of jet2", 50, -5, 5);
        h_Jet2_Eta->SetXTitle("#eta_{jet2}");
        h_Jet2_Eta->Sumw2();
        histograms.push_back(h_Jet2_Eta);

        h_Jet3_Eta = new TH1F("Jet3Eta", "#eta of jet3", 50, -5, 5);
        h_Jet3_Eta->SetXTitle("#eta_{jet3}");
        h_Jet3_Eta->Sumw2();
        histograms.push_back(h_Jet3_Eta);

        h_BJet1_Pt = new TH1F("BJet1Pt", "Pt of b-jet1", 50, 0, 1000);
        h_BJet1_Pt->SetXTitle("p_{T,b-jet1} [GeV]");
        h_BJet1_Pt->Sumw2();
        histograms.push_back(h_BJet1_Pt);

        h_BJet2_Pt = new TH1F("BJet2Pt", "Pt of b-jet2", 50, 0, 1000);
        h_BJet2_Pt->SetXTitle("p_{T,b-jet2} [GeV]");
        h_BJet2_Pt->Sumw2();
        histograms.push_back(h_BJet2_Pt);

        h_BJet1_Eta = new TH1F("BJet1Eta", "#eta of b-jet1", 50, -5, 5);
        h_BJet1_Eta->SetXTitle("#eta_{b-jet1}");
        h_BJet1_Eta->Sumw2();
        histograms.push_back(h_BJet1_Eta);

        h_BJet2_Eta = new TH1F("BJet2Eta", "#eta of b-jet2", 50, -5, 5);
        h_BJet2_Eta->SetXTitle("#eta_{b-jet2}");
        h_BJet2_Eta->Sumw2();
        histograms.push_back(h_BJet2_Eta);

        h_MET = new TH1F("MET", "MET", 50, 0, 2000);
        h_MET->SetXTitle("MET [GeV]");
        h_MET->Sumw2();
        histograms.push_back(h_MET);

        h_MHT = new TH1F("MHT", "MHT", 50, 0, 2000);
        h_MHT->SetXTitle("MHT [GeV]");
        h_MHT->Sumw2();
        histograms.push_back(h_MHT);

        h_HT = new TH1F("HT", "HT", 50, 0, 5000);
        h_HT->SetXTitle("HT [GeV]");
        h_HT->Sumw2();
        histograms.push_back(h_HT);

        h_DeltaPhiJet1Jet2 = new TH1F("DeltaPhiJet1Jet2", "DeltaPhiJet1Jet2", 50, -TMath::Pi(), TMath::Pi());
        h_DeltaPhiJet1Jet2->SetXTitle("#Delta#Phi(Jet1,Jet2)");
        h_DeltaPhiJet1Jet2->Sumw2();
        histograms.push_back(h_DeltaPhiJet1Jet2);

        h_DeltaPhiJet1MHT = new TH1F("DeltaPhiJet1MHT", "DeltaPhiJet1MHT", 50, -TMath::Pi(), TMath::Pi());
        h_DeltaPhiJet1MHT->SetXTitle("#Delta#Phi(Jet1,MHT)");
        h_DeltaPhiJet1MHT->Sumw2();
        histograms.push_back(h_DeltaPhiJet1MHT);

        h_DeltaPhiJet2MHT = new TH1F("DeltaPhiJet2MHT", "DeltaPhiJet2MHT", 50, -TMath::Pi(), TMath::Pi());
        h_DeltaPhiJet2MHT->SetXTitle("#Delta#Phi(Jet2,MHT)");
        h_DeltaPhiJet2MHT->Sumw2();
        histograms.push_back(h_DeltaPhiJet2MHT);

        h_DeltaPhiJet3MHT = new TH1F("DeltaPhiJet3MHT", "DeltaPhiJet3MHT", 50, -TMath::Pi(), TMath::Pi());
        h_DeltaPhiJet3MHT->SetXTitle("#Delta#Phi(Jet3,MHT)");
        h_DeltaPhiJet3MHT->Sumw2();
        histograms.push_back(h_DeltaPhiJet3MHT);

        h_Jet1OverHT = new TH1F("h_Jet1OverHT", "h_Jet1OverHT", 50, 0, 1.0);
        h_Jet1OverHT->SetXTitle("p_{T,jet1}/HT");
        h_Jet1OverHT->Sumw2();
        histograms.push_back(h_Jet1OverHT);

        h_Jet2OverHT = new TH1F("h_Jet2OverHT", "h_Jet2OverHT", 50, 0, 1.0);
        h_Jet2OverHT->SetXTitle("p_{T,jet2}/HT");
        h_Jet2OverHT->Sumw2();
        histograms.push_back(h_Jet2OverHT);

        h_Jet12OverHT = new TH1F("h_Jet12OverHT", "h_Jet12OverHT", 50, 0, 1.0);
        h_Jet12OverHT->SetXTitle("(p_{T,jet1}+p_{T,jet2})/HT");
        h_Jet12OverHT->Sumw2();
        histograms.push_back(h_Jet12OverHT);

        h_MHTOverHT = new TH1F("h_MHTOverHT", "h_MHTOverHT", 50, 0, 1.0);
        h_MHTOverHT->SetXTitle("MHT/HT");
        h_MHTOverHT->Sumw2();
        histograms.push_back(h_MHTOverHT);

        h_Muon1_Pt = new TH1F("Muon1Pt", "Pt of muon1", 50, 0, 1000);
        h_Muon1_Pt->SetXTitle("p_{T,muon1} [GeV]");
        h_Muon1_Pt->Sumw2();
        histograms.push_back(h_Muon1_Pt);

        h_Electron1_Pt = new TH1F("Electron1Pt", "Pt of electron1", 50, 0, 1000);
        h_Electron1_Pt->SetXTitle("p_{T,electron1} [GeV]");
        h_Electron1_Pt->Sumw2();
        histograms.push_back(h_Electron1_Pt);

        h_Muon1_Iso = new TH1F("Muon1Iso", "Relative iso of muon1", 50, 0, 1);
        h_Muon1_Iso->SetXTitle("isolation_{rel,muon1}");
        h_Muon1_Iso->Sumw2();
        histograms.push_back(h_Muon1_Iso);

        h_Electron1_Iso = new TH1F("Electron1Iso", "Relative iso of electron1", 50, 0, 1);
        h_Electron1_Iso->SetXTitle("isolation_{rel,electron1}");
        h_Electron1_Iso->Sumw2();
        histograms.push_back(h_Electron1_Iso);

        h_Muon_MT = new TH1F("MuonMT", "MT of leading muon and MET", 50, 0, 250);
        h_Muon_MT->SetXTitle("M_{T} (muon,MET) [GeV]");
        h_Muon_MT->Sumw2();
        histograms.push_back(h_Muon_MT);

        h_Electron_MT = new TH1F("ElectronMT", "MT of leading electron and MET", 50, 0, 250);
        h_Electron_MT->SetXTitle("M_{T} (ele,MET) [GeV]");
        h_Electron_MT->Sumw2();
        histograms.push_back(h_Electron_MT);

}

Bool_t MyAnalysis::Process(Long64_t entry) {
        // The Process() function is called for each entry in the tree (or possibly
        // keyed object in the case of PROOF) to be processed. The entry argument
        // specifies which entry in the currently loaded tree is to be processed.
        // It can be passed to either MyAnalysis::GetEntry() or TBranch::GetEntry()
        // to read either all or the required parts of the data. When processing
        // keyed objects with PROOF, the object is already loaded and is available
        // via the fObject pointer.
        //
        // This function should contain the "body" of the analysis. It can contain
        // simple or elaborate selection criteria, run algorithms on the data
        // of the event and typically fill histograms.
        //
        // The processing can be stopped by calling Abort().
        //
        // Use fStatus to set the return value of TTree::Process().
        //
        // The return value is currently not used.

        ++TotalEvents;

        GetEntry(entry);

        Event event(EventNumber, LumiNumber, RunNumber);

        if (TotalEvents % 10000 == 0)
                cout << "Next event -----> " << TotalEvents << endl;

        if (EventList != 0) {
                if (!EventList->IsInList(event))
                        return 0;
        }

        BuildEvent();

        if (hasBadJet)
                return 0;

        if (HT < 400)
                return 0;

        if (met.Pt() < 150)
                return 0;

//      if (MHT.Pt() < 200)
//              return 0;

        if (Jet_Mult < 2)
                return 0;

//      if (deltaPhiCut)
//              return 0;

//      if (IsoEle_Mult > 0 || IsoMu_Mult > 0)
//              return 0;

//      if ((mTele < 10 || mTele > 100) && (mTmu < 10 || mTmu > 100))
//              return 0;

//      if (mTele < 10 || mTele > 100)
//              return 0;

//      if (mTmu < 10 || mTmu > 100)
//              return 0;

        if (mTmu == 0 && mTele == 0)
                return 0;

        //// Calculate distance of leading muon to next jet, and rel pT w.r.t. that jet
        for (int i = 0; i < NMuon; ++i) {
                dRmin_Muon[i] = 999;
                pTrel_Muon[i] = 0;
                relIso_Muon[i] = 0;
                Pt_Muon[i] = 0;
                Eta_Muon[i] = 0;
        }
        int j = 0;
        for (vector<MyMuon>::iterator jt = Muons.begin(); jt != Muons.end(); ++jt) {
                Pt_Muon[j] = jt->Pt();
                Eta_Muon[j] = jt->Eta();
                for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
                        double tmp = jt->DeltaR(*it);
                        if (tmp < dRmin_Muon[j]) {
                                dRmin_Muon[j] = tmp;
                                pTrel_Muon[j] = jt->Pt() / it->Pt();
                                relIso_Muon[j] = jt->GetIsolation() / jt->Pt();
                        }
                }
                ++j;
        }

        //// Calculate distance of leading electron to next jet, and rel pT w.r.t. that jet
        for (int i = 0; i < NElectron; ++i) {
                dRmin_Electron[i] = 999;
                pTrel_Electron[i] = 0;
                relIso_Electron[i] = 0;
                Pt_Electron[i] = 0;
                Eta_Electron[i] = 0;
        }
        j = 0;
        for (vector<MyElectron>::iterator jt = Electrons.begin(); jt != Electrons.end(); ++jt) {
                Pt_Electron[j] = jt->Pt();
                Eta_Electron[j] = jt->Eta();
                for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
                        double tmp = jt->DeltaR(*it);
                        if (tmp < dRmin_Electron[j]) {
                                dRmin_Electron[j] = tmp;
                                pTrel_Electron[j] = jt->Pt() / it->Pt();
                                relIso_Electron[j] = jt->GetIsolation() / jt->Pt();
                        }
                }
                ++j;
        }

//      cout << "Jets: " << endl;
//      for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {
//              cout << "pt, eta, phi, btag, ID: " << it->Pt() << ", " << it->Eta() << ", " << it->Phi() << ", " << it->IsBTagged() << ", " << it->GetJetID() << endl;
//      }
//      cout << "Muons: " << endl;
//      for (vector<MyMuon>::iterator it = Muons.begin(); it != Muons.end(); ++it) {
//              cout << "pt, eta, phi, iso, charge: " << it->Pt() << ", " << it->Eta() << ", " << it->Phi() << ", " << it->GetIsolation() << ", " << it->GetCharge()
//                              << endl;
//      }
//      cout << "Electrons: " << endl;
//      for (vector<MyElectron>::iterator it = Electrons.begin(); it != Electrons.end(); ++it) {
//              cout << "pt, eta, phi, iso, charge: " << it->Pt() << ", " << it->Eta() << ", " << it->Phi() << ", " << it->GetIsolation() << ", " << it->GetCharge()
//                              << endl;
//      }
//      cout << "Photons: " << endl;
//      for (vector<MyPhoton>::iterator it = Photons.begin(); it != Photons.end(); ++it) {
//              cout << "pt, eta, phi, iso: " << it->Pt() << ", " << it->Eta() << ", " << it->Phi() << ", " << it->GetIsolation() << endl;
//      }
//      cout << "Taus: " << endl;
//      for (vector<MyTau>::iterator it = Taus.begin(); it != Taus.end(); ++it) {
//              cout << "pt, eta, phi, ID: " << it->Pt() << ", " << it->Eta() << ", " << it->Phi() << ", " << it->GetTauID() << endl;
//      }
//      cout << "MET (pt, phi): " << met.Pt() << ", " << met.Phi() << endl;
//      cout << "MHT (pt, phi): " << MHT.Pt() << ", " << MHT.Phi() << endl;

        int N_BJet = 0;
        int N_Jet = 0;
        for (vector<MyJet>::iterator it = Jets.begin(); it != Jets.end(); ++it) {

                ++N_Jet;

                if (N_Jet == 1) {
                        h_Jet1_Pt->Fill(it->Pt(), EventWeight);
                        h_Jet1_Eta->Fill(it->Eta(), EventWeight);
                        h_DeltaPhiJet1MHT->Fill(DeltaPhiJet1MHT, EventWeight);
                } else if (N_Jet == 2) {
                        h_Jet2_Pt->Fill(it->Pt(), EventWeight);
                        h_Jet2_Eta->Fill(it->Eta(), EventWeight);
                        h_DeltaPhiJet2MHT->Fill(DeltaPhiJet2MHT, EventWeight);
                } else if (N_Jet == 3) {
                        h_Jet3_Pt->Fill(it->Pt(), EventWeight);
                        h_Jet3_Eta->Fill(it->Eta(), EventWeight);
                        h_DeltaPhiJet3MHT->Fill(DeltaPhiJet3MHT, EventWeight);
                }
                if (it->IsBTagged()) {
                        ++N_BJet;
                        if (it->Pt() > 30)
                                ++BJet_Mult;
                        if (N_BJet == 1) {
                                h_BJet1_Pt->Fill(it->Pt(), EventWeight);
                                h_BJet1_Eta->Fill(it->Eta(), EventWeight);
                        } else if (N_BJet == 2) {
                                h_BJet2_Pt->Fill(it->Pt(), EventWeight);
                                h_BJet2_Eta->Fill(it->Eta(), EventWeight);
                        }
                }
        }
        h_NBJet->Fill(BJet_Mult, EventWeight);
        h_NJet->Fill(Jet_Mult, EventWeight);

        h_MET->Fill(met.Pt(), EventWeight);
        h_MHT->Fill(MHT.Pt(), EventWeight);
        h_HT->Fill(HT, EventWeight);
        //////////////////////////////

        //////////////////////////////
        if (Jets.size() > 1) {
                h_DeltaPhiJet1Jet2->Fill(Jets.at(0).DeltaPhi(Jets.at(1)), EventWeight);
                h_Jet2OverHT->Fill(Jets.at(1).Pt() / HT, EventWeight);
                h_Jet12OverHT->Fill((Jets.at(0).Pt() + Jets.at(1).Pt()) / HT, EventWeight);
        }
        if (HT > 0)
                h_Jet1OverHT->Fill(Jets.at(0).Pt() / HT, EventWeight);
        if (HT > 0)
                h_MHTOverHT->Fill(MHT.Pt() / HT, EventWeight);
        //////////////////////////////

        //////////////////////////////
        if (NElectron > 0) {
                h_Electron1_Pt->Fill(Electrons.at(0).Pt(), EventWeight);
                h_Electron1_Iso->Fill(Electrons.at(0).GetIsolation() / Electrons.at(0).Pt(), EventWeight);
                h_Electron_MT->Fill(mTele, EventWeight);
        }
        if (NMuon > 0) {
                h_Muon1_Pt->Fill(Muons.at(0).Pt(), EventWeight);
                h_Muon1_Iso->Fill(Muons.at(0).GetIsolation() / Muons.at(0).Pt(), EventWeight);
                h_Muon_MT->Fill(mTmu, EventWeight);
        }
        //////////////////////////////

        //////////////////////////////
        if (NMuon > 1) {
                if (Muons.at(0).GetCharge() * Muons.at(1).GetCharge() < 1 && Muons.at(0).IsIsolated() && Muons.at(1).IsIsolated()) {
                        h_Mmumu->Fill((Muons.at(0) + Muons.at(1)).M(), EventWeight);
                }
        }
        //////////////////////////////

        ReweightTree->Fill();

        return kTRUE;
}

void MyAnalysis::SlaveTerminate() {
        // The SlaveTerminate() function is called after all entries or objects
        // have been processed. When running with PROOF SlaveTerminate() is called
        // on each slave server.
        file->Write();
        file->Close();
        delete file;

}

void MyAnalysis::Terminate() {
        // The Terminate() function is the last function to be called during
        // a query. It always runs on the client, it can be used to present
        // the results graphically or save the results to file.

}
Revision:	1.24
Committed:	Fri Jul 6 08:19:52 2012 UTC (12 years, 9 months ago) by csander
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.23:	+146 -23 lines
Log Message:	v1.0, including a small ntupler for further skimming