int get_circ_wg_efield_vert(TVector3 &pos, TVector3 &efield)
{
//returns the TE_11 efield inside an infinite circ. waveguide
//efield normalized the jackson way with 1/cm units
//waveguide extends in x-direction
// wavelength of 27 GHz radiation is 1.1 cm
double p11 = 1.841; //1st zero of the derivate of bessel function
//k11 is angular wavenumber for cutoff frequency for TE11
double k11 = p11 / tl_data.rO;
//convert position to cylindrical
pos.SetZ(0);
double radius = pos.Mag();
double phi = pos.Phi();//azimuthal position
//double phi = acos(pos.Y()/radius);//azimuthal position, see definition of phase
double J1 = TMath::BesselJ1(k11 * radius);//this term cancels in dot product w/ vel
double Jp = TMath::BesselJ0(k11 * radius) - TMath::BesselJ1(k11 * radius) / k11 / radius;
double e_amp = 1.63303/tl_data.rO;//cm
int status = 0;
if (radius > tl_data.rO) {
cout << "Problem!!! Electron hit a wall! At radius " << radius << endl;
status = 1;
}
efield.SetX(e_amp * (J1 / k11 / radius * cos(phi) * sin(phi) - Jp * sin(phi) * cos(phi)));
efield.SetY(e_amp * (J1 / k11 / radius * sin(phi) * sin(phi) + Jp * cos(phi) * cos(phi)));
efield.SetZ(0); //only true for TE mode
if (radius == 0) {
Jp = 1.0/2;
phi = 0;
efield.SetX(e_amp * (1. / 2 * cos(phi) * sin(phi) - Jp * sin(phi) * cos(phi)));
efield.SetY(e_amp * (1. / 2 * sin(phi) * sin(phi) + Jp * cos(phi) * cos(phi)));
}
return status;
}
int getSurfacePoint(TVector3 intPos, TVector3 &intDir, TVector3 &surfPos) {
Double_t b=intDir.X()*intPos.X() + intDir.Y()*intPos.Y() + intDir.Z()*intPos.Z();
Double_t c = intPos.X()*intPos.X() + intPos.Y()*intPos.Y() + intPos.Z()*intPos.Z() - rEarth*rEarth;
if(b*b < c)
return 0;
Double_t l1=-1*b + TMath::Sqrt(b*b - c);
Double_t l2=-1*b - TMath::Sqrt(b*b - c);
if(intPos.Mag2()> rEarth*rEarth) {
//Start outside take l1
//return 0;
// cout << "Outside:\t" << l1 << "\t" << l2 << endl;
intDir*=-1;
l1*=-1;
surfPos.SetX(intPos.X() + l1*intDir.X());
surfPos.SetY(intPos.Y() + l1*intDir.Y());
surfPos.SetZ(intPos.Z() + l1*intDir.Z());
// cout << surfPos.Mag() << endl;
}
else {
//Start inside take l2
// cout << "Inside:\t" << l1 << "\t" << l2 << endl;
// cout << l2 << endl;
// return 0;
surfPos.SetX(intPos.X() + l2*intDir.X());
surfPos.SetY(intPos.Y() + l2*intDir.Y());
surfPos.SetZ(intPos.Z() + l2*intDir.Z());
// cout << surfPos.Mag() << endl;
}
return 1;
}
static TVector3 floorXYZ(double zvtx, double physeta, double physphi) {
// Function to calculate detector position when particle is extrapolated
// to 3rd layer of em calorimeter.
// Note that we assume an x,y vertex position of zero.
// Also, the x,y cal shifts are not implemented...yet.
TVector3 v;
double phi = physphi;
double eta = physeta;
double theta = PTools::etaToTheta(eta);
double ztmp = zvtx + CC_3R/TMath::Tan(theta);
if( TMath::Abs(ztmp) >= EC_DIV ){ // in EC
(eta>=0) ? v.SetZ(EC_3Z_SOUTH) : v.SetZ(EC_3Z_NORTH);
v.SetX( (v.Z()-zvtx) * TMath::Tan(theta) * TMath::Cos(phi));
v.SetY( (v.Z()-zvtx) * TMath::Tan(theta) * TMath::Sin(phi));
}
else{ // in CC
v.SetZ(ztmp);
v.SetX( CC_3R * TMath::Cos(phi));
v.SetY( CC_3R * TMath::Sin(phi));
}
return v;
}
int get_tl_efield(TVector3 &p,TVector3 &efield)
{
//function returns the electric field between two infinite parallel wires
//efield normalized the jackson way with 1/cm units
//wires extend in z-direction and are can be offset
double e_amp = 1. / 2.0 / M_PI * sqrt(tl_data.C / (EPS0 / M2CM));
//calculate effective wire position for efield
TVector3 x1(tl_data.x1, 0, 0); //real position of first wire in cm
TVector3 x2(tl_data.x2, 0, 0); //real position of second wire in cm
TVector3 l = x1 - x2;
l *= 1./2;
double a = sqrt(l.Mag2() - pow(tl_data.rI, 2)); //effective wire half separation in cm
TVector3 a1 = x1 - l + a*l.Unit(); //effective position of first wire in cm
TVector3 a2 = x1 - l - a*l.Unit(); //effective position of second wire in cm
//vector from point to wires
p.SetZ(0);
TVector3 r1 = p + a1;
TVector3 r2 = p + a2;
//check for hitting wires
int status = 0;
if ( ( (x1-r1).Mag() < tl_data.rI ) || ( (x2-r2).Mag() < tl_data.rI ) ) {
cout << "Problem!!! Electron hit a wire! Radius " << p.Mag() << endl;
status = 1;
}
//efield = e_amp * (r1 * 1/r1.Mag2() - r2 * 1/r2.Mag2());
efield.SetX( e_amp * ( r1.X() / r1.Mag2() - r2.X() / r2.Mag2() ) );
efield.SetY( e_amp * ( r1.Y() / r1.Mag2() - r2.Y() / r2.Mag2() ) );
efield.SetZ( 0 ); //only true for TE or TEM modes
return status;
}
static TVector3 toGlobal(const TVector3 &local){
TVector3 global = local;
if(TMath::Abs(local.Z()) < EC_DIV){ //CC
global.SetX(global.X()+CC_XSHIFT);
global.SetY(global.Y()+CC_YSHIFT);
global.SetZ(global.Z()+CC_ZSHIFT);
}else{
if (local.Z() < 0) global.SetX(local.X()+EC_XSHIFT_NORTH);
global.SetZ( (local.Z()>0) ? EC_3Z_SOUTH : EC_3Z_NORTH );
}
return global;
}
static TVector3 toLocal(const TVector3 &global){
TVector3 local = global;
if(TMath::Abs(global.Z()) < EC_DIV){ //CC
local.SetX(local.X()-CC_XSHIFT);
local.SetY(local.Y()-CC_YSHIFT);
local.SetZ(local.Z()-CC_ZSHIFT);
}else{
if (global.Z() < 0) local.SetX(local.X()-EC_XSHIFT_NORTH);
local.SetZ( (global.Z()>0) ? EC_3Z : -EC_3Z );
}
return local;
}
// This is the deltaphi between the di-lepton system and the Higgs
// boost in the approximate Higgs rest frame, or R-FRAME
// L1 and L2 are the 4-vectors for the 2 hemispheres, or in you case,
// the two leptons - setting mass to 0 should be fine
// MET is the MET 3 vector (don't forget to set the z-component of
// MET to 0)
// This function will do the correct Lorentz transformations of the
// leptons for you
double HWWKinematics::CalcDoubleDphiRFRAME(){
// first calculate pt-corrected MR
float mymrnew = CalcMRNEW();
TVector3 BL = L1.Vect()+L2.Vect();
BL.SetX(0.0);
BL.SetY(0.0);
BL = (1./(L1.P()+L2.P()))*BL;
L1.Boost(-BL);
L2.Boost(-BL);
//Next, calculate the transverse Lorentz transformation
TVector3 B = L1.Vect()+L2.Vect()+MET;
B.SetZ(0.0);
B = (-1./(sqrt(4.*mymrnew*mymrnew+B.Dot(B))))*B;
L1.Boost(B);
L2.Boost(B);
// Now, calculate the delta phi
// between di-lepton axis and boost
// in new reference frame
return B.DeltaPhi(L1.Vect()+L2.Vect());
}
// This is the pt corrected delta phi between the 2 leptons
// P and L2 are the 4-vectors for the 2 hemispheres, or in you case,
// the two leptons - setting mass to 0 should be fine
// MET is the MET 3 vector (don't forget to set the z-component of
// MET to 0)
// This function will do the correct Lorentz transformations of the
// leptons for you
double HWWKinematics::CalcDeltaPhiRFRAME(){
// first calculate pt-corrected MR
float mymrnew = CalcMRNEW();
// Now, boost lepton system to rest in z
// (approximate accounting for longitudinal boost)
TVector3 BL = L1.Vect()+L2.Vect();
BL.SetX(0.0);
BL.SetY(0.0);
BL = (1./(L1.P()+L2.P()))*BL;
L1.Boost(-BL);
L2.Boost(-BL);
// Next, calculate the transverse Lorentz transformation
// to go to Higgs approximate rest frame
TVector3 B = L1.Vect()+L2.Vect()+MET;
B.SetZ(0.0);
B = (-1./(sqrt(4.*mymrnew*mymrnew+B.Dot(B))))*B;
L1.Boost(B);
L2.Boost(B);
//Now, re-calculate the delta phi
// in the new reference frame:
return L1.DeltaPhi(L2);
}
double coeff_of_t(TVector3 &efield, TVector3 &vel, int dir)
{
//returns A C(t), the coefficient of each waveguide mode in +x-direction
// in units of C*Ohm/s or volts
efield.SetZ( dir * efield.Z() );//only effect TM modes
return Echarge * tl_data.Zw / 2 * ( efield * vel ) / US2S;
}
int get_coax_efield(TVector3 &p, TVector3 &efield)
{
//function returns the electric field inside an infinite coaxial cable
//efield normalized the jackson way with 1/cm units
//cable extend in z-direction
double e_amp = 1 / sqrt(2.0 * M_PI * log(tl_data.rO / tl_data.rI));
int status = 0;
p.SetZ(0);
if (p.Mag() < tl_data.rI || p.Mag() > tl_data.rO) {
cout << "Problem!!! Electron hit the cable! " << endl;
status = 1;
}
efield.SetX( e_amp * p.X() / p.Mag2() );
efield.SetY( e_amp * p.Y() / p.Mag2() );
efield.SetZ( 0 ); //only true for TE or TEM modes
return status;
}
// M is the MET 3 vector (don't forget to set the z-component of
// MET to 0)
double HWWKinematics::CalcMRNEW(TLorentzVector P, TLorentzVector Q, TVector3 M){
TVector3 vI = M+P.Vect()+Q.Vect();
vI.SetZ(0.0);
double PpQ = CalcMR(P,Q); //Note - this calls the old MR function
double vptx = (P+Q).Px();
double vpty = (P+Q).Py();
TVector3 vpt;
vpt.SetXYZ(vptx,vpty,0.0);
float MR2 = 0.5*(PpQ*PpQ-vpt.Dot(vI)+PpQ*sqrt(PpQ*PpQ+vI.Dot(vI)-2.*vI.Dot(vpt)));
return sqrt(MR2);
}
// This is the pt corrected MR - here, we assume the pt
// of the Higgs is (MET+Pt+Qt);
// L1 and L2 are the 4-vectors for the 2 hemispheres, or in you case,
// the two leptons - setting mass to 0 should be fine
// MET is the MET 3 vector (don't forget to set the z-component of
// MET to 0)
// Also, 2 times this variable should give you the Higgs mass
double HWWKinematics::CalcMRNEW(){
TVector3 vI = MET+L1.Vect()+L2.Vect();
vI.SetZ(0.0);
double L1pL2 = CalcMR(); //Note - this calls the old MR function
double vptx = (L1+L2).Px();
double vpty = (L1+L2).Py();
TVector3 vpt;
vpt.SetXYZ(vptx,vpty,0.0);
float MR2 = 0.5*(L1pL2*L1pL2-vpt.Dot(vI)+L1pL2*sqrt(L1pL2*L1pL2+vI.Dot(vI)-2.*vI.Dot(vpt)));
return sqrt(MR2);
}
// This is the pt corrected delta phi between the 2 mega-jets
// P and Q are the 4-vectors for the 2 hemispheres
// M is the MET 3 vector (don't forget to set the z-component of
// MET to 0)
// This function will do the correct Lorentz transformations of the
// leptons for you
double HWWKinematics::CalcDeltaPhiNEW(TLorentzVector P, TLorentzVector Q, TVector3 M){
// first calculate pt-corrected MR
float mymrnew = CalcMRNEW(L1,L2,MET);
//Next, calculate the transverse Lorentz transformation
TVector3 B = P.Vect()+Q.Vect()+MET;
B.SetZ(0.0);
B = (-1./(sqrt(4.*mymrnew*mymrnew+B.Dot(B))))*B;
P.Boost(B);
Q.Boost(B);
//Now, re-calculate the delta phi
// in the new reference frame:
return P.DeltaPhi(Q);
}
double HWWKinematics::CalcUnboostedMTR(TLorentzVector P, TLorentzVector Q, TVector3 M){
// first calculate pt-corrected MR
float mymrnew = CalcMRNEW(L1,L2,MET);
//Next, calculate the transverse Lorentz transformation
TVector3 B = P.Vect()+Q.Vect()+MET;
B.SetZ(0.0);
B = (-1./(sqrt(4.*mymrnew*mymrnew+B.Dot(B))))*B;
P.Boost(B);
Q.Boost(B);
//Now, re-calculate MTR in the new reference frame:
float mymtrnew = CalcMTRNEW(P, Q);
//R is now just the ratio of mymrnew and mymtrnew;
return mymtrnew;
}
int get_sq_wg_efield(TVector3 &pos, TVector3 &efield)
{
//function returns the TE_10 efield inside an infinite square waveguide
//centered at x=0, y=0 (not with corner at origin as is standard)
//efield normalized the jackson way with 1/cm units
//waveguide extends in z-direction
// wavelength of 27 GHz radiation is 1.1 cm
double e_amp = sqrt(2 / tl_data.x1 / tl_data.y1);
int status = 0;
if ((pos.X() > tl_data.x1 / 2.) || (pos.X() < -tl_data.x1 / 2.)) {
cout << "Problem!!! Electron hit a wall in x-dir! " << endl;
status = 1;
}
if ((pos.Y() > tl_data.y1 / 2.) || (pos.Y() < -tl_data.y1 / 2.)) {
cout << "Problem!!! Electron hit a wall in y-dir! " << endl;
status = 1;
}
efield.SetX( 0 );
efield.SetY( e_amp * sin(M_PI * (pos.X() + tl_data.x1 / 2.) / tl_data.x1) );
efield.SetZ( 0 ); //is true for TE mode
return status;
}
int get_pp_efield(TVector3 &p, TVector3 &efield)
{
//function returns the electric field between two parallel plates
//amplitude corrected for capacitance of finite width strips
//not valid outside plates
//efield normalized the jackson way with 1/cm units
//strips extend in y- and z- directions, so the field is in the x-direction
double e_amp = sqrt(1 / (tl_data.n * tl_data.l * (tl_data.x2 - tl_data.x1)));
//factor of sqrt(n=1.8) lower than ideal capacitor
int status = 0;
if ((p.X() < tl_data.x1) || (p.X() > tl_data.x2)) {
cout << "Problem!!! Electron hit a plate! " << endl;
status = 1;
}
if ((p.Y() < -tl_data.l / 2) || (p.Y() > tl_data.l / 2)) {
cout << "Problem!!! Electron outside plates! " << endl;
status = 1;
}
efield.SetX( e_amp );
efield.SetY( 0 );
efield.SetZ( 0 ); //only true for TE or TEM modes
return status;
}
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;
}
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;
}
void example_Wlnu(const std::string& output_name = "output_Wlnu.root"){
double mW = 80.385; // GeV, PDG 2016
double wW = 2.085;
// Number of events to generate
int Ngen = 100000;
/////////////////////////////////////////////////////////////////////////////////////////
g_Log << LogInfo << "Initializing generator frames and tree..." << LogEnd;
/////////////////////////////////////////////////////////////////////////////////////////
LabGenFrame LAB_Gen("LAB_Gen","LAB");
ResonanceGenFrame W_Gen("W_Gen","W");
VisibleGenFrame L_Gen("L_Gen","#it{l}");
InvisibleGenFrame NU_Gen("NU_Gen","#nu");
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
LAB_Gen.SetChildFrame(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 W pole mass and width
W_Gen.SetMass(mW); W_Gen.SetWidth(wW);
// set lepton pT and eta cuts
L_Gen.SetPtCut(20.); L_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("LAB","LAB");
DecayRecoFrame W("W","W");
VisibleRecoFrame L("L","#it{l}");
InvisibleRecoFrame NU("NU","#nu");
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
LAB.SetChildFrame(W);
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;
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
// Now we add invisible jigsaws
InvisibleGroup INV("INV","Neutrino Jigsaws");
INV.AddFrame(NU);
// Set the neutrino mass
SetMassInvJigsaw MassJigsaw("MassJigsaw","m_{#nu} = 0");
INV.AddJigsaw(MassJigsaw);
// Set the neutrino rapidity
SetRapidityInvJigsaw RapidityJigsaw("RapidityJigsaw","#eta_{#nu} = #eta_{#it{l}}");
INV.AddJigsaw(RapidityJigsaw);
RapidityJigsaw.AddVisibleFrame(L);
if(LAB.InitializeAnalysis())
g_Log << LogInfo << "...Successfully initialized analyses" << LogEnd;
else
g_Log << LogError << "...Failed initializing analyses" << LogEnd;
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
TreePlot* tree_plot = new TreePlot("TreePlot","TreePlot");
// generator tree
tree_plot->SetTree(LAB_Gen);
tree_plot->Draw("GenTree", "Generator Tree", true);
// reconstruction tree
tree_plot->SetTree(LAB);
tree_plot->Draw("RecoTree", "Reconstruction Tree");
// Invisible Jigsaws tree
tree_plot->SetTree(INV);
tree_plot->Draw("InvTree", "InvisibleJigsaws", true);
//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//-//
// Declare observables for histogram booking
HistPlot* hist_plot = new HistPlot("HistPlot","W #rightarrow #it{l} #nu");
const HistPlotVar& MW = hist_plot->GetNewVar("MW", "M_{W}", 30., 120., "[GeV]");
const HistPlotVar& cosW = hist_plot->GetNewVar("cosW","cos #phi_{W}", -1., 1.);
const HistPlotVar& dphiW = hist_plot->GetNewVar("dphiW", "#Delta #phi_{W}", 0., 2.*acos(-1.));
const HistPlotVar& DcosW = hist_plot->GetNewVar("DcosW","#phi_{W} - #phi_{W}^{true}", -0.5, 0.5);
const HistPlotVar& DdphiW = hist_plot->GetNewVar("DdphiW","#Delta #phi_{W} - #Delta #phi_{W}^{true}", -0.5, 0.5);
const HistPlotVar& pTWoMW = hist_plot->GetNewVar("pTW","p_{T}^{W} / m_{W}",0.,1.);
const HistPlotCategory& cat_Gen = hist_plot->GetNewCategory("Reco", "Generator");
const HistPlotCategory& cat_Reco = hist_plot->GetNewCategory("Reco", "Reconstruction");
hist_plot->AddPlot(DcosW, cat_Reco);
hist_plot->AddPlot(DdphiW, cat_Reco);
hist_plot->AddPlot(MW, cat_Gen+cat_Reco);
hist_plot->AddPlot(DcosW, MW, cat_Reco);
hist_plot->AddPlot(DdphiW, MW, cat_Reco);
hist_plot->AddPlot(MW, pTWoMW, cat_Reco);
hist_plot->AddPlot(DcosW, pTWoMW, cat_Reco);
hist_plot->AddPlot(DdphiW, pTWoMW, cat_Reco);
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
pTWoMW = gRandom->Rndm();
LAB_Gen.SetPToverM(pTWoMW); // give the W some Pt
double PzW = mW*(2.*gRandom->Rndm()-1.);
LAB_Gen.SetLongitudinalMomentum(PzW); // give the W some Pz
LAB_Gen.AnalyzeEvent(); // generate a new event
// analyze event
LAB.ClearEvent(); // clear the reco tree
L.SetLabFrameFourVector(L_Gen.GetFourVector()); // Set lepton 4-vec
TVector3 MET = LAB_Gen.GetInvisibleMomentum(); // Get the MET from gen tree
MET.SetZ(0.);
INV.SetLabFrameThreeVector(MET); // Set the MET in reco tree
LAB.AnalyzeEvent(); // analyze the event
// generator-level observables
MW = W_Gen.GetMass();
cosW = cos(W_Gen.GetDeltaPhiDecayAngle());
dphiW = LAB_Gen.GetDeltaPhiDecayPlanes(W_Gen);
hist_plot->Fill(cat_Gen);
// calculate observables
MW = W.GetMass();
cosW = cos(W.GetDeltaPhiDecayAngle());
dphiW = LAB.GetDeltaPhiDecayPlanes(W);
double cosWgen = cos(W_Gen.GetDeltaPhiDecayAngle());
double dphiWgen = LAB_Gen.GetDeltaPhiDecayPlanes(W_Gen);
DcosW = asin(sqrt(1.-cosW*cosW)*cosWgen-sqrt(1.-cosWgen*cosWgen)*cosW);
DdphiW = asin(sin(dphiW-dphiWgen));
hist_plot->Fill(cat_Reco);
}
hist_plot->Draw();
TFile fout(output_name.c_str(),"RECREATE");
fout.Close();
hist_plot->WriteOutput(output_name);
hist_plot->WriteHist(output_name);
tree_plot->WriteOutput(output_name);
}
void RJ_ttbar(){
setstyle();
//give transverse momenta to CM system in lab frame?
double PT = 0.1; //In units of sqrt{shat}
//gamma factor associated with 'off-threshold-ness' of tops
double gamma = 1.2;
//Now, we also have the option to take gamma, event-by-event,
//from a more realistic distribution
//to do this, set 'b_gamma' to true and the rest
//of the variables below appropriately
bool b_gamma = true;
rootS = 13.;
type = 1; //0 quark-antiquark 1 gluon-gluon
M = 175./1000.; //TeV units
//Number of toy events to throw
int N = 1000;
//
// Generate fake events taking flat ME's for all decay angles
//
//here, we set up the stuff for dynamic gamma
TH1D *h_gamma = (TH1D*) new TH1D("newgamma","newgamma",500,1.0,10.0);
if(b_gamma){
cout << "generating gamma distribution" << endl;
for(int ibin = 1; ibin <= 500; ibin++){
double g = h_gamma->GetBinCenter(ibin);
double entry = Calc_dsigma_dgamma(g);
if(entry > 0.)
h_gamma->SetBinContent(ibin, entry);
}
cout << "done" << endl;
}
//////////////////////////////////////////////////////////////
// Setup rest frames code
//////////////////////////////////////////////////////////////
cout << " Initialize lists of visible, invisible particles and intermediate states " << endl;
RLabFrame* LAB = new RLabFrame("LAB","lab");
RDecayFrame* TT = new RDecayFrame("TT","t #bar{t}");
RDecayFrame* T1 = new RDecayFrame("T1","t_{a}");
RDecayFrame* T2 = new RDecayFrame("T2","t_{b}");
RVisibleFrame* Bjet1 = new RVisibleFrame("B1","b_{a}");
RVisibleFrame* Bjet2 = new RVisibleFrame("B2","b_{b}");
RDecayFrame* W1 = new RDecayFrame("W1","W_{a}");
RDecayFrame* W2 = new RDecayFrame("W2","W_{b}");
RVisibleFrame* Lep1 = new RVisibleFrame("L1","#it{l}_{a}");
RVisibleFrame* Lep2 = new RVisibleFrame("L2","#it{l}_{b}");
RInvisibleFrame* Neu1 = new RInvisibleFrame("NU1","#nu_{a}");
RInvisibleFrame* Neu2 = new RInvisibleFrame("NU2","#nu_{b}");
cout << " Define invisible and combinatoric groups " << endl;
InvisibleGroup INV("INV","Invisible State Jigsaws");
INV.AddFrame(Neu1);
INV.AddFrame(Neu2);
CombinatoricGroup BTAGS("BTAGS","B-tagged jet Jigsaws");
BTAGS.AddFrame(Bjet1);
BTAGS.SetNElementsForFrame(Bjet1,1,true);
BTAGS.AddFrame(Bjet2);
BTAGS.SetNElementsForFrame(Bjet2,1,true);
cout << " Build decay tree " << endl;
LAB->SetChildFrame(TT);
TT->AddChildFrame(T1);
TT->AddChildFrame(T2);
T1->AddChildFrame(Bjet1);
T1->AddChildFrame(W1);
T2->AddChildFrame(Bjet2);
T2->AddChildFrame(W2);
W1->AddChildFrame(Lep1);
W1->AddChildFrame(Neu1);
W2->AddChildFrame(Lep2);
W2->AddChildFrame(Neu2);
//check that tree topology is consistent
cout << "Is consistent topology: " << LAB->InitializeTree() << endl;
cout << "Initializing jigsaw rules" << endl;
InvisibleMassJigsaw MinMassJigsaw("MINMASS_JIGSAW", "Invisible system mass Jigsaw");
INV.AddJigsaw(MinMassJigsaw);
InvisibleRapidityJigsaw RapidityJigsaw("RAPIDITY_JIGSAW", "Invisible system rapidity Jigsaw");
INV.AddJigsaw(RapidityJigsaw);
RapidityJigsaw.AddVisibleFrame((LAB->GetListVisibleFrames()));
ContraBoostInvariantJigsaw TopJigsaw("TOP_JIGSAW","Contraboost invariant Jigsaw");
INV.AddJigsaw(TopJigsaw);
TopJigsaw.AddVisibleFrame((T1->GetListVisibleFrames()), 0);
TopJigsaw.AddVisibleFrame((T2->GetListVisibleFrames()), 1);
TopJigsaw.AddInvisibleFrame((T1->GetListInvisibleFrames()), 0);
TopJigsaw.AddInvisibleFrame((T2->GetListInvisibleFrames()), 1);
MinimizeMassesCombinatoricJigsaw BLJigsaw("BL_JIGSAW","Minimize m_{b#it{l}}'s Jigsaw");
BTAGS.AddJigsaw(BLJigsaw);
BLJigsaw.AddFrame(Bjet1,0);
BLJigsaw.AddFrame(Lep1,0);
BLJigsaw.AddFrame(Bjet2,1);
BLJigsaw.AddFrame(Lep2,1);
cout << "Initializing the tree for analysis : " << LAB->InitializeAnalysis() << endl;
//draw tree with jigsaws
FramePlot* jigsaw_plot = new FramePlot("tree","Decay Tree");
jigsaw_plot->AddFrameTree(LAB);
jigsaw_plot->AddJigsaw(TopJigsaw);
jigsaw_plot->AddJigsaw(BLJigsaw);
jigsaw_plot->DrawFramePlot();
for(int i = 0; i < N; i++){
if(b_gamma){
gamma = h_gamma->GetRandom();
}
//////////////////////////////////////////////////////////////
// BEGIN CODE TO generate toy GEN LEVEL events
//////////////////////////////////////////////////////////////
double Mt1 = 175.;
double MW1 = 80.;
double Mt2 = 175.;
double MW2 = 80.;
double Mnu1 = 0.;
double Mnu2 = 0.;
GetLepTopHem(0, Mt1, MW1, 5., 0.005, Mnu1);
GetLepTopHem(1, Mt2, MW2, 5., 0.005, Mnu2);
double EB1 = (Mt1*Mt1 - MW1*MW1)/(2.*Mt1);
double EB2 = (Mt2*Mt2 - MW2*MW2)/(2.*Mt2);
double EVIS1 = (Mt1*Mt1 - Mnu1*Mnu1)/(Mt1);
double EVIS2 = (Mt2*Mt2 - Mnu2*Mnu2)/(Mt2);
double EW1 = (Mt1*Mt1 + MW1*MW1)/(2.*Mt1);
double EW2 = (Mt2*Mt2 + MW2*MW2)/(2.*Mt2);
double EL1 = (MW1*MW1-Mnu1*Mnu1)/(2.*MW1);
double EL2 = (MW2*MW2-Mnu2*Mnu2)/(2.*MW2);
double gamma1 = EW1/MW1;
double gamma2 = EW2/MW2;
double beta1 = 1.;
double beta2 = 1.;
//put them in the lab frame
BoostToLabFrame(gamma);
// effective gamma factor for parents in CM frame
double g_eff = (P[0]+P[1]).M()/(2.*sqrt(P[0].M()*P[1].M()));
PtBoost(PT);
//////////////////////////////////////////////////////////////
// END CODE TO generate toy GEN LEVEL event
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// BEGIN CODE TO analyze GEN LEVEL events
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// First, we calculate approximate neutrino 4-vectors
// in W frames using two different strategies
//////////////////////////////////////////////////////////////
TLorentzVector NU1_top, NU2_top, NU1_W, NU2_W;
//
// first, we will assign 4-vectos in the lab frame for
// NU1_top and NU2_top by drawing a contraboost invariant symmetry
// between the two BL systems and neutrinos.
// Here, the tops are assumed to have the same boost factor in TT
// rest frame.
//
for(;;){
// get MET in lab frame
TVector3 MET = (vMiss[0]+vMiss[1]).Vect();
MET.SetZ(0.0);
// get b-quarks in lab frame
TLorentzVector B1, B2;
B1 = C_2[0];
B2 = C_2[1];
// get leptons in lab frame
TLorentzVector L1, L2;
L1 = C_1_1[0];
L2 = C_1_1[1];
//
// We separate the objects into decay hemispheres
// practice we will need to assign BL pairs according to
// metric (see commented below)
//
TLorentzVector VISTOT = B1+L1+B2+L2;
TVector3 boostTOT = VISTOT.BoostVector();
B1.Boost(-boostTOT);
B2.Boost(-boostTOT);
L1.Boost(-boostTOT);
L2.Boost(-boostTOT);
if( (B1+L2).P() > (B1+L1).P() ){
TLorentzVector temp = B1;
B1 = B2;
B2 = temp;
}
B1.Boost(boostTOT);
B2.Boost(boostTOT);
L1.Boost(boostTOT);
L2.Boost(boostTOT);
//
// visible hemispheres of top decays
//
TLorentzVector H1 = (B1+L1);
TLorentzVector H2 = (B2+L2);
//
// We will now attempt to travel through approximations of each of the rest frames
// of interest, beginning in the lab frame and ending in the TT rest frame, where
// we will specify the neutrino 4-momenta according to a contraboost invariant
// symmetry between the visible and invisible decay products of the two tops
//
//
// first, we boost from the lab frame to intermediate 'CMz' frame
// i.e. with the visible hemispheres' vectoral sum zero
//
TVector3 BL = H1.Vect()+H2.Vect();
BL.SetX(0.0);
BL.SetY(0.0);
BL = (1./(H1.E()+H2.E()))*BL;
B1.Boost(-BL);
L1.Boost(-BL);
B2.Boost(-BL);
L2.Boost(-BL);
H1.Boost(-BL);
H2.Boost(-BL);
//
// Now, we need to 'guess' the invariant mass of the weakly interacting system
// as a Lorentz-invariant quantity which is a function of the visible system
// masses, and large enough to accomodate the contraboost invariant
// solution we will use in the following TT CM frame. This allows us to write down
// the transverse part of the boost from lab to TT CM frame.
//
double Minv2 = (H1+H2).M2() - 4.*H1.M()*H2.M();
//double Minv2 = (H1+H2).M2() - 4.*min(H1.M2(),H2.M2());
//
// transverse momentum of total TT system in lab frame
// NOTE: (H1+H2).Pz() == 0 due to previous longitudinal boost
//
TVector3 PT = MET+(H1+H2).Vect();
double Einv2 = MET.Mag2() + Minv2;
PT.SetZ(0.0); // redundant
//
// transverse boost from 'CMz' frame to TT CM frame
//
TVector3 BT = (1./( (H1+H2).E() + sqrt(Einv2) ))*PT;
B1.Boost(-BT);
L1.Boost(-BT);
B2.Boost(-BT);
L2.Boost(-BT);
H1.Boost(-BT);
H2.Boost(-BT);
//
// Now, in TT CM approx frame we will make a contraboost invariant choise for the assymmetric boost, then specifying
// neutrino 4-vectors
//
//
// contra-boost invariant quantities (for this boost)
//
double m1 = H1.M();
double m2 = H2.M();
double MC2 = 2.*( H1.E()*H2.E() + H1.Vect().Dot(H2.Vect()) );
//
// contra-boost invariant coefficients
//
double k1 = m1*m1-m2*m2 + MC2 - 2.*m1*m2;
double k2 = m2*m2-m1*m1 + MC2 - 2.*m1*m2;
double N = ( fabs(k1*m1*m1 - k2*m2*m2) - 0.5*fabs(k2-k1)*MC2 + 0.5*(k1+k2)*sqrt(MC2*MC2-4.*m1*m1*m2*m2) )/(k1*k1*m1*m1+k2*k2*m2*m2+k1*k2*MC2);
double c1 = 0.5*(1.+N*k1);
double c2 = 0.5*(1.+N*k2);
//c1 = 1;
//c2 = 1;
//
// adjust coefficients such that di-neutrino invariant mass is equal to the Lorentz-invariant value we chose earlier,
// maintaining a contra-boost invariant ratio
//
double A = ( H1.E()+H2.E() + sqrt( (H1.E()+H2.E())*(H1.E()+H2.E()) -(H1+H2).M2() + Minv2 ))/(c1*H1.E()+c2*H2.E())/2.;
c1 *= A;
c2 *= A;
double Enu1 = (c1-1.)*H1.E() + c2*H2.E();
double Enu2 = c1*H1.E() + (c2-1.)*H2.E();
TVector3 pnu1 = (c1-1.)*H1.Vect() - c2*H2.Vect();
TVector3 pnu2 = (c2-1.)*H2.Vect() - c1*H1.Vect();
//
// define neutrino 4-vectors
//
NU1_top.SetPxPyPzE(pnu1.X(),pnu1.Y(),pnu1.Z(),Enu1);
NU2_top.SetPxPyPzE(pnu2.X(),pnu2.Y(),pnu2.Z(),Enu2);
//
// now, transform neutrinos back into lab frame
//
NU1_top.Boost(BT);
NU2_top.Boost(BT);
NU1_top.Boost(BL);
NU2_top.Boost(BL);
break;
}
//
// Next, we will assign 4-vectos in the lab frame for
// NU1_W and NU2_W by drawing a contraboost invariant symmetry
// between the two L systems and neutrinos.
// Here, the W's are assumed to have the same boost factor in the WW
// rest frame.
//
for(;;){
TVector3 MET = (vMiss[0]+vMiss[1]).Vect();
MET.SetZ(0.0);
//get b-quarks in lab frame
TLorentzVector B1, B2;
B1 = C_2[0];
B2 = C_2[1];
//get leptons in lab frame
TLorentzVector L1, L2;
L1 = C_1_1[0];
L2 = C_1_1[1];
//
// We separate the objects into decay hemispheres
// practice we will need to assign BL pairs according to
// metric (see commented below)
//
TLorentzVector VISTOT = B1+L1+B2+L2;
TVector3 boostTOT = VISTOT.BoostVector();
B1.Boost(-boostTOT);
B2.Boost(-boostTOT);
L1.Boost(-boostTOT);
L2.Boost(-boostTOT);
if( (B1+L2).P() > (B1+L1).P() ){
TLorentzVector temp = B1;
B1 = B2;
B2 = temp;
}
B1.Boost(boostTOT);
B2.Boost(boostTOT);
L1.Boost(boostTOT);
L2.Boost(boostTOT);
//
// visible hemispheres of top decays
//
TLorentzVector H1 = (B1+L1);
TLorentzVector H2 = (B2+L2);
//
// We will now attempt to travel through approximations of each of the rest frames
// of interest, beginning in the lab frame and ending in the WW rest frame, where
// we will specify the neutrino 4-momenta according to a contraboost invariant
// symmetry between the visible and invisible decay products of the two W's
//
//
// first, we boost from the lab frame to intermediate 'CMz' frame
// i.e. with the visible hemispheres' vectoral sum zero
//
TVector3 BL = H1.Vect()+H2.Vect();
BL.SetX(0.0);
BL.SetY(0.0);
BL = (1./(H1.E()+H2.E()))*BL;
B1.Boost(-BL);
L1.Boost(-BL);
B2.Boost(-BL);
L2.Boost(-BL);
H1.Boost(-BL);
H2.Boost(-BL);
//
// Now, we need to 'guess' the invariant mass of the weakly interacting system
// as a Lorentz-invariant quantity which is a function of the visible system
// masses, and large enough to accomodate the contraboost invariant
// solution we will use in the following WW CM frame. This allows us to write down
// the transverse part of the boost from lab to WW CM frame.
//
double Minv2 = (L1+L2).M2();
TVector3 PT = MET+(L1+L2).Vect();
double Einv2 = MET.Mag2() + Minv2;
TVector3 BT = (1./( (L1+L2).E() + sqrt(Einv2) ))*PT;
L1.Boost(-BT);
L2.Boost(-BT);
//
// Now, in WW CM approx frame we will make a contraboost invariant choise for the assymmetric boost, then specifying
// neutrino 4-vectors
//
//
// contra-boost invariant coefficients are both 1, scaling factor to fix di-neutrino invariant mass
// is 1, since (L1+L2).M2() = Minv2
//
double c = ( L1.E()+L2.E() + sqrt( (L1.E()+L2.E())*(L1.E()+L2.E()) -(L1+L2).M2() + Minv2 ))/(L1.E()+L2.E())/2.; //obviously redundant
double Enu1 = (c-1.)*L1.E() + c*L2.E();
double Enu2 = c*L1.E() + (c-1.)*L2.E();
TVector3 pnu1 = (c-1.)*L1.Vect() - c*L2.Vect();
TVector3 pnu2 = (c-1.)*L2.Vect() - c*L1.Vect();
//define neutrino 4-vectors
NU1_W.SetPxPyPzE(pnu1.X(),pnu1.Y(),pnu1.Z(),Enu1);
NU2_W.SetPxPyPzE(pnu2.X(),pnu2.Y(),pnu2.Z(),Enu2);
//now, go back to lab frame
NU1_W.Boost(BT);
NU2_W.Boost(BT);
NU1_W.Boost(BL);
NU2_W.Boost(BL);
break;
}
//
// Now we have our guess for the neutrino 4-vectors in the lab frame
// using two different approaches (top or W symmetry, NUi_top and NUi_W
// 4-vectors, respectively), along with the 'truth' values.
// We will now go through all of the relevant reference frames in our approximate
// reconstructions and in truth simultaenously to calculate observables
//
TLorentzVector B1, B2;
B1 = C_2[0];
B2 = C_2[1];
//get leptons in lab frame
TLorentzVector L1, L2;
L1 = C_1_1[0];
L2 = C_1_1[1];
//get truth neutrinos in lab frame
TLorentzVector NU1, NU2;
NU1 = C_1_2[0];
NU2 = C_1_2[1];
TVector3 MET = (vMiss[0]+vMiss[1]).Vect();
MET.SetZ(0.0);
INV.ClearEvent();
BTAGS.ClearEvent();
Lep1->SetLabFrameFourVector(L1);
Lep2->SetLabFrameFourVector(L2);
GroupElementID B1_ID = BTAGS.AddLabFrameFourVector(B1);
GroupElementID B2_ID = BTAGS.AddLabFrameFourVector(B2);
INV.SetLabFrameThreeVector(MET);
LAB->AnalyzeEvent();
//
// Now we have two different sets of neutrino guesses in lab frame - define matching visible particles
//
TLorentzVector B1_top = B1;
TLorentzVector B2_top = B2;
TLorentzVector L1_top = L1;
TLorentzVector L2_top = L2;
TLorentzVector B1_W = B1;
TLorentzVector B2_W = B2;
TLorentzVector L1_W = L1;
TLorentzVector L2_W = L2;
//
// We separate the objects into decay hemispheres
// practice we will need to assign BL pairs according to
// metric for 'reconstructed' events (see commented below)
//
TLorentzVector VISTOT_top = B1_top+L1_top+B2_top+L2_top;
TVector3 boostTOT_top = VISTOT_top.BoostVector();
B1_top.Boost(-boostTOT_top);
B2_top.Boost(-boostTOT_top);
L1_top.Boost(-boostTOT_top);
L2_top.Boost(-boostTOT_top);
if( (B1_top+L2_top).P() > (B1_top+L1_top).P() ){
TLorentzVector temp = B1_top;
B1_top = B2_top;
B2_top = temp;
}
B1_top.Boost(boostTOT_top);
B2_top.Boost(boostTOT_top);
L1_top.Boost(boostTOT_top);
L2_top.Boost(boostTOT_top);
/*
if( (B1_W+L1_W).M2()+(B2_W+L2_W).M2() > (B1_W+L2_W).M2()+(B2_W+L1_W).M2() ){
TLorentzVector temp = L1_W;
L1_W = L2_W;
L2_W = temp;
}
*/
//
// visible hemispheres of top decays
//
TLorentzVector H1 = L1+B1+NU1;
TLorentzVector H2 = L2+B2+NU2;
TLorentzVector H1_top = L1_top+B1_top+NU1_top;
TLorentzVector H2_top = L2_top+B2_top+NU2_top;
TLorentzVector H1_W = L1+B1+NU1_W;
TLorentzVector H2_W = L2+B2+NU2_W;
cout << "TT mass: " << (H1_top+H2_top).M() << " " << TT->GetMass() << endl;
cout << "T1 mass: " << H1_top.M() << " " << T1->GetMass() << endl;
cout << "T2 mass: " << H2_top.M() << " " << T2->GetMass() << endl;
cout << "W1 mass: " << (L1_top+NU1_top).M() << " " << W1->GetMass() << endl;
cout << "W2 mass: " << (L2_top+NU2_top).M() << " " << W2->GetMass() << endl;
cout << "NU1 mass: " << NU1_top.M() << " " << Neu1->GetMass() << endl;
cout << "NU2 mass: " << NU2_top.M() << " " << Neu2->GetMass() << endl;
cout << "MET: " << (Neu1->GetFourVector(LAB)+Neu2->GetFourVector(LAB)).Pt() << " " << MET.Mag() << endl;
/*
cout << "TT mass: " << (H1_W+H2_W).M() << " " << TT->GetMass() << endl;
cout << "T1 mass: " << H1_W.M() << " " << T1->GetMass() << endl;
cout << "T2 mass: " << H2_W.M() << " " << T2->GetMass() << endl;
cout << "W1 mass: " << (L1+NU1_W).M() << " " << W1->GetMass() << endl;
cout << "W2 mass: " << (L2+NU2_W).M() << " " << W2->GetMass() << endl;
cout << "NU1 mass: " << NU1_W.M() << " " << Neu1->GetMass() << endl;
cout << "NU2 mass: " << NU2_W.M() << " " << Neu2->GetMass() << endl;
*/
//
// In the lab frame - let's move now to the ttbar CM frame
// boosts
//
TVector3 BltoCM = (H1+H2).BoostVector();
TVector3 BltoCM_top = (H1_top+H2_top).BoostVector();
TVector3 BltoCM_W = (H1_W+H2_W).BoostVector();
H1.Boost(-BltoCM);
H2.Boost(-BltoCM);
L1.Boost(-BltoCM);
L2.Boost(-BltoCM);
NU1.Boost(-BltoCM);
NU2.Boost(-BltoCM);
B1.Boost(-BltoCM);
B2.Boost(-BltoCM);
H1_top.Boost(-BltoCM_top);
H2_top.Boost(-BltoCM_top);
L1_top.Boost(-BltoCM_top);
L2_top.Boost(-BltoCM_top);
B1_top.Boost(-BltoCM_top);
B2_top.Boost(-BltoCM_top);
NU1_top.Boost(-BltoCM_top);
NU2_top.Boost(-BltoCM_top);
H1_W.Boost(-BltoCM_W);
H2_W.Boost(-BltoCM_W);
L1_W.Boost(-BltoCM_W);
L2_W.Boost(-BltoCM_W);
B1_W.Boost(-BltoCM_W);
B2_W.Boost(-BltoCM_W);
NU1_W.Boost(-BltoCM_W);
NU2_W.Boost(-BltoCM_W);
//
// angles in the TT CM frames, approximate and true
//
double costhetaTT = H1.Vect().Unit().Dot( BltoCM.Unit() );
double dphiTT = fabs(H1.Vect().DeltaPhi( BltoCM ));
double dphiM = fabs( (B1+B2+L1+L2).Vect().DeltaPhi( BltoCM ));
double costhetaTT_top = fabs( H1_top.Vect().Unit().Dot( BltoCM_top.Unit() ));
double dphiTT_top = fabs(H1_top.Vect().DeltaPhi( BltoCM_top ));
double dphiM_top = fabs( (B1_top+B2_top+L1_top+L2_top).Vect().DeltaPhi( BltoCM_top ));
double costhetaTT_W = fabs( H1_W.Vect().Unit().Dot( BltoCM_W.Unit() ));
double dphiTT_W = fabs(H1_W.Vect().DeltaPhi( BltoCM_W ));
double dphiM_W = fabs( (B1_W+B2_W+L1_W+L2_W).Vect().DeltaPhi( BltoCM_W ));
//scale
double MTT = (H1+H2).M();
double MTT_top = (H1_top+H2_top).M();
double MTT_W = (H1_W+H2_W).M();
// vector normal to decay plane of CM frame (for later azimuthal angles)
TVector3 vNORM_CM_T1 = B1.Vect().Cross((L1+NU1).Vect());
TVector3 vNORM_CM_T2 = B2.Vect().Cross((L2+NU2).Vect());
double dphi_T1_T2 = vNORM_CM_T1.Angle(vNORM_CM_T2);
double dot_dphi_T1_T2 = B1.Vect().Dot(vNORM_CM_T2);
if(dot_dphi_T1_T2 < 0.0 && dphi_T1_T2 > 0.0){
dphi_T1_T2 = TMath::Pi()*2. - dphi_T1_T2;
}
TVector3 vNORM_CM_T1_top = B1_top.Vect().Cross((L1_top+NU1_top).Vect());
TVector3 vNORM_CM_T2_top = B2_top.Vect().Cross((L2_top+NU2_top).Vect());
double dphi_T1_T2_top = vNORM_CM_T1_top.Angle(vNORM_CM_T2_top);
double dot_dphi_T1_T2_top = B1_top.Vect().Dot(vNORM_CM_T2_top);
if(dot_dphi_T1_T2_top < 0.0 && dphi_T1_T2_top > 0.0){
dphi_T1_T2_top = TMath::Pi()*2. - dphi_T1_T2_top;
}
TVector3 vNORM_CM_T1_W = B1_W.Vect().Cross((L1_W+NU1_W).Vect());
TVector3 vNORM_CM_T2_W = B2_W.Vect().Cross((L2_W+NU2_W).Vect());
double dphi_T1_T2_W = vNORM_CM_T1_W.Angle(vNORM_CM_T2_W);
double dot_dphi_T1_T2_W = B1.Vect().Dot(vNORM_CM_T2_W);
if(dot_dphi_T1_T2_W < 0.0 && dphi_T1_T2_W > 0.0){
dphi_T1_T2_W = TMath::Pi()*2. - dphi_T1_T2_W;
}
double ddphi_T1_T2_top = sin(dphi_T1_T2_top-dphi_T1_T2);
double ddphi_T1_T2_W = sin(dphi_T1_T2_W-dphi_T1_T2);
//
// To the next frames!!!!
// now, to 'top' CM frame approxs and truth
//
TVector3 BCMtoT1 = H1.BoostVector();
TVector3 BCMtoT2 = H2.BoostVector();
TVector3 BCMtoT1_top = H1_top.BoostVector();
TVector3 BCMtoT2_top = H2_top.BoostVector();
TVector3 BCMtoT1_W = H1_W.BoostVector();
TVector3 BCMtoT2_W = H2_W.BoostVector();
B1.Boost(-BCMtoT1);
B2.Boost(-BCMtoT2);
L1.Boost(-BCMtoT1);
L2.Boost(-BCMtoT2);
NU1.Boost(-BCMtoT1);
NU2.Boost(-BCMtoT2);
B1_top.Boost(-BCMtoT1_top);
B2_top.Boost(-BCMtoT2_top);
L1_top.Boost(-BCMtoT1_top);
L2_top.Boost(-BCMtoT2_top);
NU1_top.Boost(-BCMtoT1_top);
NU2_top.Boost(-BCMtoT2_top);
B1_W.Boost(-BCMtoT1_W);
B2_W.Boost(-BCMtoT2_W);
L1_W.Boost(-BCMtoT1_W);
L2_W.Boost(-BCMtoT2_W);
NU1_W.Boost(-BCMtoT1_W);
NU2_W.Boost(-BCMtoT2_W);
cout << W1->GetFourVector(T1).E() << " " << (L1_top+NU1_top).E() << endl;
cout << W2->GetFourVector(T2).E() << " " << (L2_top+NU2_top).E() << endl;
//
// decay angles in top frames
//
double costhetaT1 = B1.Vect().Unit().Dot(BCMtoT1.Unit());
double costhetaT2 = B2.Vect().Unit().Dot(BCMtoT2.Unit());
double costhetaT1_top = B1_top.Vect().Unit().Dot(BCMtoT1_top.Unit());
double costhetaT2_top = B2_top.Vect().Unit().Dot(BCMtoT2_top.Unit());
double costhetaT1_W = B1_W.Vect().Unit().Dot(BCMtoT1_W.Unit());
double costhetaT2_W = B2_W.Vect().Unit().Dot(BCMtoT2_W.Unit());
double dcosthetaT1_top = costhetaT1_top*sqrt(1.-costhetaT1*costhetaT1)-costhetaT1*sqrt(1.-costhetaT1_top*costhetaT1_top);
double dcosthetaT2_top = costhetaT2_top*sqrt(1.-costhetaT2*costhetaT2)-costhetaT2*sqrt(1.-costhetaT2_top*costhetaT2_top);
double dcosthetaT1_W = costhetaT1_W*sqrt(1.-costhetaT1*costhetaT1)-costhetaT1*sqrt(1.-costhetaT1_W*costhetaT1_W);
double dcosthetaT2_W = costhetaT2_W*sqrt(1.-costhetaT2*costhetaT2)-costhetaT2*sqrt(1.-costhetaT2_W*costhetaT2_W);
//vectors normal to decay planes of T frames
TVector3 vNORM_T1_B = B1.Vect().Cross(BCMtoT1);
TVector3 vNORM_T2_B = B2.Vect().Cross(BCMtoT2);
TVector3 vNORM_T1_B_top = B1_top.Vect().Cross(BCMtoT1_top);
TVector3 vNORM_T2_B_top = B2_top.Vect().Cross(BCMtoT2_top);
TVector3 vNORM_T1_B_W = B1_W.Vect().Cross(BCMtoT1_W);
TVector3 vNORM_T2_B_W = B2_W.Vect().Cross(BCMtoT2_W);
//vectors normal to W decay planes in T frames
TVector3 vNORM_T1_W = L1.Vect().Cross(NU1.Vect());
TVector3 vNORM_T2_W = L2.Vect().Cross(NU2.Vect());
TVector3 vNORM_T1_W_top = L1_top.Vect().Cross(NU1_top.Vect());
TVector3 vNORM_T2_W_top = L2_top.Vect().Cross(NU2_top.Vect());
TVector3 vNORM_T1_W_W = L1_W.Vect().Cross(NU1_W.Vect());
TVector3 vNORM_T2_W_W = L2_W.Vect().Cross(NU2_W.Vect());
double dphi_W_T1 = vNORM_T1_W.Angle(vNORM_T1_B);
double dphi_W_T2 = vNORM_T2_W.Angle(vNORM_T2_B);
double dot_dphi_W_T1 = L1.Vect().Dot(vNORM_T1_B);
double dot_dphi_W_T2 = L2.Vect().Dot(vNORM_T2_B);
if(dot_dphi_W_T1 < 0.0 && dphi_W_T1 > 0.0){
dphi_W_T1 = TMath::Pi()*2. - dphi_W_T1;
}
if(dot_dphi_W_T2 < 0.0 && dphi_W_T2 > 0.0){
dphi_W_T2 = TMath::Pi()*2. - dphi_W_T2;
}
double dphi_W_T1_top = vNORM_T1_W_top.Angle(vNORM_T1_B_top);
double dphi_W_T2_top = vNORM_T2_W_top.Angle(vNORM_T2_B_top);
double dot_dphi_W_T1_top = L1_top.Vect().Dot(vNORM_T1_B_top);
double dot_dphi_W_T2_top = L2_top.Vect().Dot(vNORM_T2_B_top);
if(dot_dphi_W_T1_top < 0.0 && dphi_W_T1_top > 0.0){
dphi_W_T1_top = TMath::Pi()*2. - dphi_W_T1_top;
}
if(dot_dphi_W_T2_top < 0.0 && dphi_W_T2_top > 0.0){
dphi_W_T2_top = TMath::Pi()*2. - dphi_W_T2_top;
}
double dphi_W_T1_W = vNORM_T1_W_W.Angle(vNORM_T1_B_W);
double dphi_W_T2_W = vNORM_T2_W_W.Angle(vNORM_T2_B_W);
double dot_dphi_W_T1_W = L1_W.Vect().Dot(vNORM_T1_B_W);
double dot_dphi_W_T2_W = L2_W.Vect().Dot(vNORM_T2_B_W);
if(dot_dphi_W_T1_W < 0.0 && dphi_W_T1_W > 0.0){
dphi_W_T1_W = TMath::Pi()*2. - dphi_W_T1_W;
}
if(dot_dphi_W_T2_W < 0.0 && dphi_W_T2_W > 0.0){
dphi_W_T2_W = TMath::Pi()*2. - dphi_W_T2_W;
}
//
// differences between true and reco azimuthal angles
//
double ddphi_W_T1_top = sin(dphi_W_T1_top-dphi_W_T1);
double ddphi_W_T2_top = sin(dphi_W_T2_top-dphi_W_T2);
double ddphi_W_T1_W = sin(dphi_W_T1_W-dphi_W_T1);
double ddphi_W_T2_W = sin(dphi_W_T2_W-dphi_W_T2);
//
// gamma for asymmetric boost
//
double gammaT = 1./pow( (1.-BCMtoT1.Mag2())*(1.-BCMtoT2.Mag2()),1./4. );
double gammaT_top = 1./sqrt(1.-BCMtoT1_top.Mag2());
double gammaT_W = 1./pow( (1.-BCMtoT1_W.Mag2())*(1.-BCMtoT2_W.Mag2()),1./4. );
//
// scale variables
//
double MT1 = H1.M();
double MT2 = H2.M();
double MT_top = H1_top.M();
double MT1_W = H1_W.M();
double MT2_W = H2_W.M();
double Eb1 = B1.E();
double Eb2 = B2.E();
double Eb1_top = B1_top.E();
double Eb2_top = B2_top.E();
double Eb1_W = B1_W.E();
double Eb2_W = B2_W.E();
//
// Heading to the last frames!!!!!
// from the T rest frames to the W rest frames
//
TVector3 BTtoW1 = (L1+NU1).BoostVector();
TVector3 BTtoW2 = (L2+NU2).BoostVector();
TVector3 BTtoW1_top = (L1_top+NU1_top).BoostVector();
TVector3 BTtoW2_top = (L2_top+NU2_top).BoostVector();
TVector3 BTtoW1_W = (L1_W+NU1_W).BoostVector();
TVector3 BTtoW2_W = (L2_W+NU2_W).BoostVector();
L1.Boost(-BTtoW1);
NU1.Boost(-BTtoW1);
L2.Boost(-BTtoW2);
NU2.Boost(-BTtoW2);
L1_top.Boost(-BTtoW1_top);
NU1_top.Boost(-BTtoW1_top);
L2_top.Boost(-BTtoW2_top);
NU2_top.Boost(-BTtoW2_top);
L1_W.Boost(-BTtoW1_W);
NU1_W.Boost(-BTtoW1_W);
L2_W.Boost(-BTtoW2_W);
NU2_W.Boost(-BTtoW2_W);
//
// scales in the W rest frame
//
double El1 = L1.E();
double El2 = L2.E();
double El1_top = L1_top.E();
double El2_top = L2_top.E();
double El1_W = L1_W.E();
double El2_W = L2_W.E();
//calculate some angles
double costhetaW1 = L1.Vect().Unit().Dot(BTtoW1.Unit());
double costhetaW2 = L2.Vect().Unit().Dot(BTtoW2.Unit());
double costhetaW1_top = L1_top.Vect().Unit().Dot(BTtoW1_top.Unit());
double costhetaW2_top = L2_top.Vect().Unit().Dot(BTtoW2_top.Unit());
double costhetaW1_W = L1_W.Vect().Unit().Dot(BTtoW1_W.Unit());
double costhetaW2_W = L2_W.Vect().Unit().Dot(BTtoW2_W.Unit());
double dcosthetaW1_top = costhetaW1*sqrt(1.-costhetaW1_top*costhetaW1_top) - costhetaW1_top*sqrt(1.-costhetaW1*costhetaW1);
double dcosthetaW2_top = costhetaW2*sqrt(1.-costhetaW2_top*costhetaW2_top) - costhetaW2_top*sqrt(1.-costhetaW2*costhetaW2);
double dcosthetaW1_W = costhetaW1*sqrt(1.-costhetaW1_W*costhetaW1_W) - costhetaW1_W*sqrt(1.-costhetaW1*costhetaW1);
double dcosthetaW2_W = costhetaW2*sqrt(1.-costhetaW2_W*costhetaW2_W) - costhetaW2_W*sqrt(1.-costhetaW2*costhetaW2);
// define different scale sensitive ratios
double El1Eb1_top = El1_top/(El1_top+Eb1_top);
double El1Eb1_W = El1_W/(El1_W+Eb1_W);
double El1Eb2_top = El1_top/(El1_top+Eb2_top);
double El1Eb2_W = El1_W/(El1_W+Eb2_W);
cout << "TT costheta: " << costhetaTT_top << " " << TT->GetCosDecayAngle() << endl;
cout << "T1 costheta: " << costhetaT1_top << " " << T1->GetCosDecayAngle() << endl;
cout << "T2 costheta: " << costhetaT2_top << " " << T2->GetCosDecayAngle() << endl;
cout << "dphi_T1_T2_top: " << dphi_T1_T2_top << " " << T1->GetDeltaPhiDecayPlanes(T2) << endl;
cout << "dphi_W_T1_top: " << dphi_W_T1_top << " " << T1->GetDeltaPhiDecayPlanes(W1) << endl;
TLorentzVector newB1 = Bjet1->GetFourVector(T1);
TLorentzVector newB2 = Bjet2->GetFourVector(T2);
TLorentzVector newL1 = Lep1->GetFourVector(W1);
TLorentzVector newL2 = Lep2->GetFourVector(W2);
TLorentzVector newNU1 = Neu1->GetFourVector(W1);
TLorentzVector newNU2 = Neu2->GetFourVector(W2);
cout << "Eb1: " << Eb1_top << " " << newB1.E() << endl;
cout << "Eb2: " << Eb2_top << " " << newB2.E() << endl;
cout << "El1: " << El1_top << " " << newL1.E() << endl;
cout << "El2: " << El2_top << " " << newL2.E() << endl;
cout << "ENU1: " << NU1_top.E() << " " << newNU1.E() << endl;
cout << "ENU2: " << NU2_top.E() << " " << newNU2.E() << endl;
}
}
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;
}
