コード例 #1
0
ファイル: example_N_Wlnu.C プロジェクト: crogan/RestFrames
void example_N_Wlnu(const std::string& output_name =
		    "output_example_N_Wlnu.root"){

  double mW   = 80.385;  // GeV, PDG 2016
  double wW   = 2.085;
  double mL   = 0.106;   // muons
  double mN   = 0.;

  // number of events to generate (for each W multiplicity)
  int Ngen = 10000;

  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing generator frames and tree..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  
  ppLabGenFrame     LAB_G2W("LAB_G2W","LAB");      ppLabGenFrame     LAB_G3W("LAB_G3W","LAB");
  DecayGenFrame     CM_G2W("CM_G2W","CM");         DecayGenFrame     CM_G3W("CM_G3W","CM");
  ResonanceGenFrame Wa_G2W("Wa_G2W","W_{a}");      ResonanceGenFrame Wa_G3W("Wa_G3W","W_{a}");
  ResonanceGenFrame Wb_G2W("Wb_G2W","W_{b}");      ResonanceGenFrame Wb_G3W("Wb_G3W","W_{b}");
                                                   ResonanceGenFrame Wc_G3W("Wc_G3W","W_{c}");
  VisibleGenFrame   La_G2W("La_G2W","#it{l}_{a}"); VisibleGenFrame   La_G3W("La_G3W","#it{l}_{a}");
  InvisibleGenFrame Na_G2W("Na_G2W","#nu_{a}");    InvisibleGenFrame Na_G3W("Na_G3W","#nu_{a}");
  VisibleGenFrame   Lb_G2W("Lb_G2W","#it{l}_{b}"); VisibleGenFrame   Lb_G3W("Lb_G3W","#it{l}_{b}");
  InvisibleGenFrame Nb_G2W("Nb_G2W","#nu_{b}");    InvisibleGenFrame Nb_G3W("Nb_G3W","#nu_{b}");
                                                   VisibleGenFrame   Lc_G3W("Lc_G3W","#it{l}_{c}");
                                                   InvisibleGenFrame Nc_G3W("Nc_G3W","#nu_{c}");

  ppLabGenFrame     LAB_G4W("LAB_G4W","LAB");     
  DecayGenFrame     CM_G4W("CM_G4W","CM");        
  ResonanceGenFrame Wa_G4W("Wa_G4W","W_{a}");     
  ResonanceGenFrame Wb_G4W("Wb_G4W","W_{b}");    
  ResonanceGenFrame Wc_G4W("Wc_G4W","W_{c}");
  ResonanceGenFrame Wd_G4W("Wd_G4W","W_{d}");
  VisibleGenFrame   La_G4W("La_G4W","#it{l}_{a}"); 
  InvisibleGenFrame Na_G4W("Na_G4W","#nu_{a}");   
  VisibleGenFrame   Lb_G4W("Lb_G4W","#it{l}_{b}");
  InvisibleGenFrame Nb_G4W("Nb_G4W","#nu_{b}");
  VisibleGenFrame   Lc_G4W("Lc_G4W","#it{l}_{c}");
  InvisibleGenFrame Nc_G4W("Nc_G4W","#nu_{c}");
  VisibleGenFrame   Ld_G4W("Ld_G4W","#it{l}_{d}");
  InvisibleGenFrame Nd_G4W("Nd_G4W","#nu_{d}");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
  
  LAB_G2W.SetChildFrame(CM_G2W);                   LAB_G3W.SetChildFrame(CM_G3W);
  CM_G2W.AddChildFrame(Wa_G2W);                    CM_G3W.AddChildFrame(Wa_G3W);
  CM_G2W.AddChildFrame(Wb_G2W);                    CM_G3W.AddChildFrame(Wb_G3W);
  Wa_G2W.AddChildFrame(La_G2W);                    CM_G3W.AddChildFrame(Wc_G3W);
  Wa_G2W.AddChildFrame(Na_G2W);                    Wa_G3W.AddChildFrame(La_G3W);
  Wb_G2W.AddChildFrame(Lb_G2W);                    Wa_G3W.AddChildFrame(Na_G3W);
  Wb_G2W.AddChildFrame(Nb_G2W);                    Wb_G3W.AddChildFrame(Lb_G3W);
                                                   Wb_G3W.AddChildFrame(Nb_G3W);
  LAB_G4W.SetChildFrame(CM_G4W);                   Wc_G3W.AddChildFrame(Lc_G3W);
  CM_G4W.AddChildFrame(Wa_G4W);                    Wc_G3W.AddChildFrame(Nc_G3W);                               
  CM_G4W.AddChildFrame(Wb_G4W);
  CM_G4W.AddChildFrame(Wc_G4W);
  CM_G4W.AddChildFrame(Wd_G4W);
  Wa_G4W.AddChildFrame(La_G4W);
  Wa_G4W.AddChildFrame(Na_G4W);
  Wb_G4W.AddChildFrame(Lb_G4W);
  Wb_G4W.AddChildFrame(Nb_G4W);
  Wc_G4W.AddChildFrame(Lc_G4W);
  Wc_G4W.AddChildFrame(Nc_G4W);
  Wd_G4W.AddChildFrame(Ld_G4W);
  Wd_G4W.AddChildFrame(Nd_G4W);

  if(LAB_G2W.InitializeTree() && LAB_G3W.InitializeTree() &&
     LAB_G4W.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized generator trees" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator trees" << LogEnd;

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
  
  // non-resonant production
  CM_G2W.SetVariableMass(true); CM_G3W.SetVariableMass(true); CM_G4W.SetVariableMass(true);
  // set W masses and widths
  Wa_G2W.SetMass(mW);  Wb_G2W.SetMass(mW);
  Wa_G3W.SetMass(mW);  Wb_G3W.SetMass(mW);  Wc_G3W.SetMass(mW);
  Wa_G4W.SetMass(mW);  Wb_G4W.SetMass(mW);  Wc_G4W.SetMass(mW);   Wd_G4W.SetMass(mW);
  Wa_G2W.SetWidth(wW); Wb_G2W.SetWidth(wW);
  Wa_G3W.SetWidth(wW); Wb_G3W.SetWidth(wW); Wc_G3W.SetWidth(wW);
  Wa_G4W.SetWidth(wW); Wb_G4W.SetWidth(wW); Wc_G4W.SetWidth(wW); Wd_G4W.SetWidth(wW);
  // set lepton masses
  La_G2W.SetMass(mL);  Lb_G2W.SetMass(mL);
  La_G3W.SetMass(mL);  Lb_G3W.SetMass(mL);  Lc_G3W.SetMass(mL);
  La_G4W.SetMass(mL);  Lb_G4W.SetMass(mL);  Lc_G4W.SetMass(mL);  Ld_G4W.SetMass(mL);
  // set neutrino masses
  Na_G2W.SetMass(mN);  Nb_G2W.SetMass(mN);
  Na_G3W.SetMass(mN);  Nb_G3W.SetMass(mN);  Nc_G3W.SetMass(mN);
  Na_G4W.SetMass(mN);  Nb_G4W.SetMass(mN);  Nc_G4W.SetMass(mN);  Nd_G4W.SetMass(mN);

  // lepton pT/eta cuts
  La_G2W.SetPtCut(15.);  Lb_G2W.SetPtCut(15.);
  La_G2W.SetEtaCut(2.5); Lb_G2W.SetEtaCut(2.5);
  La_G3W.SetPtCut(15.);  Lb_G3W.SetPtCut(15.);  Lc_G3W.SetPtCut(15.);
  La_G3W.SetEtaCut(2.5); Lb_G3W.SetEtaCut(2.5); Lc_G3W.SetEtaCut(2.5);
  La_G4W.SetPtCut(15.);  Lb_G4W.SetPtCut(15.);  Lc_G4W.SetPtCut(15.);  Ld_G4W.SetPtCut(15.);
  La_G4W.SetEtaCut(2.5); Lb_G4W.SetEtaCut(2.5); Lc_G4W.SetEtaCut(2.5); Ld_G4W.SetEtaCut(2.5);
  
  if(LAB_G2W.InitializeAnalysis() && LAB_G3W.InitializeAnalysis() &&
     LAB_G4W.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized generator analyses" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator analyses" << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////////////////

  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing reconstruction frames and trees..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////

  LabRecoFrame       LAB_2W("LAB_2W","LAB");       LabRecoFrame       LAB_3W("LAB_3W","LAB");
  DecayRecoFrame     CM_2W("CM_2W","CM");          DecayRecoFrame     CM_3W("CM_3W","CM");
  DecayRecoFrame     Wa_2W("Wa_2W","W_{a}");       DecayRecoFrame     Wa_3W("Wa_3W","W_{a}");
  DecayRecoFrame     Wb_2W("Wb_2W","W_{b}");       DecayRecoFrame     Wb_3W("Wb_3W","W_{b}");
                                                   DecayRecoFrame     Wc_3W("Wc_3W","W_{c}");
  VisibleRecoFrame   La_2W("La_2W","#it{l}_{a}");  VisibleRecoFrame   La_3W("La_3W","#it{l}_{a}");
  InvisibleRecoFrame Na_2W("Na_2W","#nu_{a}");     InvisibleRecoFrame Na_3W("Na_3W","#nu_{a}");
  VisibleRecoFrame   Lb_2W("Lb_2W","#it{l}_{b}");  VisibleRecoFrame   Lb_3W("Lb_3W","#it{l}_{b}");
  InvisibleRecoFrame Nb_2W("Nb_2W","#nu_{b}");     InvisibleRecoFrame Nb_3W("Nb_3W","#nu_{b}");
                                                   VisibleRecoFrame   Lc_3W("Lc_3W","#it{l}_{c}");
                                                   InvisibleRecoFrame Nc_3W("Nc_3W","#nu_{c}");

  LabRecoFrame       LAB_4W("LAB_4W","LAB");     
  DecayRecoFrame     CM_4W("CM_4W","CM");        
  DecayRecoFrame     Wa_4W("Wa_4W","W_{a}");     
  DecayRecoFrame     Wb_4W("Wb_4W","W_{b}");    
  DecayRecoFrame     Wc_4W("Wc_4W","W_{c}");
  DecayRecoFrame     Wd_4W("Wd_4W","W_{d}");
  VisibleRecoFrame   La_4W("La_4W","#it{l}_{a}"); 
  InvisibleRecoFrame Na_4W("Na_4W","#nu_{a}");   
  VisibleRecoFrame   Lb_4W("Lb_4W","#it{l}_{b}");
  InvisibleRecoFrame Nb_4W("Nb_4W","#nu_{b}");
  VisibleRecoFrame   Lc_4W("Lc_4W","#it{l}_{c}");
  InvisibleRecoFrame Nc_4W("Nc_4W","#nu_{c}");
  VisibleRecoFrame   Ld_4W("Ld_4W","#it{l}_{d}");
  InvisibleRecoFrame Nd_4W("Nd_4W","#nu_{d}");
  
  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
  
  LAB_2W.SetChildFrame(CM_2W);                   LAB_3W.SetChildFrame(CM_3W);
  CM_2W.AddChildFrame(Wa_2W);                    CM_3W.AddChildFrame(Wa_3W);
  CM_2W.AddChildFrame(Wb_2W);                    CM_3W.AddChildFrame(Wb_3W);
  Wa_2W.AddChildFrame(La_2W);                    CM_3W.AddChildFrame(Wc_3W);
  Wa_2W.AddChildFrame(Na_2W);                    Wa_3W.AddChildFrame(La_3W);
  Wb_2W.AddChildFrame(Lb_2W);                    Wa_3W.AddChildFrame(Na_3W);
  Wb_2W.AddChildFrame(Nb_2W);                    Wb_3W.AddChildFrame(Lb_3W);
                                                 Wb_3W.AddChildFrame(Nb_3W);
  LAB_4W.SetChildFrame(CM_4W);                   Wc_3W.AddChildFrame(Lc_3W);
  CM_4W.AddChildFrame(Wa_4W);                    Wc_3W.AddChildFrame(Nc_3W);                               
  CM_4W.AddChildFrame(Wb_4W);
  CM_4W.AddChildFrame(Wc_4W);
  CM_4W.AddChildFrame(Wd_4W);
  Wa_4W.AddChildFrame(La_4W);
  Wa_4W.AddChildFrame(Na_4W);
  Wb_4W.AddChildFrame(Lb_4W);
  Wb_4W.AddChildFrame(Nb_4W);
  Wc_4W.AddChildFrame(Lc_4W);
  Wc_4W.AddChildFrame(Nc_4W);
  Wd_4W.AddChildFrame(Ld_4W);
  Wd_4W.AddChildFrame(Nd_4W);

  if(LAB_2W.InitializeTree() && LAB_3W.InitializeTree() &&
     LAB_4W.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized reconstruction trees" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing reconstruction trees" << LogEnd;
 
  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  // Invisible Groups
  InvisibleGroup INV_2W("INV_2W","#nu #nu Jigsaws");
  INV_2W.AddFrame(Na_2W);
  INV_2W.AddFrame(Nb_2W);
  InvisibleGroup INV_3W("INV_3W","#nu #nu #nu Jigsaws");
  INV_3W.AddFrame(Na_3W);
  INV_3W.AddFrame(Nb_3W);
  INV_3W.AddFrame(Nc_3W);
  InvisibleGroup INV_4W("INV_4W","#nu #nu #nu #nu Jigsaws");
  INV_4W.AddFrame(Na_4W);
  INV_4W.AddFrame(Nb_4W);
  INV_4W.AddFrame(Nc_4W);
  INV_4W.AddFrame(Nd_4W);

  // Set N nu mass equal to ~ N lep mass
  SetMassInvJigsaw NuNuM_2W("NuNuM_2W", "M_{#nu#nu} ~ m_{#it{l}#it{l}}");
  INV_2W.AddJigsaw(NuNuM_2W);
  SetMassInvJigsaw NuNuM_3W("NuNuM_3W", "M_{#nu#nu#nu} ~ m_{#it{l}#it{l}#it{l}}");
  INV_3W.AddJigsaw(NuNuM_3W);
  SetMassInvJigsaw NuNuM_4W("NuNuM_4W", "M_{#nu#nu#nu#nu} ~ m_{#it{l}#it{l}#it{l}#it{l}}");
  INV_4W.AddJigsaw(NuNuM_4W);

  // Set N nu rapidity equal to N lep rapidity
  SetRapidityInvJigsaw NuNuR_2W("NuNuR_2W", "#eta_{#nu#nu} = #eta_{#it{l}#it{l}}");
  INV_2W.AddJigsaw(NuNuR_2W);
  NuNuR_2W.AddVisibleFrames(La_2W+Lb_2W);
  SetRapidityInvJigsaw NuNuR_3W("NuNuR_3W", "#eta_{#nu#nu#nu} = #eta_{#it{l}#it{l}#it{l}}");
  INV_3W.AddJigsaw(NuNuR_3W);
  NuNuR_3W.AddVisibleFrames(La_3W+Lb_3W+Lc_3W);
  SetRapidityInvJigsaw NuNuR_4W("NuNuR_4W", "#eta_{#nu#nu#nu#nu} = #eta_{#it{l}#it{l}#it{l}#it{l}}");
  INV_4W.AddJigsaw(NuNuR_4W);
  NuNuR_4W.AddVisibleFrames(La_4W+Lb_4W+Lc_4W+Ld_4W);

  // Set neutrino 4-vectors by minimizing N W masses ^2
  MinMassesSqInvJigsaw MinMW_2W("MinMW_2W","min #Sigma M_{W}^{ 2}", 2);
  INV_2W.AddJigsaw(MinMW_2W);
  MinMW_2W.AddVisibleFrame(La_2W, 0);   MinMW_2W.AddInvisibleFrame(Na_2W, 0);
  MinMW_2W.AddVisibleFrame(Lb_2W, 1);   MinMW_2W.AddInvisibleFrame(Nb_2W, 1);
  MinMassesSqInvJigsaw MinMW_3W("MinMW_3W","min #Sigma M_{W}^{ 2}", 3);
  INV_3W.AddJigsaw(MinMW_3W);
  MinMW_3W.AddVisibleFrame(La_3W, 0);   MinMW_3W.AddInvisibleFrame(Na_3W, 0);
  MinMW_3W.AddVisibleFrame(Lb_3W, 1);   MinMW_3W.AddInvisibleFrame(Nb_3W, 1);
  MinMW_3W.AddVisibleFrame(Lc_3W, 2);   MinMW_3W.AddInvisibleFrame(Nc_3W, 2);
  MinMassesSqInvJigsaw MinMW_4W("MinMW_4W","min #Sigma M_{W}^{ 2}", 4);
  INV_4W.AddJigsaw(MinMW_4W);
  MinMW_4W.AddVisibleFrame(La_4W, 0);   MinMW_4W.AddInvisibleFrame(Na_4W, 0);
  MinMW_4W.AddVisibleFrame(Lb_4W, 1);   MinMW_4W.AddInvisibleFrame(Nb_4W, 1);
  MinMW_4W.AddVisibleFrame(Lc_4W, 2);   MinMW_4W.AddInvisibleFrame(Nc_4W, 2);
  MinMW_4W.AddVisibleFrame(Ld_4W, 3);   MinMW_4W.AddInvisibleFrame(Nd_4W, 3);

  if(LAB_2W.InitializeAnalysis() && LAB_3W.InitializeAnalysis() &&
     LAB_4W.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized analyses" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing analyses" << LogEnd;

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

  TreePlot* treePlot = new TreePlot("TreePlot","TreePlot");
  
  treePlot->SetTree(CM_2W);
  treePlot->Draw("Reco_2W_Tree", "2W Reconstruction Tree");

  treePlot->SetTree(CM_3W);
  treePlot->Draw("Reco_3W_Tree", "3W Reconstruction Tree");

  treePlot->SetTree(CM_4W);
  treePlot->Draw("Reco_4W_Tree", "4W Reconstruction Tree");

  treePlot->SetTree(INV_2W);
  treePlot->Draw("Inv_2W_Tree", "2W Inivisible Jigsaws", true);

  treePlot->SetTree(INV_3W);
  treePlot->Draw("Inv_3W_Tree", "3W Inivisible Jigsaws", true);

  treePlot->SetTree(INV_4W);
  treePlot->Draw("Inv_4W_Tree", "4W Inivisible Jigsaws", true);

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
  
  HistPlot* histPlot   = new HistPlot("HistPlot","pp #rightarrow N W(#it{l} #nu)");

  const HistPlotCategory& cat_2W = histPlot->GetNewCategory("Reco_2W", "2 W(#it{l} #nu)");
  const HistPlotCategory& cat_3W = histPlot->GetNewCategory("Reco_3W", "3 W(#it{l} #nu)");
  const HistPlotCategory& cat_4W = histPlot->GetNewCategory("Reco_4W", "4 W(#it{l} #nu)");

  const HistPlotVar& MCM    = histPlot->GetNewVar("MCM", "M_{CM} / m_{CM}^{ true}", 0., 2.);
  const HistPlotVar& sumMW2 = histPlot->GetNewVar("MWTOT",
		   "#sqrt{#Sigma M_{W}^{ 2} / #Sigma m_{W, true}^{ 2}}", 0., 1.5);
  double sumMW2gen;
  
  histPlot->AddPlot(MCM,    cat_2W+cat_3W+cat_4W);
  histPlot->AddPlot(sumMW2, cat_2W+cat_3W+cat_4W);
  histPlot->AddPlot(MCM, sumMW2, cat_2W+cat_3W+cat_4W);

  
  for(int igen = 0; igen < Ngen; igen++){
    if(igen%(Ngen/10) == 0) 
      g_Log << LogInfo << "Generating event " << igen << " of " << Ngen << LogEnd;

    // generate event
    LAB_G2W.ClearEvent();                            // clear the gen tree;
    LAB_G2W.AnalyzeEvent();                          // generate a new event
    LAB_G3W.ClearEvent();                                   
    LAB_G3W.AnalyzeEvent();                         
    LAB_G4W.ClearEvent();                                
    LAB_G4W.AnalyzeEvent();                        

    TVector3 MET_2W = LAB_G2W.GetInvisibleMomentum();  // Get the MET from gen tree
    MET_2W.SetZ(0.);
    TVector3 MET_3W = LAB_G3W.GetInvisibleMomentum();  
    MET_3W.SetZ(0.);
    TVector3 MET_4W = LAB_G4W.GetInvisibleMomentum(); 
    MET_4W.SetZ(0.);

    // analyze event(s)
    LAB_2W.ClearEvent();                                  // clear the reco tree
    INV_2W.SetLabFrameThreeVector(MET_2W);                // Set the MET in reco tree
    LAB_3W.ClearEvent();                              
    INV_3W.SetLabFrameThreeVector(MET_3W);            
    LAB_4W.ClearEvent();                           
    INV_4W.SetLabFrameThreeVector(MET_4W);              

    La_2W.SetLabFrameFourVector(La_G2W.GetFourVector());  // Set "measured" lep 4-vectors
    Lb_2W.SetLabFrameFourVector(Lb_G2W.GetFourVector());
    La_3W.SetLabFrameFourVector(La_G3W.GetFourVector()); 
    Lb_3W.SetLabFrameFourVector(Lb_G3W.GetFourVector());
    Lc_3W.SetLabFrameFourVector(Lc_G3W.GetFourVector());
    La_4W.SetLabFrameFourVector(La_G4W.GetFourVector()); 
    Lb_4W.SetLabFrameFourVector(Lb_G4W.GetFourVector());
    Lc_4W.SetLabFrameFourVector(Lc_G4W.GetFourVector());
    Ld_4W.SetLabFrameFourVector(Ld_G4W.GetFourVector());

    LAB_2W.AnalyzeEvent();                                // analyze the event
    LAB_3W.AnalyzeEvent();
    LAB_4W.AnalyzeEvent();
    
    //////////////////////////////////////
    // Observable Calculations
    //////////////////////////////////////
    
    MCM = CM_2W.GetMass()/CM_G2W.GetMass();
    sumMW2  = Wa_2W.GetMass()*Wa_2W.GetMass();
    sumMW2 += Wb_2W.GetMass()*Wb_2W.GetMass();
    sumMW2gen  = Wa_G2W.GetMass()*Wa_G2W.GetMass();
    sumMW2gen += Wb_G2W.GetMass()*Wb_G2W.GetMass();
    sumMW2 /= sumMW2gen;
    sumMW2 = sqrt(sumMW2);

    histPlot->Fill(cat_2W);

    MCM = CM_3W.GetMass()/CM_G3W.GetMass();
    sumMW2  = Wa_3W.GetMass()*Wa_3W.GetMass();
    sumMW2 += Wb_3W.GetMass()*Wb_3W.GetMass();
    sumMW2 += Wc_3W.GetMass()*Wc_3W.GetMass();
    sumMW2gen  = Wa_G3W.GetMass()*Wa_G3W.GetMass();
    sumMW2gen += Wb_G3W.GetMass()*Wb_G3W.GetMass();
    sumMW2gen += Wc_G3W.GetMass()*Wc_G3W.GetMass();
    sumMW2 /= sumMW2gen;
    sumMW2 = sqrt(sumMW2);

    histPlot->Fill(cat_3W);

    MCM = CM_4W.GetMass()/CM_G4W.GetMass();
    sumMW2  = Wa_4W.GetMass()*Wa_4W.GetMass();
    sumMW2 += Wb_4W.GetMass()*Wb_4W.GetMass();
    sumMW2 += Wc_4W.GetMass()*Wc_4W.GetMass();
    sumMW2 += Wd_4W.GetMass()*Wd_4W.GetMass();
    sumMW2gen  = Wa_G4W.GetMass()*Wa_G4W.GetMass();
    sumMW2gen += Wb_G4W.GetMass()*Wb_G4W.GetMass();
    sumMW2gen += Wc_G4W.GetMass()*Wc_G4W.GetMass();
    sumMW2gen += Wd_G4W.GetMass()*Wd_G4W.GetMass();
    sumMW2 /= sumMW2gen;
    sumMW2 = sqrt(sumMW2);

    histPlot->Fill(cat_4W);
  }

  histPlot->Draw();

  TFile fout(output_name.c_str(),"RECREATE");
  fout.Close();
  histPlot->WriteOutput(output_name);
  histPlot->WriteHist(output_name);
  treePlot->WriteOutput(output_name);

  g_Log << LogInfo << "Finished" << LogEnd;
}
コード例 #2
0
void example_ttbar_to_bWlnubWlnu(const std::string output_name =
				 "output_ttbar_to_bWlnubWlnu.root"){

  double mT = 173.21; // GeV, PDG 2016
  double mW = 80.385;
  double mB = 4.18;
  double mL = 0.106;
  double mN = 0.;

  // number of events to generate
  int Ngen = 100000;

  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing generator frames and tree..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  ppLabGenFrame     LAB_Gen("LAB_Gen","LAB");
  DecayGenFrame     TT_Gen("TT_Gen","t #bar{t}");
  DecayGenFrame     Ta_Gen("Ta_Gen","t_{a}");
  DecayGenFrame     Tb_Gen("Tb_Gen","t_{b}");
  DecayGenFrame     Wa_Gen("Wa_Gen","W_{a}");
  DecayGenFrame     Wb_Gen("Wb_Gen","W_{b}");
  VisibleGenFrame   Ba_Gen("Ba_Gen","b_{a}");
  VisibleGenFrame   La_Gen("La_Gen","#it{l}_{a}");
  InvisibleGenFrame Na_Gen("Na_Gen","#nu_{a}");
  VisibleGenFrame   Bb_Gen("Bb_Gen","b_{b}");
  VisibleGenFrame   Lb_Gen("Lb_Gen","#it{l}_{b}");
  InvisibleGenFrame Nb_Gen("Nb_Gen","#nu_{b}");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  LAB_Gen.SetChildFrame(TT_Gen);
  TT_Gen.AddChildFrame(Ta_Gen);
  TT_Gen.AddChildFrame(Tb_Gen);
  Ta_Gen.AddChildFrame(Ba_Gen);
  Ta_Gen.AddChildFrame(Wa_Gen);
  Tb_Gen.AddChildFrame(Bb_Gen);
  Tb_Gen.AddChildFrame(Wb_Gen);
  Wa_Gen.AddChildFrame(La_Gen);
  Wa_Gen.AddChildFrame(Na_Gen);
  Wb_Gen.AddChildFrame(Lb_Gen);
  Wb_Gen.AddChildFrame(Nb_Gen);

  if(LAB_Gen.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized generator tree" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator tree" << LogEnd;							        
  
  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  // non-resonant ttbar production
  TT_Gen.SetVariableMass();
  // set top masses
  Ta_Gen.SetMass(mT);            Tb_Gen.SetMass(mT);
  // set W masses
  Wa_Gen.SetMass(mW);            Wb_Gen.SetMass(mW);
  // set B masses
  Ba_Gen.SetMass(mB);            Bb_Gen.SetMass(mB);
  // set : masses
  La_Gen.SetMass(mL);            Lb_Gen.SetMass(mL);
  // set neutrino masses
  Na_Gen.SetMass(mN);            Nb_Gen.SetMass(mN);

  // set b-jet/lepton pT/eta cuts
  Ba_Gen.SetPtCut(20.);          Bb_Gen.SetPtCut(20.);
  Ba_Gen.SetEtaCut(2.5);         Bb_Gen.SetEtaCut(2.5);
  La_Gen.SetPtCut(15.);          Lb_Gen.SetPtCut(15.);
  La_Gen.SetEtaCut(2.5);         Lb_Gen.SetEtaCut(2.5);

  if(LAB_Gen.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized generator analysis" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator analysis" << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////////////////								    
  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing reconstruction frames and trees..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  LabRecoFrame       LAB_R1("LAB_R1","LAB");      LabRecoFrame       LAB_R2("LAB_R2","LAB");
  DecayRecoFrame     TT_R1("TT_R1","t #bar{t}");  DecayRecoFrame     TT_R2("TT_R2","t #bar{t}");
  DecayRecoFrame     Ta_R1("Ta_R1","t_{a}");      DecayRecoFrame     Ta_R2("Ta_R2","t_{a}");
  DecayRecoFrame     Tb_R1("Tb_R1","t_{b}");      DecayRecoFrame     Tb_R2("Tb_R2","t_{b}");
  DecayRecoFrame     Wa_R1("Wa_R1","W_{a}");      DecayRecoFrame     Wa_R2("Wa_R2","W_{a}");
  DecayRecoFrame     Wb_R1("Wb_R1","W_{b}");      DecayRecoFrame     Wb_R2("Wb_R2","W_{b}");
  VisibleRecoFrame   Ba_R1("Ba_R1","b_{a}");      VisibleRecoFrame   Ba_R2("Ba_R2","b_{a}");
  VisibleRecoFrame   La_R1("La_R1","#it{l}_{a}"); VisibleRecoFrame   La_R2("La_R2","#it{l}_{a}");
  InvisibleRecoFrame Na_R1("Na_R1","#nu_{a}");    InvisibleRecoFrame Na_R2("Na_R2","#nu_{a}");
  VisibleRecoFrame   Bb_R1("Bb_R1","b_{b}");      VisibleRecoFrame   Bb_R2("Bb_R2","b_{b}");
  VisibleRecoFrame   Lb_R1("Lb_R1","#it{l}_{b}"); VisibleRecoFrame   Lb_R2("Lb_R2","#it{l}_{b}");
  InvisibleRecoFrame Nb_R1("Nb_R1","#nu_{b}");    InvisibleRecoFrame Nb_R2("Nb_R2","#nu_{b}");

  LabRecoFrame       LAB_R3("LAB_R3","LAB");      LabRecoFrame       LAB_R4("LAB_R4","LAB");
  DecayRecoFrame     TT_R3("TT_R3","t #bar{t}");  DecayRecoFrame     TT_R4("TT_R4","t #bar{t}");
  DecayRecoFrame     Ta_R3("Ta_R3","t_{a}");      DecayRecoFrame     Ta_R4("Ta_R4","t_{a}");
  DecayRecoFrame     Tb_R3("Tb_R3","t_{b}");      DecayRecoFrame     Tb_R4("Tb_R4","t_{b}");
  DecayRecoFrame     Wa_R3("Wa_R3","W_{a}");      DecayRecoFrame     Wa_R4("Wa_R4","W_{a}");
  DecayRecoFrame     Wb_R3("Wb_R3","W_{b}");      DecayRecoFrame     Wb_R4("Wb_R4","W_{b}");
  VisibleRecoFrame   Ba_R3("Ba_R3","b_{a}");      VisibleRecoFrame   Ba_R4("Ba_R4","b_{a}");
  VisibleRecoFrame   La_R3("La_R3","#it{l}_{a}"); VisibleRecoFrame   La_R4("La_R4","#it{l}_{a}");
  InvisibleRecoFrame Na_R3("Na_R3","#nu_{a}");    InvisibleRecoFrame Na_R4("Na_R4","#nu_{a}");
  VisibleRecoFrame   Bb_R3("Bb_R3","b_{b}");      VisibleRecoFrame   Bb_R4("Bb_R4","b_{b}");
  VisibleRecoFrame   Lb_R3("Lb_R3","#it{l}_{b}"); VisibleRecoFrame   Lb_R4("Lb_R4","#it{l}_{b}");
  InvisibleRecoFrame Nb_R3("Nb_R3","#nu_{b}");    InvisibleRecoFrame Nb_R4("Nb_R4","#nu_{b}");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  LAB_R1.SetChildFrame(TT_R1);                    LAB_R2.SetChildFrame(TT_R2);
  TT_R1.AddChildFrame(Ta_R1);                     TT_R2.AddChildFrame(Ta_R2);
  TT_R1.AddChildFrame(Tb_R1);                     TT_R2.AddChildFrame(Tb_R2);
  Ta_R1.AddChildFrame(Ba_R1);                     Ta_R2.AddChildFrame(Ba_R2);
  Ta_R1.AddChildFrame(Wa_R1);                     Ta_R2.AddChildFrame(Wa_R2);
  Tb_R1.AddChildFrame(Bb_R1);                     Tb_R2.AddChildFrame(Bb_R2);
  Tb_R1.AddChildFrame(Wb_R1);                     Tb_R2.AddChildFrame(Wb_R2);
  Wa_R1.AddChildFrame(La_R1);                     Wa_R2.AddChildFrame(La_R2);
  Wa_R1.AddChildFrame(Na_R1);                     Wa_R2.AddChildFrame(Na_R2);
  Wb_R1.AddChildFrame(Lb_R1);                     Wb_R2.AddChildFrame(Lb_R2);
  Wb_R1.AddChildFrame(Nb_R1);                     Wb_R2.AddChildFrame(Nb_R2);

  LAB_R3.SetChildFrame(TT_R3);                    LAB_R4.SetChildFrame(TT_R4);
  TT_R3.AddChildFrame(Ta_R3);                     TT_R4.AddChildFrame(Ta_R4);
  TT_R3.AddChildFrame(Tb_R3);                     TT_R4.AddChildFrame(Tb_R4);
  Ta_R3.AddChildFrame(Ba_R3);                     Ta_R4.AddChildFrame(Ba_R4);
  Ta_R3.AddChildFrame(Wa_R3);                     Ta_R4.AddChildFrame(Wa_R4);
  Tb_R3.AddChildFrame(Bb_R3);                     Tb_R4.AddChildFrame(Bb_R4);
  Tb_R3.AddChildFrame(Wb_R3);                     Tb_R4.AddChildFrame(Wb_R4);
  Wa_R3.AddChildFrame(La_R3);                     Wa_R4.AddChildFrame(La_R4);
  Wa_R3.AddChildFrame(Na_R3);                     Wa_R4.AddChildFrame(Na_R4);
  Wb_R3.AddChildFrame(Lb_R3);                     Wb_R4.AddChildFrame(Lb_R4);
  Wb_R3.AddChildFrame(Nb_R3);                     Wb_R4.AddChildFrame(Nb_R4);

  if(LAB_R1.InitializeTree() && LAB_R2.InitializeTree() && 
     LAB_R3.InitializeTree() && LAB_R4.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized reconstruction trees" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing reconstruction trees" << LogEnd;
 
  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  //////////////////////// define Groups for reconstruction trees ////////////////////////
  std::string group_name;

  // Invisible Group
  group_name = "#splitline{#nu #nu Jigsaws for}{min M_{top} , M_{top}^{ a} = M_{top}^{ b}}";
  InvisibleGroup INV_R1("INV_R1", group_name);
  INV_R1.AddFrame(Na_R1);
  INV_R1.AddFrame(Nb_R1);
  // Combinatoric Group for b's
  CombinatoricGroup B_R1("VIS_R1","b-jet Jigsaws");
  B_R1.AddFrame(Ba_R1);
  B_R1.AddFrame(Bb_R1);
  // b-jet frames must have at least one element
  B_R1.SetNElementsForFrame(Ba_R1, 1);
  B_R1.SetNElementsForFrame(Bb_R1, 1);

  group_name = "#splitline{#nu #nu Jigsaws for}{min M_{W}, M_{W}^{ a} = M_{W}^{ b}}";
  InvisibleGroup INV_R2("INV_R2", group_name);
  INV_R2.AddFrame(Na_R2);
  INV_R2.AddFrame(Nb_R2);
  CombinatoricGroup B_R2("VIS_R2","b-jet Jigsaws");
  B_R2.AddFrame(Ba_R2);
  B_R2.AddFrame(Bb_R2);
  B_R2.SetNElementsForFrame(Ba_R2, 1);
  B_R2.SetNElementsForFrame(Bb_R2, 1);

  group_name = "#splitline{#nu #nu Jigsaws for}{min M_{top a}^{2}+ M_{top b}^{2}}";
  InvisibleGroup INV_R3("INV_R3", group_name);
  INV_R3.AddFrame(Na_R3);
  INV_R3.AddFrame(Nb_R3);
  CombinatoricGroup B_R3("VIS_R3","b-jet Jigsaws");
  B_R3.AddFrame(Ba_R3);
  B_R3.AddFrame(Bb_R3);
  B_R3.SetNElementsForFrame(Ba_R3, 1);
  B_R3.SetNElementsForFrame(Bb_R3, 1);

  group_name = "#splitline{#nu #nu Jigsaws for}{min (M_{top a}- M_{top b})^{2}}";
  InvisibleGroup INV_R4("INV_R4", group_name);
  INV_R4.AddFrame(Na_R4);
  INV_R4.AddFrame(Nb_R4);
  CombinatoricGroup B_R4("VIS_R4","b-jet Jigsaws");
  B_R4.AddFrame(Ba_R4);
  B_R4.AddFrame(Bb_R4);
  B_R4.SetNElementsForFrame(Ba_R4, 1);
  B_R4.SetNElementsForFrame(Bb_R4, 1);

  //////////////////////// define Jigsaws for reconstruction trees ////////////////////////
  std::string jigsaw_name;

  // Minimize equal top masses neutrino jigsaws
  jigsaw_name = "M_{#nu#nu} = f(m_{b#it{l}b#it{l}} , m_{b#it{l}}^{ a} , m_{b#it{l}}^{ b})";
  SetMassInvJigsaw NuNuM_R1("NuNuM_R1", jigsaw_name);
  INV_R1.AddJigsaw(NuNuM_R1);

  jigsaw_name = "#eta_{#nu#nu} = #eta_{b #it{l} b #it{l}}";
  SetRapidityInvJigsaw NuNuR_R1("NuNuR_R1", jigsaw_name);
  INV_R1.AddJigsaw(NuNuR_R1);
  NuNuR_R1.AddVisibleFrames(La_R1+Ba_R1+Lb_R1+Bb_R1);

  jigsaw_name = "min M_{top}, M_{top}^{ a} = M_{top}^{ b}";
  ContraBoostInvJigsaw MinMt_R1("MinMt_R1", jigsaw_name);
  INV_R1.AddJigsaw(MinMt_R1);
  MinMt_R1.AddVisibleFrames(La_R1+Ba_R1, 0);
  MinMt_R1.AddVisibleFrames(Lb_R1+Bb_R1, 1);
  MinMt_R1.AddInvisibleFrame(Na_R1, 0);
  MinMt_R1.AddInvisibleFrame(Nb_R1, 1);

  // Minimize equal W masses neutrino jigsaws
  jigsaw_name = "M_{#nu#nu} = f(m_{#it{l}#it{l}} , m_{#it{l}}^{ a} , m_{#it{l}}^{ b})";
  SetMassInvJigsaw NuNuM_R2("NuNuM_R2", jigsaw_name);
  INV_R2.AddJigsaw(NuNuM_R2);

  jigsaw_name = "#eta_{#nu#nu} = #eta_{b #it{l} b #it{l}}";
  SetRapidityInvJigsaw NuNuR_R2("NuNuR_R2", jigsaw_name);
  INV_R2.AddJigsaw(NuNuR_R2);
  NuNuR_R2.AddVisibleFrames(La_R2+Ba_R2+Lb_R2+Bb_R2);

  jigsaw_name = "min M_{W}, M_{W}^{ a} = M_{W}^{ b}";
  ContraBoostInvJigsaw MinMW_R2("MinMW_R2", jigsaw_name);
  INV_R2.AddJigsaw(MinMW_R2);
  MinMW_R2.AddVisibleFrame(La_R2, 0);
  MinMW_R2.AddVisibleFrame(Lb_R2, 1);
  MinMW_R2.AddInvisibleFrame(Na_R2, 0);
  MinMW_R2.AddInvisibleFrame(Nb_R2, 1);

  // Minimize sum Mt^2 jigsaws
  jigsaw_name = "M_{#nu#nu} = f(m_{#it{l}#it{l}} , m_{#it{l}}^{ a} , m_{#it{l}}^{ b})";
  SetMassInvJigsaw NuNuM_R3("NuNuM_R3", jigsaw_name);
  INV_R3.AddJigsaw(NuNuM_R3);

  jigsaw_name = "#eta_{#nu#nu} = #eta_{b #it{l} b #it{l}}";
  SetRapidityInvJigsaw NuNuR_R3("NuNuR_R3", jigsaw_name);
  INV_R3.AddJigsaw(NuNuR_R3);
  NuNuR_R3.AddVisibleFrames(LAB_R3.GetListVisibleFrames());

  jigsaw_name = "min #Sigma M_{top}^{2}";
  MinMassesSqInvJigsaw MinMt_R3("MinMt_R3", jigsaw_name, 2);
  INV_R3.AddJigsaw(MinMt_R3);
  MinMt_R3.AddInvisibleFrame(Na_R3, 0);
  MinMt_R3.AddInvisibleFrame(Nb_R3, 1);
  MinMt_R3.AddVisibleFrames(La_R3+Ba_R3, 0);
  MinMt_R3.AddVisibleFrames(Lb_R3+Bb_R3, 1);
  MinMt_R3.AddMassFrame(La_R3, 0);
  MinMt_R3.AddMassFrame(Lb_R3, 1);

  // Minimize difference Mt jigsaws
  jigsaw_name = "M_{#nu#nu} = f(m_{#it{l}#it{l}} , m_{#it{l}}^{ a} , m_{#it{l}}^{ b})";
  SetMassInvJigsaw NuNuM_R4("NuNuM_R4", jigsaw_name);
  INV_R4.AddJigsaw(NuNuM_R4);

  jigsaw_name = "#eta_{#nu#nu} = #eta_{b #it{l} b #it{l}}";
  SetRapidityInvJigsaw NuNuR_R4("NuNuR_R4", jigsaw_name);
  INV_R4.AddJigsaw(NuNuR_R4);
  NuNuR_R4.AddVisibleFrames(LAB_R4.GetListVisibleFrames());

  jigsaw_name = "min ( M_{top a}- M_{top b} )^{2}";
  MinMassDiffInvJigsaw MinDeltaMt_R4("MinDeltaMt_R4", jigsaw_name, 2);
  INV_R4.AddJigsaw(MinDeltaMt_R4);
  MinDeltaMt_R4.AddInvisibleFrame(Na_R4, 0);
  MinDeltaMt_R4.AddInvisibleFrame(Nb_R4, 1);
  MinDeltaMt_R4.AddVisibleFrames(La_R4+Ba_R4, 0);
  MinDeltaMt_R4.AddVisibleFrames(Lb_R4+Bb_R4, 1);
  MinDeltaMt_R4.AddMassFrame(La_R4, 0);
  MinDeltaMt_R4.AddMassFrame(Lb_R4, 1);

  // b-jet combinatoric jigsaws for all trees
  jigsaw_name = "Minimize M(b #it{l} )_{a} , M(b #it{l} )_{b}";

  MinMassesCombJigsaw MinBL_R1("MinBL_R1", jigsaw_name);
  B_R1.AddJigsaw(MinBL_R1);
  MinBL_R1.AddFrames(La_R1+Ba_R1,0);
  MinBL_R1.AddFrames(Lb_R1+Bb_R1,1);

  MinMassesCombJigsaw MinBL_R2("MinBL_R2", jigsaw_name);
  B_R2.AddJigsaw(MinBL_R2);
  MinBL_R2.AddFrames(La_R2+Ba_R2,0);
  MinBL_R2.AddFrames(Lb_R2+Bb_R2,1);

  MinMassesCombJigsaw MinBL_R3("MinBL_R3", jigsaw_name);
  B_R3.AddJigsaw(MinBL_R3);
  MinBL_R3.AddFrames(La_R3+Ba_R3,0);
  MinBL_R3.AddFrames(Lb_R3+Bb_R3,1);

  MinMassesCombJigsaw MinBL_R4("MinBL_R4", jigsaw_name);
  B_R4.AddJigsaw(MinBL_R4);
  MinBL_R4.AddFrames(La_R4+Ba_R4,0);
  MinBL_R4.AddFrames(Lb_R4+Bb_R4,1);

  if(LAB_R1.InitializeAnalysis() && LAB_R2.InitializeAnalysis() && 
     LAB_R3.InitializeAnalysis() && LAB_R4.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized analysis" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing analysis" << LogEnd;	

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

  TreePlot* treePlot = new TreePlot("TreePlot","TreePlot");
 
  treePlot->SetTree(LAB_Gen);
  treePlot->Draw("GenTree", "Generator Tree", true);
  
  treePlot->SetTree(LAB_R1);
  treePlot->Draw("RecoTree", "Reconstruction Tree");

  treePlot->SetTree(B_R1);
  treePlot->Draw("VisTree", "b-jet Jigsaws", true);

  treePlot->SetTree(INV_R1);
  treePlot->Draw("InvTree_R1", "Inivisibl Jigsaws", true);

  treePlot->SetTree(INV_R2);
  treePlot->Draw("InvTree_R2", "Inivisibl Jigsaws", true);

  treePlot->SetTree(INV_R3);
  treePlot->Draw("InvTree_R3", "Inivisibl Jigsaws", true);

  treePlot->SetTree(INV_R4);
  treePlot->Draw("InvTree_R4", "Inivisibl Jigsaws", true);

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  HistPlot* histPlot = new HistPlot("HistPlot", "t #bar{t} #rightarrow b W(#it{l} #nu) b W(#it{l} #nu)");

  const HistPlotCategory& cat_Gen = histPlot->GetNewCategory("Gen",  "Generator");
  const HistPlotCategory& cat_R1  = histPlot->GetNewCategory("Reco1", "M_{top}^{ a} = M_{top}^{ b} Reco");
  const HistPlotCategory& cat_R2  = histPlot->GetNewCategory("Reco2", "M_{W}^{ a} = M_{W}^{ b} Reco");
  const HistPlotCategory& cat_R3  = histPlot->GetNewCategory("Reco3", "min #Sigma M_{top}^{ 2} Reco");
  const HistPlotCategory& cat_R4  = histPlot->GetNewCategory("Reco4", "min #Delta M_{top} Reco");

  const HistPlotVar& Mtt    = histPlot->GetNewVar("Mtt", "M_{t #bar{t}} / m_{t #bar{t}}", 0., 2.);
  const HistPlotVar& Eb_ta  = histPlot->GetNewVar("Eb_ta", "E_{b a}^{top a} / E_{b a}^{top a gen}", 0., 2.);
  const HistPlotVar& Eb_tb  = histPlot->GetNewVar("Eb_tb", "E_{b b}^{top b} / E_{b b}^{top b gen}", 0., 2.);
  const HistPlotVar& El_Wa  = histPlot->GetNewVar("El_Wa", "E_{#it{l} a}^{W a} / E_{#it{l} a}^{W a gen}", 0., 2.);
  const HistPlotVar& El_Wb  = histPlot->GetNewVar("El_Wb", "E_{#it{l} b}^{W b} / E_{#it{l} b}^{W b gen}", 0., 2.);
  const HistPlotVar& costt  = histPlot->GetNewVar("costt","cos #theta_{t #bar{t}}", -1., 1.);
  const HistPlotVar& costa  = histPlot->GetNewVar("costa","cos #theta_{top a}", -1., 1.);
  const HistPlotVar& costb  = histPlot->GetNewVar("costb","cos #theta_{top b}", -1., 1.);
  const HistPlotVar& cosWa  = histPlot->GetNewVar("cosWa","cos #theta_{W a}", -1., 1.);
  const HistPlotVar& cosWb  = histPlot->GetNewVar("cosWb","cos #theta_{W b}", -1., 1.);
  const HistPlotVar& Dcostt = histPlot->GetNewVar("Dcostt","#theta_{t #bar{t}} - #theta_{t #bar{t}}^{gen}", 
						  -acos(-1.)/2., acos(-1.)/2.);
  const HistPlotVar& Dcosta = histPlot->GetNewVar("Dcosta","#theta_{top a} - #theta_{top a}^{gen}", 
						  -acos(-1.)/2., acos(-1.)/2.);
  const HistPlotVar& Dcostb = histPlot->GetNewVar("Dcostb","#theta_{top b} - #theta_{top b}^{gen}", 
						  -acos(-1.)/2., acos(-1.)/2.);
  const HistPlotVar& DcosWa = histPlot->GetNewVar("DcosWa","#theta_{W a} - #theta_{W a}^{gen}", 
						  -acos(-1.)/2., acos(-1.)/2.);
  const HistPlotVar& DcosWb = histPlot->GetNewVar("DcosWb","#theta_{W b} - #theta_{W b}^{gen}", 
						  -acos(-1.)/2., acos(-1.)/2.);

  histPlot->AddPlot(Mtt,   cat_R1+cat_R2+cat_R3+cat_R4);
  histPlot->AddPlot(Eb_ta, cat_R1+cat_R2+cat_R3+cat_R4);
  histPlot->AddPlot(El_Wa, cat_R1+cat_R2+cat_R3+cat_R4);
  histPlot->AddPlot(Dcostt, cat_R1+cat_R2+cat_R3+cat_R4);
  histPlot->AddPlot(Dcosta, cat_R1+cat_R2+cat_R3+cat_R4);
  histPlot->AddPlot(DcosWa, cat_R1+cat_R2+cat_R3+cat_R4);

  histPlot->AddPlot(Mtt, Eb_ta, cat_R4);
  histPlot->AddPlot(Mtt, El_Wa, cat_R4);
  histPlot->AddPlot(Eb_ta, Eb_tb, cat_R4);
  histPlot->AddPlot(El_Wa, El_Wb, cat_R4);
  histPlot->AddPlot(Eb_ta, El_Wa, cat_R4);
  histPlot->AddPlot(Eb_ta, El_Wb, cat_R4);
  histPlot->AddPlot(Dcostt, Mtt,  cat_R4);
  histPlot->AddPlot(Dcosta, Eb_ta, cat_R4);
  histPlot->AddPlot(DcosWa, El_Wa, cat_R4);
  histPlot->AddPlot(Dcostt, Dcosta, cat_R4);
  histPlot->AddPlot(Dcosta, Dcostb, cat_R4);
  histPlot->AddPlot(DcosWa, DcosWb, cat_R4);
  histPlot->AddPlot(Dcosta, DcosWa, cat_R4);

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

  for(int igen = 0; igen < Ngen; igen++){
    if(igen%((std::max(Ngen,10))/10) == 0)
      g_Log << LogInfo << "Generating event " << igen << " of " << Ngen << LogEnd;

    // generate event
    LAB_Gen.ClearEvent();                             // clear the gen tree
  
    LAB_Gen.AnalyzeEvent();                           // generate a new event

    // analyze event three different ways
    TVector3 MET = LAB_Gen.GetInvisibleMomentum();    // Get the MET from gen tree
    MET.SetZ(0.);

    LAB_R1.ClearEvent();   
    LAB_R2.ClearEvent(); 
    LAB_R3.ClearEvent(); 
    LAB_R4.ClearEvent(); 
             
    INV_R1.SetLabFrameThreeVector(MET); 
    INV_R2.SetLabFrameThreeVector(MET); 
    INV_R3.SetLabFrameThreeVector(MET);
    INV_R4.SetLabFrameThreeVector(MET);

    La_R1.SetLabFrameFourVector(La_Gen.GetFourVector());
    Lb_R1.SetLabFrameFourVector(Lb_Gen.GetFourVector());
    La_R2.SetLabFrameFourVector(La_Gen.GetFourVector());
    Lb_R2.SetLabFrameFourVector(Lb_Gen.GetFourVector());
    La_R3.SetLabFrameFourVector(La_Gen.GetFourVector());
    Lb_R3.SetLabFrameFourVector(Lb_Gen.GetFourVector());
    La_R4.SetLabFrameFourVector(La_Gen.GetFourVector());
    Lb_R4.SetLabFrameFourVector(Lb_Gen.GetFourVector());

    std::vector<RFKey> B_R1_ID; // ID for tracking jets in tree
    B_R1_ID.push_back(B_R1.AddLabFrameFourVector(Ba_Gen.GetFourVector()));
    B_R1_ID.push_back(B_R1.AddLabFrameFourVector(Bb_Gen.GetFourVector()));
    B_R2.AddLabFrameFourVector(Ba_Gen.GetFourVector());
    B_R2.AddLabFrameFourVector(Bb_Gen.GetFourVector());
    B_R3.AddLabFrameFourVector(Ba_Gen.GetFourVector());
    B_R3.AddLabFrameFourVector(Bb_Gen.GetFourVector());
    B_R4.AddLabFrameFourVector(Ba_Gen.GetFourVector());
    B_R4.AddLabFrameFourVector(Bb_Gen.GetFourVector());
   
    LAB_R1.AnalyzeEvent(); // analyze the event
    LAB_R2.AnalyzeEvent();     
    LAB_R3.AnalyzeEvent(); 
    LAB_R4.AnalyzeEvent(); 

    //////////////////////////////////////
    // Observable Calculations
    //////////////////////////////////////

    double Mttgen   = TT_Gen.GetMass();
    double Eb_tagen = Ba_Gen.GetFourVector(Ta_Gen).E();
    double Eb_tbgen = Bb_Gen.GetFourVector(Tb_Gen).E();
    double El_Wagen = La_Gen.GetFourVector(Wa_Gen).E();
    double El_Wbgen = Lb_Gen.GetFourVector(Wb_Gen).E();
    double costtgen = TT_Gen.GetCosDecayAngle();
    double costagen = Ta_Gen.GetCosDecayAngle();
    double costbgen = Tb_Gen.GetCosDecayAngle();
    double cosWagen = Wa_Gen.GetCosDecayAngle();
    double cosWbgen = Wb_Gen.GetCosDecayAngle();

    Mtt = TT_R1.GetMass()/Mttgen;
    // Mta = Ta_R1.GetMass();
    // Mtb = Tb_R1.GetMass();
    // MWa = Wa_R1.GetMass();
    // MWb = Wb_R1.GetMass();
    Eb_ta = Ba_R1.GetFourVector(Ta_R1).E()/Eb_tagen;
    Eb_tb = Bb_R1.GetFourVector(Tb_R1).E()/Eb_tbgen;
    El_Wa = La_R1.GetFourVector(Wa_R1).E()/El_Wagen;
    El_Wb = Lb_R1.GetFourVector(Wb_R1).E()/El_Wbgen;
    costt = TT_R1.GetCosDecayAngle();
    costa = Ta_R1.GetCosDecayAngle();
    costb = Tb_R1.GetCosDecayAngle();
    cosWa = Wa_R1.GetCosDecayAngle();
    cosWb = Wb_R1.GetCosDecayAngle();
    Dcostt = asin(sqrt(1.-costt*costt)*costtgen-sqrt(1.-costtgen*costtgen)*costt);
    Dcosta = asin(sqrt(1.-costa*costa)*costagen-sqrt(1.-costagen*costagen)*costa);
    Dcostb = asin(sqrt(1.-costb*costb)*costbgen-sqrt(1.-costbgen*costbgen)*costb);
    DcosWa = asin(sqrt(1.-cosWa*cosWa)*cosWagen-sqrt(1.-cosWagen*cosWagen)*cosWa);
    DcosWb = asin(sqrt(1.-cosWb*cosWb)*cosWbgen-sqrt(1.-cosWbgen*cosWbgen)*cosWb);

    histPlot->Fill(cat_R1);

    Mtt = TT_R2.GetMass()/Mttgen;
    // Mta = Ta_R2.GetMass();
    // Mtb = Tb_R2.GetMass();
    // MWa = Wa_R2.GetMass();
    // MWb = Wb_R2.GetMass();
    Eb_ta = Ba_R2.GetFourVector(Ta_R2).E()/Eb_tagen;
    Eb_tb = Bb_R2.GetFourVector(Tb_R2).E()/Eb_tbgen;
    El_Wa = La_R2.GetFourVector(Wa_R2).E()/El_Wagen;
    El_Wb = Lb_R2.GetFourVector(Wb_R2).E()/El_Wbgen;
    costt = TT_R2.GetCosDecayAngle();
    costa = Ta_R2.GetCosDecayAngle();
    costb = Tb_R2.GetCosDecayAngle();
    cosWa = Wa_R2.GetCosDecayAngle();
    cosWb = Wb_R2.GetCosDecayAngle();
    Dcostt = asin(sqrt(1.-costt*costt)*costtgen-sqrt(1.-costtgen*costtgen)*costt);
    Dcosta = asin(sqrt(1.-costa*costa)*costagen-sqrt(1.-costagen*costagen)*costa);
    Dcostb = asin(sqrt(1.-costb*costb)*costbgen-sqrt(1.-costbgen*costbgen)*costb);
    DcosWa = asin(sqrt(1.-cosWa*cosWa)*cosWagen-sqrt(1.-cosWagen*cosWagen)*cosWa);
    DcosWb = asin(sqrt(1.-cosWb*cosWb)*cosWbgen-sqrt(1.-cosWbgen*cosWbgen)*cosWb);

    histPlot->Fill(cat_R2);

    Mtt = TT_R3.GetMass()/Mttgen;
    // Mta = Ta_R3.GetMass();
    // Mtb = Tb_R3.GetMass();
    // MWa = Wa_R3.GetMass();
    // MWb = Wb_R3.GetMass();
    Eb_ta = Ba_R3.GetFourVector(Ta_R3).E()/Eb_tagen;
    Eb_tb = Bb_R3.GetFourVector(Tb_R3).E()/Eb_tbgen;
    El_Wa = La_R3.GetFourVector(Wa_R3).E()/El_Wagen;
    El_Wb = Lb_R3.GetFourVector(Wb_R3).E()/El_Wbgen;
    costt = TT_R3.GetCosDecayAngle();
    costa = Ta_R3.GetCosDecayAngle();
    costb = Tb_R3.GetCosDecayAngle();
    cosWa = Wa_R3.GetCosDecayAngle();
    cosWb = Wb_R3.GetCosDecayAngle();
    Dcostt = asin(sqrt(1.-costt*costt)*costtgen-sqrt(1.-costtgen*costtgen)*costt);
    Dcosta = asin(sqrt(1.-costa*costa)*costagen-sqrt(1.-costagen*costagen)*costa);
    Dcostb = asin(sqrt(1.-costb*costb)*costbgen-sqrt(1.-costbgen*costbgen)*costb);
    DcosWa = asin(sqrt(1.-cosWa*cosWa)*cosWagen-sqrt(1.-cosWagen*cosWagen)*cosWa);
    DcosWb = asin(sqrt(1.-cosWb*cosWb)*cosWbgen-sqrt(1.-cosWbgen*cosWbgen)*cosWb);

    histPlot->Fill(cat_R3);

    Mtt = TT_R4.GetMass()/Mttgen;
    // Mta = Ta_R4.GetMass();
    // Mtb = Tb_R4.GetMass();
    // MWa = Wa_R4.GetMass();
    // MWb = Wb_R4.GetMass();
    Eb_ta = Ba_R4.GetFourVector(Ta_R4).E()/Eb_tagen;
    Eb_tb = Bb_R4.GetFourVector(Tb_R4).E()/Eb_tbgen;
    El_Wa = La_R4.GetFourVector(Wa_R4).E()/El_Wagen;
    El_Wb = Lb_R4.GetFourVector(Wb_R4).E()/El_Wbgen;
    costt = TT_R4.GetCosDecayAngle();
    costa = Ta_R4.GetCosDecayAngle();
    costb = Tb_R4.GetCosDecayAngle();
    cosWa = Wa_R4.GetCosDecayAngle();
    cosWb = Wb_R4.GetCosDecayAngle();
    Dcostt = asin(sqrt(1.-costt*costt)*costtgen-sqrt(1.-costtgen*costtgen)*costt);
    Dcosta = asin(sqrt(1.-costa*costa)*costagen-sqrt(1.-costagen*costagen)*costa);
    Dcostb = asin(sqrt(1.-costb*costb)*costbgen-sqrt(1.-costbgen*costbgen)*costb);
    DcosWa = asin(sqrt(1.-cosWa*cosWa)*cosWagen-sqrt(1.-cosWagen*cosWagen)*cosWa);
    DcosWb = asin(sqrt(1.-cosWb*cosWb)*cosWbgen-sqrt(1.-cosWbgen*cosWbgen)*cosWb);

    histPlot->Fill(cat_R4);

  }

  histPlot->Draw();

  LAB_Gen.PrintGeneratorEfficiency();

  TFile fout(output_name.c_str(),"RECREATE");
  fout.Close();
  histPlot->WriteOutput(output_name);
  histPlot->WriteHist(output_name);
  treePlot->WriteOutput(output_name);

  g_Log << LogInfo << "Finished" << LogEnd;
}
コード例 #3
0
void example_top_to_bWlnu(const std::string& output_name =
			 "output_top_to_bWlnu.root"){
 
  // set particle masses and widths
  double mtop = 173.21; // GeV, PDG 2016
  double wtop = 1.41;
  double mW   = 80.385;
  double wW   = 2.085;
  
  // Number of events to generate
  int Ngen = 100000;
  
  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing generator frames and tree..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  ppLabGenFrame         LAB_Gen("LAB_Gen","LAB");
  ResonanceGenFrame     T_Gen("T_Gen","t");
  ResonanceGenFrame     W_Gen("W_Gen","W");
  VisibleGenFrame       B_Gen("B_Gen","b");
  VisibleGenFrame       L_Gen("L_Gen","#it{l}");
  InvisibleGenFrame     NU_Gen("NU_Gen","#nu");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  LAB_Gen.SetChildFrame(T_Gen);
  T_Gen.AddChildFrame(B_Gen);
  T_Gen.AddChildFrame(W_Gen);
  W_Gen.AddChildFrame(L_Gen);
  W_Gen.AddChildFrame(NU_Gen);

  if(LAB_Gen.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized generator tree" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator tree" << LogEnd;

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  // set top mass and width
  T_Gen.SetMass(mtop);                 T_Gen.SetWidth(wtop);
  // set W mass and width
  W_Gen.SetMass(mW);                   W_Gen.SetWidth(wW);

  // set b-jet/lepton pT and eta cuts
  L_Gen.SetPtCut(20.);                 L_Gen.SetEtaCut(2.5);
  B_Gen.SetPtCut(20.);                 B_Gen.SetEtaCut(2.5);  

  if(LAB_Gen.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized generator analysis" << std::endl << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator analysis" << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////////////////

  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing reconstruction frames and trees..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  LabRecoFrame       LAB_Mt("LAB_Mt","LAB"); LabRecoFrame       LAB_MW("LAB_MW","LAB");
  DecayRecoFrame     T_Mt("T_Mt","t");       DecayRecoFrame     T_MW("T_MW","t");
  DecayRecoFrame     W_Mt("W_Mt","W");       DecayRecoFrame     W_MW("W_MW","W");
  VisibleRecoFrame   B_Mt("B_Mt","b");       VisibleRecoFrame   B_MW("B_MW","b");
  VisibleRecoFrame   L_Mt("L_Mt","#it{l}");  VisibleRecoFrame   L_MW("L_MW","#it{l}");
  InvisibleRecoFrame NU_Mt("NU_Mt","#nu");   InvisibleRecoFrame NU_MW("NU_MW","#nu");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  LAB_Mt.SetChildFrame(T_Mt);                LAB_MW.SetChildFrame(T_MW);
  T_Mt.AddChildFrame(B_Mt);                  T_MW.AddChildFrame(B_MW);
  T_Mt.AddChildFrame(W_Mt);                  T_MW.AddChildFrame(W_MW);
  W_Mt.AddChildFrame(L_Mt);                  W_MW.AddChildFrame(L_MW);
  W_Mt.AddChildFrame(NU_Mt);                 W_MW.AddChildFrame(NU_MW);

  if(LAB_Mt.InitializeTree() && LAB_MW.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized reconstruction trees" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing reconstruction trees" << LogEnd;

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  // Invisible Groups
  InvisibleGroup INV_Mt("INV_Mt","#nu Jigsaws");
  INV_Mt.AddFrame(NU_Mt);     
  InvisibleGroup INV_MW("INV_MW","#nu Jigsaws");
  INV_MW.AddFrame(NU_MW);

  // Set neutrino masses to zero
  SetMassInvJigsaw NuM_Mt("NuM_Mt","M_{#nu} = 0"); 
  INV_Mt.AddJigsaw(NuM_Mt);                        
  SetMassInvJigsaw NuM_MW("NuM_MW","M_{#nu} = 0");
  INV_MW.AddJigsaw(NuM_MW);

  // Set neutrino rapidity to that of visible particles
  SetRapidityInvJigsaw NuR_Mt("NuR_Mt","#eta_{#nu} = #eta_{b+#it{l}}");
  INV_Mt.AddJigsaw(NuR_Mt);
  NuR_Mt.AddVisibleFrame(L_Mt);
  NuR_Mt.AddVisibleFrame(B_Mt);
  SetRapidityInvJigsaw NuR_MW("NuR_MW","#eta_{#nu} = #eta_{#it{l}}");
  INV_MW.AddJigsaw(NuR_MW);
  NuR_MW.AddVisibleFrame(L_MW);

  if(LAB_Mt.InitializeAnalysis() && LAB_MW.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized analyses" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing analyses" << LogEnd;

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

  TreePlot* treePlot = new TreePlot("TreePlot","TreePlot");
 
  treePlot->SetTree(LAB_Gen);
  treePlot->Draw("GenTree", "Generator Tree", true);

  treePlot->SetTree(LAB_Mt);
  treePlot->Draw("RecoTree", "Reconstruction Tree");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  // Declare observables for histogram booking
  HistPlot* histPlot   = new HistPlot("HistPlot","pp #rightarrow t #rightarrow W(#it{l} #nu) b");

  const HistPlotCategory& cat_Gen   = histPlot->GetNewCategory("Gen", "Generator");
  const HistPlotCategory& cat_minMt = histPlot->GetNewCategory("minMt", "min M_{t} Reco");
  const HistPlotCategory& cat_minMW = histPlot->GetNewCategory("minMW", "min M_{W} Reco");

  const HistPlotVar& Mt     = histPlot->GetNewVar("Mt", "M_{t}", 0., 280., "[GeV]");
  const HistPlotVar& MW     = histPlot->GetNewVar("MW", "M_{W}", 0., 150., "[GeV]");
  const HistPlotVar& pTtoMt = histPlot->GetNewVar("pTtoMt","p_{T}^{top} / m_{top}", 0., 1.);
  const HistPlotVar& cosT   = histPlot->GetNewVar("cosT","cos #theta_{t}", -1., 1.);
  const HistPlotVar& cosW   = histPlot->GetNewVar("cosW","cos #theta_{W}", -1., 1.);
  const HistPlotVar& dphiT  = histPlot->GetNewVar("dphiT", "#Delta #phi_{t}", 0., 2.*acos(-1.));
  const HistPlotVar& dphiW  = histPlot->GetNewVar("dphiW", "#Delta #phi_{W}", 0., 2.*acos(-1.));
  const HistPlotVar& DcosT  = histPlot->GetNewVar("DcosT","#theta_{t} - #theta_{t}^{gen}", -1., 1.);
  const HistPlotVar& DcosW  = histPlot->GetNewVar("DcosW","#theta_{W} - #theta_{W}^{gen}", -1., 1.);
  const HistPlotVar& DdphiT = histPlot->GetNewVar("DdphiT","#Delta #phi_{t} - #Delta #phi_{t}^{gen}", -1., 1.);
  const HistPlotVar& DdphiW = histPlot->GetNewVar("DdphiW","#Delta #phi_{W} - #Delta #phi_{W}^{gen}", -1., 1.);

  histPlot->AddPlot(DcosT,  cat_minMt+cat_minMW);
  histPlot->AddPlot(DcosW,  cat_minMt+cat_minMW);
  histPlot->AddPlot(DdphiT, cat_minMt+cat_minMW);
  histPlot->AddPlot(DdphiW, cat_minMt+cat_minMW);
  histPlot->AddPlot(MW,     cat_minMt+cat_minMW+cat_Gen);
  histPlot->AddPlot(Mt,     cat_minMt+cat_minMW+cat_Gen);
  histPlot->AddPlot(Mt, MW, cat_minMt+cat_minMW+cat_Gen);
  histPlot->AddPlot(Mt, pTtoMt, cat_minMt+cat_minMW);
  histPlot->AddPlot(MW, pTtoMt, cat_minMt+cat_minMW);
  histPlot->AddPlot(DcosW,  MW, cat_minMt+cat_minMW);
  histPlot->AddPlot(DcosT,  Mt, cat_minMt+cat_minMW);
  histPlot->AddPlot(Mt, pTtoMt, cat_minMt+cat_minMW);
  histPlot->AddPlot(MW, pTtoMt, cat_minMt+cat_minMW);
  histPlot->AddPlot(DcosT, DcosW, cat_minMt+cat_minMW);
 

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

  for(int igen = 0; igen < Ngen; igen++){
    if(igen%((std::max(Ngen,10))/10) == 0)
      g_Log << LogInfo << "Generating event " << igen << " of " << Ngen << LogEnd;

    // generate event
    LAB_Gen.ClearEvent();                            // clear the gen tree

    pTtoMt = gRandom->Rndm();                        // give the Top some Pt
    LAB_Gen.SetPToverM(pTtoMt); 
  
    LAB_Gen.AnalyzeEvent();                          // generate a new event

    TVector3 MET = LAB_Gen.GetInvisibleMomentum();   // Get the MET from gen tree
    MET.SetZ(0.);
    
    // analyze event one way
    LAB_Mt.ClearEvent();                               // clear the reco tree
    
    L_Mt.SetLabFrameFourVector(L_Gen.GetFourVector()); // Set lepton 4-vec
    B_Mt.SetLabFrameFourVector(B_Gen.GetFourVector()); // Set b-jet 4-vec
    INV_Mt.SetLabFrameThreeVector(MET);                // Set the MET in reco tree
    
    LAB_Mt.AnalyzeEvent();                             //analyze the event

    // analyze event another way
    LAB_MW.ClearEvent();                               // clear the reco tree
    
    L_MW.SetLabFrameFourVector(L_Gen.GetFourVector()); // Set lepton 4-vec
    B_MW.SetLabFrameFourVector(B_Gen.GetFourVector()); // Set b-jet 4-vec
    INV_MW.SetLabFrameThreeVector(MET);                // Set the MET in reco tree
    
    LAB_MW.AnalyzeEvent();                             //analyze the event

    // Generator-level observables
    double MTgen = T_Gen.GetMass();
    double cosTgen  = T_Gen.GetCosDecayAngle();
    double dphiTgen = LAB_Gen.GetDeltaPhiDecayPlanes(T_Gen);
    double MWgen = W_Gen.GetMass();
    double cosWgen  = W_Gen.GetCosDecayAngle();
    double dphiWgen = T_Gen.GetDeltaPhiDecayPlanes(W_Gen);

    Mt = MTgen;
    MW = MWgen;
    histPlot->Fill(cat_Gen);

    // minMt observables
    Mt     = T_Mt.GetMass();
    cosT   = T_Mt.GetCosDecayAngle();
    dphiT  = LAB_Mt.GetDeltaPhiDecayPlanes(T_Mt);
    MW     = W_Mt.GetMass();
    cosW   = W_Mt.GetCosDecayAngle();
    dphiW  = T_Mt.GetDeltaPhiDecayPlanes(W_Mt);
    DcosT  = asin(sqrt(1.-cosT*cosT)*cosTgen-sqrt(1.-cosTgen*cosTgen)*cosT);
    DdphiT = asin(sin(dphiT-dphiTgen));
    DcosW  = asin(sqrt(1.-cosW*cosW)*cosWgen-sqrt(1.-cosWgen*cosWgen)*cosW);
    DdphiW = asin(sin(dphiW-dphiWgen));

    histPlot->Fill(cat_minMt);

    // minMW observables
    Mt     = T_MW.GetMass();
    cosT   = T_MW.GetCosDecayAngle();
    dphiT  = LAB_MW.GetDeltaPhiDecayPlanes(T_MW);
    MW     = W_MW.GetMass();
    cosW   = W_MW.GetCosDecayAngle();
    dphiW  = T_MW.GetDeltaPhiDecayPlanes(W_MW);
    DcosT  = asin(sqrt(1.-cosT*cosT)*cosTgen-sqrt(1.-cosTgen*cosTgen)*cosT);
    DdphiT = asin(sin(dphiT-dphiTgen));
    DcosW  = asin(sqrt(1.-cosW*cosW)*cosWgen-sqrt(1.-cosWgen*cosWgen)*cosW);
    DdphiW = asin(sin(dphiW-dphiWgen));

    histPlot->Fill(cat_minMW);
  }

  histPlot->Draw();

  LAB_Gen.PrintGeneratorEfficiency();
  
  TFile fout(output_name.c_str(),"RECREATE");
  fout.Close();
  histPlot->WriteOutput(output_name);
  histPlot->WriteHist(output_name);
  treePlot->WriteOutput(output_name);

  g_Log << LogInfo << "Finished" << LogEnd;

}
コード例 #4
0
void example_Hp_to_HggWlnu(const std::string& output_name =
			   "output_Hp_to_HggWlnu.root"){
 
  // set particle masses and widths
  double mH   = 125.; 
  double mW   = 80.385; // GeV, PDG 2016
  double wW   = 2.085;
  
  std::vector<double> mHp; // vary charged Higgs mass
  mHp.push_back(300.);
  mHp.push_back(500.);
  mHp.push_back(750.);
  mHp.push_back(1000.);
  mHp.push_back(1500.);
  
  // Number of events to generate (per H+ mass)
  int Ngen = 10000;
  
  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing generator frames and tree..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  ppLabGenFrame         LAB_Gen("LAB_Gen","LAB");
  DecayGenFrame         Hp_Gen("Hp_Gen","H^{ +}");
  DecayGenFrame         H_Gen("H_Gen","h^{ 0}");
  ResonanceGenFrame     W_Gen("W_Gen","W^{ +}");
  VisibleGenFrame       G1_Gen("G1_Gen","#gamma_{1}");
  VisibleGenFrame       G2_Gen("G2_Gen","#gamma_{2}");
  VisibleGenFrame       L_Gen("L_Gen","#it{l}^{ +}");
  InvisibleGenFrame     NU_Gen("NU_Gen","#nu");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  LAB_Gen.SetChildFrame(Hp_Gen);
  Hp_Gen.AddChildFrame(H_Gen);
  Hp_Gen.AddChildFrame(W_Gen);
  H_Gen.AddChildFrame(G1_Gen);
  H_Gen.AddChildFrame(G2_Gen);
  W_Gen.AddChildFrame(L_Gen);
  W_Gen.AddChildFrame(NU_Gen);

  if(LAB_Gen.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized generator tree" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator tree" << LogEnd;

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  if(mHp.size() < 1) return;
  
  // set neutral and charged Higgs mass 
  Hp_Gen.SetMass(mHp[0]);              H_Gen.SetMass(mH);         
  // set W mass and width
  W_Gen.SetMass(mW);                   W_Gen.SetWidth(wW);

  // set photon/lepton pT and eta cuts
  L_Gen.SetPtCut(15.);                 L_Gen.SetEtaCut(2.5);
  G1_Gen.SetPtCut(20.);                G1_Gen.SetEtaCut(3.);
  G2_Gen.SetPtCut(20.);                G2_Gen.SetEtaCut(3.);  

  if(LAB_Gen.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized generator analysis" << std::endl << LogEnd;
  else
    g_Log << LogError << "...Failed initializing generator analysis" << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////////////////

  /////////////////////////////////////////////////////////////////////////////////////////
  g_Log << LogInfo << "Initializing reconstruction frames and trees..." << LogEnd;
  /////////////////////////////////////////////////////////////////////////////////////////
  LabRecoFrame       LAB("LAB","LAB");
  DecayRecoFrame     Hp("Hp","H^{ +}");
  DecayRecoFrame     H("H","h^{ 0}");
  DecayRecoFrame     W("W","W^{ +}");
  VisibleRecoFrame   G1("G1","#gamma_{1}");
  VisibleRecoFrame   G2("G2","#gamma_{2}");
  VisibleRecoFrame   L("L","#it{l}^{ +}");
  InvisibleRecoFrame NU("NU","#nu");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  LAB.SetChildFrame(Hp);
  Hp.AddChildFrame(H);
  Hp.AddChildFrame(W);
  H.AddChildFrame(G1);
  H.AddChildFrame(G2);
  W.AddChildFrame(L);
  W.AddChildFrame(NU);

  if(LAB.InitializeTree())
    g_Log << LogInfo << "...Successfully initialized reconstruction trees" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing reconstruction trees" << LogEnd;

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//

  // Invisible Group
  InvisibleGroup INV("INV","#nu Jigsaws");
  INV.AddFrame(NU);     

  // Set neutrino masses to zero
  SetMassInvJigsaw NuM("NuM","M_{#nu} = 0"); 
  INV.AddJigsaw(NuM);                        

  // Set neutrino rapidity to that of visible particles
  SetRapidityInvJigsaw NuR("NuR","#eta_{#nu} = #eta_{#gamma#gamma#it{l}}");
  INV.AddJigsaw(NuR);
  NuR.AddVisibleFrames(Hp.GetListVisibleFrames());

  if(LAB.InitializeAnalysis())
    g_Log << LogInfo << "...Successfully initialized analyses" << LogEnd;
  else
    g_Log << LogError << "...Failed initializing analyses" << LogEnd;

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

  TreePlot* treePlot = new TreePlot("TreePlot","TreePlot");
 
  treePlot->SetTree(LAB_Gen);
  treePlot->Draw("GenTree", "Generator Tree", true);

  treePlot->SetTree(LAB);
  treePlot->Draw("RecoTree", "Reconstruction Tree");

  //-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
  
  // Declare observables for histogram booking
  std::string plot_title = "pp #rightarrow H^{ +} #rightarrow h^{ 0}(#gamma #gamma ) W(#it{l} #nu)";
  HistPlot* histPlot   = new HistPlot("HistPlot", plot_title);

  RFList<const HistPlotCategory> cat_list;
  int Nmass = mHp.size();
  for(int m = 0; m < Nmass; m++){
    char smass[50], scat[50];
    sprintf(scat, "MHp%.0f", mHp[m]);
    sprintf(smass, "m_{H^{ +}} = %.0f", mHp[m]);
    cat_list += histPlot->GetNewCategory(scat, smass);
  }

  const HistPlotCategory& cat_Hp  = histPlot->GetNewCategory("HprodHp", "h^{ 0} prod. frame = H^{ +}");
  const HistPlotCategory& cat_LAB = histPlot->GetNewCategory("HprodLAB", "h^{ 0} prod. frame = LAB");
  
  const HistPlotVar& MHp    = histPlot->GetNewVar("MHp", "M_{H^{ +}}", 0., 2400., "[GeV]");
  const HistPlotVar& MHpN   = histPlot->GetNewVar("MHpN", "M_{H^{ +}} / m_{H^{ +}}^{true}", 0.7, 1.05);
  const HistPlotVar& MWN    = histPlot->GetNewVar("MWN", "M_{W} / m_{W}^{true}", 0., 2.);
  const HistPlotVar& cosHp  = histPlot->GetNewVar("cosHp","cos #theta_{H^{ +}}", -1., 1.);
  const HistPlotVar& cosW   = histPlot->GetNewVar("cosW","cos #theta_{W}", -1., 1.);
  const HistPlotVar& cosH   = histPlot->GetNewVar("cosH","cos #theta_{h^{ 0}}", -1., 1.);
  const HistPlotVar& DcosHp = histPlot->GetNewVar("DcosHp","#theta_{H^{ +}} - #theta_{H^{ +}}^{true}", -1., 1.);
  const HistPlotVar& DcosW  = histPlot->GetNewVar("DcosW","#theta_{W} - #theta_{W}^{true}", -1., 1.);
  const HistPlotVar& DcosH  = histPlot->GetNewVar("DcosW","#theta_{h^{ 0}} - #theta_{h^{ 0}}^{true}", -1., 1.);

  histPlot->AddPlot(DcosH,  cat_list);
  histPlot->AddPlot(DcosW,  cat_list);
  histPlot->AddPlot(DcosHp, cat_list);
  histPlot->AddPlot(MWN,  cat_list);
  histPlot->AddPlot(MHpN, cat_list);
  histPlot->AddPlot(MHp,  cat_list);
  histPlot->AddPlot(MWN,    MHpN,   cat_list[2]);
  histPlot->AddPlot(DcosW, MWN,  cat_list[2]);
  histPlot->AddPlot(DcosHp, MHpN, cat_list[2]);
  histPlot->AddPlot(DcosHp, DcosW,  cat_list[2]);
  histPlot->AddPlot(DcosH,  MHpN,   cat_list[2]);
  
  histPlot->AddPlot(DcosH,  cat_Hp+cat_LAB);

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

  for(int m = 0; m < Nmass; m++){
    g_Log << LogInfo << "Generating events for H^{+} mass = " << mHp[m] << LogEnd;

    Hp_Gen.SetMass(mHp[m]);
    LAB_Gen.InitializeAnalysis();
  
    for(int igen = 0; igen < Ngen; igen++){
      if(igen%((std::max(Ngen,10))/10) == 0)
	g_Log << LogInfo << "Generating event " << igen << " of " << Ngen << LogEnd;
      
      // generate event
      LAB_Gen.ClearEvent();                            // clear the gen tree

      LAB_Gen.SetPToverM(gRandom->Rndm());             // give charged Higgs some Pt
      
      LAB_Gen.AnalyzeEvent();                          // generate a new event

      TVector3 MET = LAB_Gen.GetInvisibleMomentum();   // Get the MET from gen tree
      MET.SetZ(0.);
    
      // analyze event 
      LAB.ClearEvent();                                   // clear the reco tree
    
      L.SetLabFrameFourVector(L_Gen.GetFourVector());     // Set lepton 4-vec
      G1.SetLabFrameFourVector(G1_Gen.GetFourVector());   // Set photons' 4-vec
      G2.SetLabFrameFourVector(G2_Gen.GetFourVector());   
      INV.SetLabFrameThreeVector(MET);                    // Set the MET in reco tree
    
      LAB.AnalyzeEvent();                                 //analyze the event

      // Generator-level observables
      double MHpgen = Hp_Gen.GetMass();
      double MWgen  = W_Gen.GetMass();
      double cosHpgen = Hp_Gen.GetCosDecayAngle();
      double cosHgen  = H_Gen.GetCosDecayAngle();
      double cosWgen  = W_Gen.GetCosDecayAngle();

      // Reconstructed observables
      MHp    = Hp.GetMass();
      MHpN   = Hp.GetMass()/MHpgen;
      MWN    = W.GetMass()/MWgen;
      cosHp  = Hp.GetCosDecayAngle();
      cosH   = H.GetCosDecayAngle();
      cosW   = W.GetCosDecayAngle();
      DcosHp = asin(sqrt(1.-cosHp*cosHp)*cosHpgen-sqrt(1.-cosHpgen*cosHpgen)*cosHp);
      DcosH  = asin(sqrt(1.-cosH*cosH)*cosHgen-sqrt(1.-cosHgen*cosHgen)*cosH);
      DcosW  = asin(sqrt(1.-cosW*cosW)*cosWgen-sqrt(1.-cosWgen*cosWgen)*cosW);

      histPlot->Fill(cat_list[m]);

      if(m == 0){
	histPlot->Fill(cat_Hp);
	
	TVector3 Hboost = H.GetFourVector().BoostVector();
	TLorentzVector vP_G1 = G1.GetFourVector();
	vP_G1.Boost(-Hboost);
	cosH   = -vP_G1.Vect().Unit().Dot(Hboost.Unit());
	DcosH  = asin(sqrt(1.-cosH*cosH)*cosHgen-sqrt(1.-cosHgen*cosHgen)*cosH);

	histPlot->Fill(cat_LAB);
      }
    }

    LAB_Gen.PrintGeneratorEfficiency();
  }

  histPlot->Draw();
  
  TFile fout(output_name.c_str(),"RECREATE");
  fout.Close();
  histPlot->WriteOutput(output_name);
  histPlot->WriteHist(output_name);
  treePlot->WriteOutput(output_name);

  g_Log << LogInfo << "Finished" << LogEnd;

}