Exemplo n.º 1
0
void makeBSM_MCFM_single(int folder, int erg_tev){
  //  if (erg_tev==7) return;
  //  char TREE_NAME[] = "SelectedTree";
  char TREE_NAME[] = "GenTree";
  TString INPUT_NAME = "HZZ4l-125_6-";
  int tFitD = 0;
  TString comstring;
  comstring.Form("%iTeV", erg_tev);
  TString erg_dir;
  erg_dir.Form("LHC_%iTeV/", erg_tev);
  INPUT_NAME.Append(comstring);
  INPUT_NAME.Append("-");

  double mPOLE = 125.6;
  Mela mela(erg_tev, mPOLE);

  TString cinput_common = "/scratch0/hep/usarical/WidthSamples/" + erg_dir + "/";
  if (erg_tev!=7) cinput_common = cinput_common + user_folder[folder] + "/";

  int EnergyIndex = 1;
  if (erg_tev == 7) EnergyIndex = 0;

  float templateWeight = 1;
  float MC_weight;
  float ZZMass = 0;
  float Z1Mass = 0;
  float Z2Mass = 0;

  float GenHMass = 0;
  float GenZ1Mass = 0;
  float GenZ2Mass = 0;
  float GenLep1Id, GenLep2Id, GenLep3Id, GenLep4Id;
  float GenLep1Mass, GenLep2Mass, GenLep3Mass, GenLep4Mass;
  float GenLep1Pt, GenLep2Pt, GenLep3Pt, GenLep4Pt;
  float GenLep1Phi, GenLep2Phi, GenLep3Phi, GenLep4Phi;
  float GenLep1Eta, GenLep2Eta, GenLep3Eta, GenLep4Eta;
  float GenLep1E, GenLep2E, GenLep3E, GenLep4E;

  float p0plus_VAJHU;
  float p0hplus_VAJHU;
  float p0minus_VAJHU;
  float p0_g1prime2_VAJHU;
  float p0_g1prime4_VAJHU;

  float pg1g2_VAJHU;
  float pg1g4_VAJHU;
  float pg1g1prime2_VAJHU;
  float pg1g1prime4_VAJHU;

  TString coutput_common = user_TemplateswithTrees_dir + "../BSMReweight_GenLevel/" + erg_dir;
  coutput_common += user_folder[folder] + "/";
  gSystem->Exec("mkdir -p " + coutput_common);

  TString cinput_KDFactor = "./data/HZZ4l-KDFactorGraph";
  if (EnergyIndex == 0) cinput_KDFactor = cinput_KDFactor + "_7TeV";
  cinput_KDFactor = cinput_KDFactor + ".root";
  TFile* finput_KDFactor = new TFile(cinput_KDFactor, "read");
  TString tgkfname = "KDScale_";
  tgkfname = tgkfname + "AllFlavors_UnNormalized";
  TGraphAsymmErrors* tgkf = (TGraphAsymmErrors*)finput_KDFactor->Get(tgkfname);
  TGraph* tg_interf = make_HZZ_LeptonInterferenceGraph();

  cout<<endl;
  cout<<"==============================="<<endl;
  cout<<"CoM Energy: "<<erg_tev<<" TeV"<<endl;
  cout<<"Decay Channel: "<<user_folder[folder]<<endl;
  cout<<"==============================="<<endl;
  cout<<endl;


  const int kNumTemplates = 4;
  TString templatenames[kNumTemplates] ={ "ggF Sig", "gg Bkg", "ggF BSI", "ggF BSI25" };

  int nEntries;
  float fitYval = 0;
  MC_weight = 1;
  ZZMass = 0;

  double selfDHvvcoupl[SIZE_HVV][2] ={ { 0 } };
  double ggvvcoupl[2]={ 0, 0 };

  //Template and tree filler
  for (int t = 0; t < kNumTemplates; t++){
    TString OUTPUT_NAME;
    OUTPUT_NAME = "HtoZZ4l_MCFM_125p6_BSMTrees_";
    OUTPUT_NAME += sample_suffix[t] + ".root";
    TString coutput = coutput_common + OUTPUT_NAME;
    TFile* foutput = new TFile(coutput, "recreate");

    foutput->cd();

    TChain* tree = new TChain(TREE_NAME);
    TTree* templateTree = new TTree(TREE_NAME, TREE_NAME);

    float wPOLE=4.15e-3;
    if (t==3) wPOLE*=25;

    TString cinput = cinput_common + sample_suffix[t] + "/" + INPUT_NAME + sample_suffix[t] + ".root";
    tree->Add(cinput);

    templateTree->Branch("MC_weight", &templateWeight);
    templateTree->Branch("ZZMass", &ZZMass);
    templateTree->Branch("Z1Mass", &Z1Mass);
    templateTree->Branch("Z2Mass", &Z2Mass);
    //    templateTree->Branch("GenHMass", &GenHMass);
    templateTree->Branch("p0plus_VAJHU", &p0plus_VAJHU);
    templateTree->Branch("p0hplus_VAJHU", &p0hplus_VAJHU);
    templateTree->Branch("p0minus_VAJHU", &p0minus_VAJHU);
    templateTree->Branch("p0_g1prime2_VAJHU", &p0_g1prime2_VAJHU);
    templateTree->Branch("p0_g1prime4_VAJHU", &p0_g1prime4_VAJHU);
    templateTree->Branch("pg1g2_VAJHU", &pg1g2_VAJHU);
    templateTree->Branch("pg1g4_VAJHU", &pg1g4_VAJHU);
    templateTree->Branch("pg1g1prime2_VAJHU", &pg1g1prime2_VAJHU);
    templateTree->Branch("pg1g1prime4_VAJHU", &pg1g1prime4_VAJHU);

    //Making templates using appropriate weights
    //    tree->SetBranchAddress("ZZMass", &ZZMass);
    //    tree->SetBranchAddress("MC_weight", &MC_weight);
    tree->SetBranchAddress("GenZZMass", &GenHMass);
    tree->SetBranchAddress("GenLep1Id", &GenLep1Id);
    tree->SetBranchAddress("GenLep2Id", &GenLep2Id);
    tree->SetBranchAddress("GenLep3Id", &GenLep3Id);
    tree->SetBranchAddress("GenLep4Id", &GenLep4Id);
    tree->SetBranchAddress("GenLep1Pt", &GenLep1Pt);
    tree->SetBranchAddress("GenLep2Pt", &GenLep2Pt);
    tree->SetBranchAddress("GenLep3Pt", &GenLep3Pt);
    tree->SetBranchAddress("GenLep4Pt", &GenLep4Pt);
    tree->SetBranchAddress("GenLep1Phi", &GenLep1Phi);
    tree->SetBranchAddress("GenLep2Phi", &GenLep2Phi);
    tree->SetBranchAddress("GenLep3Phi", &GenLep3Phi);
    tree->SetBranchAddress("GenLep4Phi", &GenLep4Phi);
    tree->SetBranchAddress("GenLep1Eta", &GenLep1Eta);
    tree->SetBranchAddress("GenLep2Eta", &GenLep2Eta);
    tree->SetBranchAddress("GenLep3Eta", &GenLep3Eta);
    tree->SetBranchAddress("GenLep4Eta", &GenLep4Eta);
    tree->SetBranchAddress("GenLep1E", &GenLep1E);
    tree->SetBranchAddress("GenLep2E", &GenLep2E);
    tree->SetBranchAddress("GenLep3E", &GenLep3E);
    tree->SetBranchAddress("GenLep4E", &GenLep4E);

    if (tFitD != 0){
      if (tree->GetBranchStatus(strFitDim[tFitD])){
        tree->SetBranchAddress("Dgg10_VAMCFM", &fitYval);
        templateTree->Branch(strFitDim[tFitD], &fitYval);
      }
      else{
        cerr << "Could NOT find branch named " << strFitDim[tFitD] << "!!! Setting strFitDim[" << tFitD << "] = 0." << endl;
        fitYval = 0;
      }
    }

    nEntries = tree->GetEntries();
    double xsec = 1./nEntries;
    if (t==0) xsec *= xsec_ggHZZ_MCFM[EnergyIndex];
    else if (t==1) xsec *= xsec_ggZZ_MCFM[EnergyIndex];
    else if (t==2) xsec *= xsec_ggHZZ_BSI_MCFM[EnergyIndex];
    else if (t==3) xsec *= xsec_ggHZZ_BSI25_MCFM[EnergyIndex];
    else xsec = 1;
    if (folder<2) xsec *= 0.25;
    else xsec *= 0.5;

    //    for (int ev = 0; ev < 100; ev++){

    for (int ev = 0; ev < nEntries; ev++){
      tree->GetEntry(ev);
      ZZMass = GenHMass;
      MC_weight = xsec;

      if (fitYval != fitYval) continue;
      // Protect against any KD exceeding boundaries
      if (tFitD!=0 && fitYval>=1){
        cout << "Found fitYval == " << fitYval;
        fitYval = 0.999;
        cout << ". Fixed to " << fitYval << endl;
      }
      if (tFitD!=0 && fitYval<0) fitYval = 0;

      if (t < 4 && erg_tev==7){
        if (folder==1){
          GenLep1Id=11;
          GenLep2Id=-11;
          GenLep3Id=11;
          GenLep4Id=-11;
        }
        else if (folder==0){
          GenLep1Id=13;
          GenLep2Id=-13;
          GenLep3Id=13;
          GenLep4Id=-13;
        }
      }

      double weight = MC_weight;
      if (t < 4) weight *= tgkf->Eval(GenHMass);
      if (t < 4
        && abs(GenLep1Id)==abs(GenLep2Id)
        && abs(GenLep1Id)==abs(GenLep3Id)
        && abs(GenLep1Id)==abs(GenLep4Id)
        ) weight *= tg_interf->Eval(GenHMass);
      templateWeight = weight;

      float mzz = mPOLE;
      float m1 = 0;
      float m2 = 0;
      float h1 = 0;
      float h2 = 0;
      float phi = 0;
      float hs = 0;
      float phi1 = 0;

      GenLep1Mass = findLeptonMass(GenLep1Id);
      GenLep2Mass = findLeptonMass(GenLep2Id);
      GenLep3Mass = findLeptonMass(GenLep3Id);
      GenLep4Mass = findLeptonMass(GenLep4Id);

      TLorentzVector p1, p2, p3, p4;
      p1.SetPtEtaPhiE(GenLep1Pt, GenLep1Eta, GenLep1Phi, GenLep1E);
      p2.SetPtEtaPhiE(GenLep2Pt, GenLep2Eta, GenLep2Phi, GenLep2E);
      p3.SetPtEtaPhiE(GenLep3Pt, GenLep3Eta, GenLep3Phi, GenLep3E);
      p4.SetPtEtaPhiE(GenLep4Pt, GenLep4Eta, GenLep4Phi, GenLep4E);
      TLorentzVector pZ1 = p1+p2;
      TLorentzVector pZ2 = p3+p4;
      TLorentzVector pZ1p = p1+p4;
      TLorentzVector pZ2p = p3+p2;
      TLorentzVector pZZ = pZ1+pZ2;
      mzz=pZZ.M();
      m1=pZ1.M();
      m2=pZ2.M();
      Z1Mass = m1;
      Z2Mass=m2;
      if (Z1Mass>=120 || Z1Mass<=40) continue;
      if (Z2Mass>=120 || Z2Mass<=12) continue;
      if (!passAcceptance(GenLep1Pt, GenLep1Eta, (int)GenLep1Id)) continue;
      if (!passAcceptance(GenLep2Pt, GenLep2Eta, (int)GenLep2Id)) continue;
      if (!passAcceptance(GenLep3Pt, GenLep3Eta, (int)GenLep3Id)) continue;
      if (!passAcceptance(GenLep4Pt, GenLep4Eta, (int)GenLep4Id)) continue;
      if (pZ1.M()<=4 ||pZ2.M()<=4 ||pZ1p.M()<=4 ||pZ2p.M()<=4) continue;
      TLorentzVector pp[4] ={ p1, p2, p3, p4 };
      int pass20=-1;
      int pass10=-1;
      for (int vv=0; vv<4; vv++){
        if (pp[vv].Pt()>20){
          pass20=vv; break;
        }
      }
      for (int vv=0; vv<4; vv++){
        if (vv==pass20) continue;
        if (pp[vv].Pt()>10){
          pass10=vv; break;
        }
      }
      if (pass20<0 || pass10<0) continue;

      mela::computeAngles(p1, GenLep1Id,
        p2, GenLep2Id,
        p3, GenLep3Id,
        p4, GenLep4Id,
        hs,
        h1,
        h2,
        phi,
        phi1);
      int lepIdOrdered[4] ={ (int)GenLep1Id, (int)GenLep2Id, (int)GenLep3Id, (int)GenLep4Id };
      float angularOrdered[8] ={ mzz, m1, m2, hs, h1, h2, phi, phi1 };

      if (t==0) mela.setProcess(TVar::HSMHiggs, TVar::MCFM, TVar::ZZGG);
      if (t==2 || t==3) mela.setProcess(TVar::bkgZZ_SMHiggs, TVar::MCFM, TVar::ZZGG);
      if (t!=1){
        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[0][0]=1;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        p0plus_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[1][0]=1.638;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        p0hplus_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[3][0]=2.521;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        p0minus_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[11][0]=-12046.01;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        p0_g1prime2_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[13][0]=-pow(10000.0/mPOLE, 2);
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        p0_g1prime4_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);


        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[0][0]=1;
        selfDHvvcoupl[1][0]=1.638;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        pg1g2_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[0][0]=1;
        selfDHvvcoupl[3][0]=2.521;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        pg1g4_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[0][0]=1;
        selfDHvvcoupl[11][0]=-12046.01;
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        pg1g1prime2_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        for (int ii = 0; ii < SIZE_HVV; ii++){ for (int jj = 0; jj < 2; jj++) selfDHvvcoupl[ii][jj] = 0; }
        selfDHvvcoupl[0][0]=1;
        selfDHvvcoupl[13][0]=-pow(10000.0/mPOLE, 2);
        mela.setMelaLeptonInterference(TVar::InterfOn);
        mela.setMelaHiggsWidth(wPOLE);
        pg1g1prime4_VAJHU = getJHUGenMELAWeight(mela, lepIdOrdered, angularOrdered, selfDHvvcoupl);

        if (p0plus_VAJHU!=0){
          p0hplus_VAJHU/=p0plus_VAJHU;
          p0minus_VAJHU/=p0plus_VAJHU;
          p0_g1prime2_VAJHU/=p0plus_VAJHU;
          p0_g1prime4_VAJHU/=p0plus_VAJHU;

          pg1g2_VAJHU/=p0plus_VAJHU;
          pg1g4_VAJHU/=p0plus_VAJHU;
          pg1g1prime2_VAJHU/=p0plus_VAJHU;
          pg1g1prime4_VAJHU/=p0plus_VAJHU;
          p0plus_VAJHU=1;
        }
        else{
          p0plus_VAJHU=0;
          p0hplus_VAJHU=0;
          p0minus_VAJHU=0;
          p0_g1prime2_VAJHU=0;
          p0_g1prime4_VAJHU=0;

          pg1g2_VAJHU=0;
          pg1g4_VAJHU=0;
          pg1g1prime2_VAJHU=0;
          pg1g1prime4_VAJHU=0;
        }
      }
      else{
        p0plus_VAJHU=1;
        p0hplus_VAJHU=1;
        p0minus_VAJHU=1;
        p0_g1prime2_VAJHU=1;
        p0_g1prime4_VAJHU=1;

        pg1g2_VAJHU=1;
        pg1g4_VAJHU=1;
        pg1g1prime2_VAJHU=1;
        pg1g1prime4_VAJHU=1;
      }

      p0plus_VAJHU*=templateWeight;
      p0hplus_VAJHU*=templateWeight;
      p0minus_VAJHU*=templateWeight;
      p0_g1prime2_VAJHU*=templateWeight;
      p0_g1prime4_VAJHU*=templateWeight;

      pg1g2_VAJHU*=templateWeight;
      pg1g4_VAJHU*=templateWeight;
      pg1g1prime2_VAJHU*=templateWeight;
      pg1g1prime4_VAJHU*=templateWeight;

      templateTree->Fill();
    }

    foutput->WriteTObject(templateTree);
    delete tree;
    delete templateTree;
    foutput->Close();
  }

  delete tg_interf;
  delete tgkf;
  finput_KDFactor->Close();
}
Exemplo n.º 2
0
void createPlot(std::vector<TString> samples, std::vector<TString> files, std::vector<TString> legend)
{

  TString y_title = "Number of Entries";
  const int nHist = files.size(); // number of files

  // Declare the histograms to be saved 
  TH1F *h_mll[nHist];
  TH1F *h_dilpt[nHist];
  TH1F *h_dphill[nHist];
  TH1F *h_leadleppt[nHist];
  TH1F *h_trailleppt[nHist];
  TH1F *h_met[nHist];
  TH1F *h_mt[nHist];
  
  // Get the histograms from the ntuples
  for (int i=0;i<nHist;i++) {
    TString treeName = "angles";
    TChain *chain = new TChain(treeName);
    chain->Add(files[i]);
    assert(chain);
    
    // declare histograms  to fill
    Color_t color = kBlack;
    TString sampleName = samples[i];
    if ( sampleName.Contains("SMHiggs",TString::kExact )) color = kBlue;
    if ( sampleName.Contains("PSHiggs", TString::kExact)) color = kMagenta;
    if ( sampleName.Contains("T",  TString::kExact)) color = kRed;
    if ( sampleName.Contains("THiggs",  TString::kExact)) color = kRed;


    
    // define the histograms to plot
    
    // dilmass 
    h_mll[i] = new TH1F(TString("HWW_"+sampleName+"_hdilmass"), TString("HWW_"+sampleName+"_hdilmass"), 20, 0, 200);
    h_mll[i]->SetLineColor(color);
    h_mll[i]->SetMarkerColor(color);
    
    // leading lepton pT
    h_leadleppt[i] = new TH1F(TString("HWW_"+sampleName+"_hleadleppt"), TString("HWW_"+sampleName+"_hleadleppt"), 20, 0, 100);
    h_leadleppt[i]->SetLineColor(color);
    h_leadleppt[i]->SetMarkerColor(color);
   
    // trailing lepton pT
    h_trailleppt[i] = new TH1F(TString("HWW_"+sampleName+"_htrailleppt"), TString("HWW_"+sampleName+"_htrailleppt"), 20, 0, 100);
    h_trailleppt[i]->SetLineColor(color);
    h_trailleppt[i]->SetMarkerColor(color);
    
    // MET
    h_met[i] = new TH1F(TString("HWW_"+sampleName+"_hmet"), TString("HWW_"+sampleName+"_hmet"), 20, 0, 100);
    h_met[i]->SetLineColor(color);
    h_met[i]->SetMarkerColor(color);
    
    
    // dilepton pT
    h_dilpt[i] = new TH1F(TString("HWW_"+sampleName+"_hdilpt"), TString("HWW_"+sampleName+"_hdilpt"), 30, 20, 100);
    h_dilpt[i]->SetLineColor(color);
    h_dilpt[i]->SetMarkerColor(color);
    
    // deltaphi (ll)
    h_dphill[i] = new TH1F(TString("HWW_"+sampleName+"_hdphi"), TString("HWW_"+sampleName+"_hdphi"), 18, 0, 180.0);
    h_dphill[i]->SetLineColor(color);
    h_dphill[i]->SetMarkerColor(color);
    
    // transverse mass
    h_mt[i] = new TH1F(TString("HWW_"+sampleName+"_hmt"), TString("HWW_"+sampleName+"_hmt"), 20, 0, 200);
    h_mt[i]->SetLineColor(color);
    h_mt[i]->SetMarkerColor(color);
    

    std::cout  << "Processing " << chain->GetEntries() << " entries. \n";
    int nEntries =  chain->GetEntries() ;
    int nSelected = 0;
    
    // mcfm variables to be used
    double mll_ = 0.0;
    double leadleppt_ = 0.0;
    double trailleppt_ = 0.0;
    double leadlepeta_ = 0.0;
    double traillepeta_ = 0.0;
    double dphill_ = 0.0;
    double met_ = 0.0;
    double mt_ = 0.0;
    double dilpt_ = 0.0;
    double wt_ = 1.0;

    if (chain->GetBranchStatus("mll"))
      chain->SetBranchAddress("mll", &mll_);

    if (chain->GetBranchStatus("leadleppt"))
      chain->SetBranchAddress("leadleppt", &leadleppt_);

    if (chain->GetBranchStatus("trailleppt"))
      chain->SetBranchAddress("trailleppt", &trailleppt_);

    if (chain->GetBranchStatus("dphill"))
      chain->SetBranchAddress("dphill", &dphill_);

    if (chain->GetBranchStatus("met"))
      chain->SetBranchAddress("met", &met_);
    
    if (chain->GetBranchStatus("mt"))
      chain->SetBranchAddress("mt", &mt_);

    if (chain->GetBranchStatus("dilpt"))
      chain->SetBranchAddress("dilpt", &dilpt_);
    
      if (chain->GetBranchStatus("leadlepeta"))
      chain->SetBranchAddress("leadlepeta", &leadlepeta_);

    if (chain->GetBranchStatus("traillepeta"))
      chain->SetBranchAddress("traillepeta", &traillepeta_);

    if (chain->GetBranchStatus("wt"))
      chain->SetBranchAddress("wt", &wt_);
   
    for ( int ievt = 0; ievt < chain->GetEntries(); ievt++) {
      chain->GetEntry(ievt);
      
      //
      // apply WW selections
      // 
      
      if ( ievt == 0 ) 
	std::cout << leadleppt_ << "\t" << trailleppt_ << "\t" << dilpt_ << "\t" << met_ << "\t" << mll_ << "\n";

      float weight = wt_;

      if ( leadleppt_ < 20. ) continue;
      if ( trailleppt_ < 10. ) continue;
      if ( TMath::Abs(leadlepeta_) > 2.5) continue;
      if ( TMath::Abs(traillepeta_) > 2.5) continue;
      
      /*
      if ( dilpt_ < 45.) continue;
      if ( mll_ < 12.) continue;
      if ( met_ < 20.) continue;

      */
      
      h_mll[i]->Fill(mll_, weight);
      h_dilpt[i]->Fill(dilpt_, weight);
      h_dphill[i]->Fill(dphill_ * 180. / TMath::Pi(), weight);
      h_leadleppt[i]->Fill(leadleppt_, weight);
      h_trailleppt[i]->Fill(trailleppt_, weight);
      h_mt[i]->Fill(mt_, weight);
      h_met[i]->Fill(met_, weight);

      // 
      // apply HWW selections for 125 
      // 
      
      if ( higgselection(mH, mt_, mll_, dphill_, leadleppt_, trailleppt_) ) 
	nSelected++;
    } // end of event loop in each sample
    
    std::cout << Form("sample %s: selection effiency is %i / %i = %.2f\n", samples[i].Data(), nSelected, nEntries, float(nSelected)/float(nEntries));
  }
  
  drawsingle("mll", nHist, h_mll, samples, legend, "Dilepton Invariant Mass [GeV]");
  drawsingle("dphill", nHist, h_dphill, samples, legend, "#Delta#phi(leptons) [degrees]");
  drawsingle("mt", nHist, h_mt, samples, legend, "Transverse Higgs Mass [GeV]");
  drawsingle("met", nHist, h_met, samples, legend, "Transverse Missing Energy [GeV]");
  drawsingle("dilpt", nHist, h_dilpt, samples, legend, "Dilepton pT [GeV]");
  
  output_file->cd();
  
  for(int i=0;i<nHist;i++) {
    h_mll[i]->Write();
    h_dphill[i]->Write();
    h_leadleppt[i]->Write();
    h_trailleppt[i]->Write();
    h_met[i]->Write();
    h_mt[i]->Write();
    h_dilpt[i]->Write();
    
  }
  
  // tidy up
  
  for ( int i = 0; i<nHist;i++) {
    delete h_mll[i];
    delete h_dphill[i];
    delete h_leadleppt[i];
    delete h_trailleppt[i];
    delete h_met[i];
    delete h_mt[i];
    delete h_dilpt[i];
  }

}
Exemplo n.º 3
0
void analyzer (TString inputFileName,TString outputFileName, TString runPeriod, bool isData, bool isSignal, unsigned maxEvents)
{
  using namespace std;

  ///////////////////
  // Configuration

  float minMmm = 110;
  float maxMmm = 160;

  //gErrorIgnoreLevel = kError;
  const unsigned ISMEAR = 2;

  ///////////////////////////
  // Output Histograms

  setStyle();

  TH1F* dimuonMassHist = new TH1F("dimuonMass","",50,110,160);
  setHistTitles(dimuonMassHist,"M(#mu#mu) [GeV/c^{2}]","Events");
  dimuonMassHist->Sumw2();
  TH1F* nJetsHist = new TH1F("nJets","",10,0,10);
  setHistTitles(nJetsHist,"N_{Jets}","Events");
  nJetsHist->Sumw2();

  ///////////////////////////
  Double_t MASS_MUON = 0.105658367;    //GeV/c2

  //////////////////////////
  // Tree Branches
  cout << "Analyzing filename: "<< inputFileName.Data() << endl;
  if (isData)
    cout << "isData\n";
  if (isSignal)
    cout << "isSignal\n";

  TChain * tree = new TChain("tree");
  tree->Add(inputFileName);


  // These are the names of the muons (See src/DataFormats.h for definitions!)
  _MuonInfo reco1, reco2;

  tree->SetBranchAddress("reco1", &reco1);
  tree->SetBranchAddress("reco2", &reco2);

  // These are the dimuon mass, pt, rapidity, and phi
  float recoCandMass, recoCandPt, recoCandY, recoCandPhi;
  float recoCandMassRes, recoCandMassResCov;

  tree->SetBranchAddress("recoCandMass",       &recoCandMass);
  tree->SetBranchAddress("recoCandPt",         &recoCandPt);
  tree->SetBranchAddress("recoCandY",          &recoCandY);
  tree->SetBranchAddress("recoCandPhi",        &recoCandPhi);
  tree->SetBranchAddress("recoCandMassRes",    &recoCandMassRes);
  tree->SetBranchAddress("recoCandMassResCov", &recoCandMassResCov);

  // MC truth info
  float trueMass=-99999.0;
  if(!isData && tree->GetBranchStatus("trueMass"))
    tree->SetBranchAddress("trueMass", &trueMass);

  /// Higgs Boson MC truth info (after FSR)
  _genPartInfo genHpostFSR;
  if(!isData && tree->GetBranchStatus("genHpostFSR"))
    tree->SetBranchAddress("genHpostFSR", &genHpostFSR);

  _TrackInfo reco1GenPostFSR;
  if(!isData && tree->GetBranchStatus("genM1HpostFSR"))
    tree->SetBranchAddress("genM1HpostFSR", &reco1GenPostFSR);

  _TrackInfo reco2GenPostFSR;
  if(!isData && tree->GetBranchStatus("genM2HpostFSR"))
    tree->SetBranchAddress("genM2HpostFSR", &reco2GenPostFSR);

  /// the jet collection
  // these 'rawJets' already have Loose Jet ID applied, and JES corrections
  // and are cross-cleaned of tight muons
  // later, jets will have JER corrections, PUID, and basic cuts applied
  _PFJetInfo rawJets;
  tree->SetBranchAddress("pfJets",&rawJets);

  float puJetFullDisc[10];
  float puJetSimpleDisc[10];
  float puJetCutDisc[10];

  tree->SetBranchAddress("puJetFullDisc",&puJetFullDisc);
  tree->SetBranchAddress("puJetSimpleDisc",&puJetSimpleDisc);
  tree->SetBranchAddress("puJetCutDisc",&puJetCutDisc);

  float puJetFullId[10];
  float puJetSimpleId[10];
  float puJetCutId[10];

  tree->SetBranchAddress("puJetFullId",&puJetFullId);
  tree->SetBranchAddress("puJetSimpleId",&puJetSimpleId);
  tree->SetBranchAddress("puJetCutId",&puJetCutId);

  int nPU=0;
  if (!isData)
    {
      tree->SetBranchAddress("nPU",&nPU);
    }
  _VertexInfo vertexInfo;
  tree->SetBranchAddress("vertexInfo",&vertexInfo);
  _EventInfo eventInfo;
  tree->SetBranchAddress("eventInfo",&eventInfo);

  // Be careful, the met has not been well validated
  _MetInfo met;
  tree->SetBranchAddress("met",&met);

  //////////////////////////
  //for PU reweighting

  reweight::LumiReWeighting lumiWeights("pileupDists/PileUpHistMC2012Summer50nsPoissonOOTPU.root","pileupDists/PileUpHist2012ABCD.root","pileup","pileup");
  if (runPeriod == "7TeV")
  {
    cout << "Using 2011AB PU reweighting\n";
    lumiWeights = reweight::LumiReWeighting("pileupDists/PileUpHistMCFall11.root","pileupDists/PileUpHist2011AB.root","pileup","pileup");
  }
  else
  {
    cout << "Using 2012ABCD PU reweighting\n";
  }

  ///////////////////////////////
  // Which Muon Selection to Use

  bool (*muonIdFuncPtr)(_MuonInfo&);
  if (runPeriod == "7TeV")
    {
      cout << "Using 2011 Tight Muon Selection\n";
      muonIdFuncPtr = &isKinTight_2011_noIso;
    }
  else
    {
      cout << "Using 2012 Tight Muon Selection\n";
      muonIdFuncPtr = &isKinTight_2012_noIso;
    }

  /////////////////////////
  // Smearing
  SmearingTool *smearPT = new SmearingTool();
  SmearingTool2011 *smearPT2011 = new SmearingTool2011();

  /////////////////////////////
  /////////////////////////////

  unsigned nEvents = tree->GetEntries();
  unsigned reportEach=1000;
  if (nEvents/1000>reportEach)
    reportEach = nEvents/1000;

  ///////////////////////////////
  ///////////////////////////////
  ///////////////////////////////
  // Event Loop

  for(unsigned i=0; i<nEvents;i++)
  {
    if(i >= maxEvents)
      break;

    tree->GetEvent(i);
    if (i % reportEach == 0) cout << "Event: " << i << endl;

    // Reject events with invalid muons
    if (reco1.pt < 0. || reco2.pt < 0.)
        continue;

    /////////////////////////////////////////////////
    // Muon Resolution Smearing to match MuScleFit

    if(isSignal) // smear only signal because it has muons from higgs 
    {
      if(reco1GenPostFSR.pt<0.)
        cout << "Muon 1 Post FSR not valid!\n";
      if(reco2GenPostFSR.pt<0.)
        cout << "Muon 2 Post FSR not valid!\n";
      float ptReco1 = -1.;
      float ptReco2 = -1.;
      if(runPeriod == "7TeV")
      {
        ptReco1 = smearPT2011 -> PTsmear(reco1GenPostFSR.pt, reco1GenPostFSR.eta, reco1GenPostFSR.charge, reco1.pt, ISMEAR);
        ptReco2 = smearPT2011 -> PTsmear(reco2GenPostFSR.pt, reco2GenPostFSR.eta, reco2GenPostFSR.charge, reco2.pt, ISMEAR);
      }
      else
      {
        ptReco1 = smearPT -> PTsmear(reco1GenPostFSR.pt, reco1GenPostFSR.eta, reco1GenPostFSR.charge, reco1.pt, ISMEAR);
        ptReco2 = smearPT -> PTsmear(reco2GenPostFSR.pt, reco2GenPostFSR.eta, reco2GenPostFSR.charge, reco2.pt, ISMEAR);
      }
      TLorentzVector reco1Vec;
      TLorentzVector reco2Vec;
      reco1Vec.SetPtEtaPhiM(ptReco1,reco1.eta,reco1.phi,MASS_MUON);
      reco2Vec.SetPtEtaPhiM(ptReco2,reco2.eta,reco2.phi,MASS_MUON);
      TLorentzVector diMuonVec = reco1Vec + reco2Vec;

      reco1.pt = ptReco1;
      reco2.pt = ptReco2;
      recoCandMass = diMuonVec.M();
      recoCandPt = diMuonVec.Pt();
      recoCandY = diMuonVec.Rapidity();
      recoCandPhi = diMuonVec.Phi();
    
      reco1Vec.SetPtEtaPhiM(ptReco1,reco1.eta,reco1.phi,MASS_MUON);
      reco2Vec.SetPtEtaPhiM(ptReco2,reco2.eta,reco2.phi,MASS_MUON);
      diMuonVec = reco1Vec + reco2Vec;
    }

    //////////////////////////////////////////
    // Muon-related cuts

    if (recoCandMass > maxMmm || recoCandMass < minMmm)
        continue;

    bool muon1PassId = (*muonIdFuncPtr)(reco1);
    bool muon2PassId = (*muonIdFuncPtr)(reco2);
    if ( !(muon1PassId && muon2PassId))
        continue;

    bool muon1PassIso = (getPFRelIso(reco1) <= 0.12);
    bool muon2PassIso = (getPFRelIso(reco2) <= 0.12);
    if ( !(muon1PassIso && muon2PassIso))
        continue;

    // Order muons by pt
    if (reco1.pt < reco2.pt)
    {
      _MuonInfo tmpMuon = reco1;
      reco1 = reco2;
      reco1 = tmpMuon;
    }

    // PU reweight
    float weight = 1.;
    if (!isData)
    {
      weight *= lumiWeights.weight(nPU);
    }

    // Jet Part
    // Do basic selection on jets and JER corrections
    std::vector<TLorentzVector> jets;
    std::vector<TLorentzVector> genJets;
    const float jetPtCut = 30.;
    const float jetAbsEtaCut = 4.7;
    const int jetPUIDCut = 4; // >=    tight = 7, medium = 6, loose = 4. Only loose is useful!!
    for(unsigned iJet=0; (iJet < unsigned(rawJets.nJets) && iJet < 10);iJet++)
    {
      // apply jet energy resolution corrections
      if (rawJets.genPt[iJet]>0.0 && rawJets.pt[iJet]>15.)
        rawJets.pt[iJet] = jerCorr(rawJets.pt[iJet],rawJets.genPt[iJet],rawJets.eta[iJet]); 
      bool goodPt = rawJets.pt[iJet]>jetPtCut;
      bool goodEta = fabs(rawJets.eta[iJet])<jetAbsEtaCut;
      bool goodPUID = puJetFullId[iJet] >= jetPUIDCut;
      if (goodPt && goodEta && goodPUID)
      {
        TLorentzVector tmpJetVec;
        tmpJetVec.SetPtEtaPhiM(rawJets.pt[iJet],rawJets.eta[iJet],rawJets.phi[iJet],rawJets.mass[iJet]);
        jets.push_back(tmpJetVec);
        TLorentzVector tmpGenJetVec;
        tmpGenJetVec.SetPtEtaPhiM(rawJets.genPt[iJet],rawJets.genEta[iJet],rawJets.genPhi[iJet],rawJets.genMass[iJet]);
        genJets.push_back(tmpGenJetVec);
      }
    }

//    /////////////////////////////////////////////
//
//    cout << "Event: "<< eventInfo.run << ":" << eventInfo.event << endl;
//
//    // print muon-related info
//    cout << "recoCandMass: " << recoCandMass << endl;
//    cout << "muon Pt1: " << reco1.pt << endl;
//    cout << "muon Pt2: " << reco2.pt << endl;
//    cout << "muon eta1: " << reco1.eta << endl;
//    cout << "muon eta2: " << reco2.eta << endl;
//    cout << "muon iso1: " << getPFRelIso(reco1) << endl;
//    cout << "muon iso2: " << getPFRelIso(reco2) << endl;
//    cout << "PU weight: " << weight << endl;
//    cout << endl;
//
//    // print jet-related info
//    cout << "nJets: " << jets.size() << endl;
//    for (unsigned iJet=0; iJet < jets.size(); iJet++)
//    {
//      cout << "Jet "<<(iJet+1)<<": pt="<< jets[iJet].Pt() << " eta="<<jets[iJet].Eta()<<endl;
//    }
//    cout << endl;
//
//    /////////////////////////////////////////////
      // Fill Histograms

      dimuonMassHist->Fill(recoCandMass,weight);
      nJetsHist->Fill(jets.size(),weight);

  }

  TFile* outFile = new TFile(outputFileName,"RECREATE");
  outFile->cd();
  dimuonMassHist->Write();
  nJetsHist->Write();

}