TVector3 CalculateScatVec(TVector3 Incoming ,TVector3 ScatLab){
//What is quicker passing in same value each time or defining value here each time?
zprime = income.Unit();
yprime = zlab.Cross(-income);
yprime = yprime.Unit();
xprime = yprime.Cross(zprime);
xprime = xprime.Unit();
RotM[0][0] = xlab.Dot(xprime) ;
RotM[0][1] = xlab.Dot(yprime);
RotM[0][2] = xlab.Dot(zprime);
RotM[1][0] = ylab.Dot(xprime);
RotM[1][1] = ylab.Dot(yprime) ;
RotM[1][2] = ylab.Dot(zprime) ;
RotM[2][0] = zlab.Dot(xprime);
RotM[2][1] = zlab.Dot(yprime);
RotM[2][2] = zlab.Dot(zprime);
TVector3 ScatNuc;
ScatNuc(0) = (RotM[0][0]*ScatLab(0) + RotM[1][0]*ScatLab(1) + RotM[2][0]*ScatLab(2) );
ScatNuc(1) = (RotM[0][1]*ScatLab(0) + RotM[1][1]*ScatLab(1) + RotM[2][1]*ScatLab(2) );
ScatNuc(2) = (RotM[0][2]*ScatLab(0) + RotM[1][2]*ScatLab(1) + RotM[2][2]*ScatLab(2) );
//std::cout << zprime(0) << " " << zprime(1) << " " << zprime(2) <<std::endl;
return ScatNuc;
}
//plane class constructor
Plane::Plane(TVector3 nT){
//Use TVector3 to find an orthogonal vector and a second vector orthogonal to the first and nT
v1 = nT.Orthogonal(); v2 = nT.Cross(v1);
//Normalize, checking for 0 length axes
if ((v1(0) == 0) && (v1(1) == 0) && (v1(2) == 0)){ v1(0) = 0; v1(1) = 0; v1(2) = 0; }
else { mag1 = v1.Mag(); v1(0) = v1(0)/mag1; v1(1) = v1(1)/mag1; v1(2) = v1(2)/mag1; }
if ((v2(0) == 0) && (v2(1) == 0) && (v2(2) == 0)){ v2(0) = 0; v2(1) = 0; v2(2) = 0; }
else { mag2 = v2.Mag(); v2(0) = v2(0)/mag2; v2(1) = v2(1)/mag2; v2(2) = v2(2)/mag2; }
}//end plane constructor
////////////////////////////////////////////////////////////////////////
// Calculates theta and phi in HX frame
////////////////////////////////////////////////////////////////////////
pair<double, double> GetAngles_HX( TLorentzVector a, TLorentzVector b) {
TLorentzVector c = a+b; // JPsi momentum in lab frame
TVector3 bv = c.BoostVector();
TLorentzVector p1(0., 0., 1380., 1380.); // beam momentum in lab frame
TLorentzVector p2(0., 0., -1380., 1380.); // beam momentum in lab frame
p1.Boost(-bv);
p2.Boost(-bv);
TVector3 beam1 = p1.Vect().Unit(); // beam direction in JPsi rest frame
TVector3 beam2 = p2.Vect().Unit(); // beam direction in JPsi rest frame
TVector3 Z = c.Vect().Unit(); // JPsi direction in lab frame
TVector3 Y = beam1.Cross( beam2 ).Unit(); // the production plane normal
TVector3 X = Y.Cross(Z).Unit(); // completes the right-handed coordinate
a.Boost(-bv); // muon+ momentum in JPsi rest frame
TVector3 mu(a.Vect().Dot(X), a.Vect().Dot(Y), a.Vect().Dot(Z)); // transform to new coordinate
pair<double, double> angles;
angles.first = mu.Theta();
angles.second = mu.Phi()>0. ? mu.Phi() : mu.Phi()+2.*TMath::Pi();
return angles;
}
void polGen(double rapdilepton_min = 1,
double rapdilepton_max = 1,
double pTdilepton_min = 1,
double pTdilepton_max = 1,
double mass_signal_peak = 1,
double mass_signal_sigma = 1,
double n_sigmas_signal = 1,
int n_events = 50000,
double f_BG = 0.5,
double lambda_theta_sig=1,
double lambda_phi_sig=1,
double lambda_thetaphi_sig=1,
double lambda_theta_bkg=1,
double lambda_phi_bkg=1,
double lambda_thetaphi_bkg=1,
int frameSig=1,//CS...1, HX...2, PX...3
int frameBkg=1,//CS...1, HX...2, PX...3
int nGen=1,
Char_t *dirstruct = "ToyDirectory_Default"
){
char frameSigName[200];
if(frameSig==1)sprintf(frameSigName,"CS");
if(frameSig==2)sprintf(frameSigName,"HX");
if(frameSig==3)sprintf(frameSigName,"PX");
char frameBkgName[200];
if(frameBkg==1)sprintf(frameBkgName,"CS");
if(frameBkg==2)sprintf(frameBkgName,"HX");
if(frameBkg==3)sprintf(frameBkgName,"PX");
if(frameSig==2) HX_is_natural_sig=true; if(frameSig==3) PX_is_natural_sig=true; //else CS is the natural frame by default
if(frameBkg==2) HX_is_natural_bkg=true; if(frameBkg==3) PX_is_natural_bkg=true; //else CS is the natural frame by default
cout<<"Number of Events to be generated ........... "<<n_events<<endl;
cout<<"pT min ..................................... "<<pTdilepton_min<<endl;
cout<<"pT max ..................................... "<<pTdilepton_max<<endl;
cout<<"Rapidity min ............................... "<<rapdilepton_min<<endl;
cout<<"Rapidity max ............................... "<<rapdilepton_max<<endl;
cout<<"Background Fraction ........................ "<<f_BG<<endl;
cout<<"Injected lambda_theta Signal ............... "<<lambda_theta_sig<<" , in the "<<frameSigName<<" frame"<<endl;
cout<<"Injected lambda_phi Signal ................. "<<lambda_phi_sig<<" , in the "<<frameSigName<<" frame"<<endl;
cout<<"Injected lambda_thetaphi Signal ............ "<<lambda_thetaphi_sig<<" , in the "<<frameSigName<<" frame"<<endl;
cout<<"Injected lambda_theta Background............ "<<lambda_theta_bkg<<" , in the "<<frameBkgName<<" frame"<<endl;
cout<<"Injected lambda_phi Background ............. "<<lambda_phi_bkg<<" , in the "<<frameBkgName<<" frame"<<endl;
cout<<"Injected lambda_thetaphi Background ........ "<<lambda_thetaphi_bkg<<" , in the "<<frameBkgName<<" frame"<<endl;
cout<<"Number of Generation ....................... "<<nGen<<endl;
cout<<"Directory Structure of Output .............. "<<dirstruct<<endl;
double mass_min = mass_signal_peak - n_sigmas_signal*mass_signal_sigma;
double mass_max = mass_signal_peak + n_sigmas_signal*mass_signal_sigma;
char outfilename [500];
sprintf(outfilename,"%s/genData.root",dirstruct);
gROOT->Reset();
delete gRandom;
gRandom = new TRandom3(0);
TF1* pT_distr = new TF1("pT_distr",func_pT_gen,pTdilepton_min,pTdilepton_max,0);
TF1* rap_distr = new TF1("rap_distr",func_rap_gen,rapdilepton_min,rapdilepton_max,0);
TFile* hfileout = new TFile(outfilename, "RECREATE", "genData");
TTree* genData = new TTree("genData","genData");
// Structure of output ntuple
TLorentzVector* lepP = new TLorentzVector(0.,0.,0.,0.);
genData->Branch("lepP","TLorentzVector",&lepP);
TLorentzVector* lepN = new TLorentzVector(0.,0.,0.,0.);
genData->Branch("lepN","TLorentzVector",&lepN);
double costh_CS; genData->Branch("costh_CS", &costh_CS, "costh_CS/D");
double phi_CS; genData->Branch("phi_CS", &phi_CS, "phi_CS/D" );
double phith_CS; genData->Branch("phith_CS", &phith_CS, "phith_CS/D");
double costh_HX; genData->Branch("costh_HX", &costh_HX, "costh_HX/D");
double phi_HX; genData->Branch("phi_HX", &phi_HX, "phi_HX/D" );
double phith_HX; genData->Branch("phith_HX", &phith_HX, "phith_HX/D");
double costh_PX; genData->Branch("costh_PX", &costh_PX, "costh_PX/D");
double phi_PX; genData->Branch("phi_PX", &phi_PX, "phi_PX/D" );
double phith_PX; genData->Branch("phith_PX", &phith_PX, "phith_PX/D");
double cosalpha; genData->Branch("cosalpha", &cosalpha, "cosalpha/D");
double pT; genData->Branch("pT", &pT, "pT/D" );
double rap; genData->Branch("rap", &rap, "rap/D" );
double mass; genData->Branch("mass", &mass, "mass/D");
double deltaHXCS; genData->Branch("deltaHXCS", &deltaHXCS, "deltaHXCS/D");
int isBG; genData->Branch("isBG", &isBG, "isBG/I");
// extremes and binning of lambda_gen extraction histos
const double l_min = -1;
const double l_max = 1;
const double l_step_1D = 0.02;
TH1D* h_costh2_CS = new TH1D( "h_costh2_CS", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_cos2ph_CS = new TH1D( "h_cos2ph_CS", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_sin2thcosph_CS = new TH1D( "h_sin2thcosph_CS", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_costh2_HX = new TH1D( "h_costh2_HX", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_cos2ph_HX = new TH1D( "h_cos2ph_HX", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_sin2thcosph_HX = new TH1D( "h_sin2thcosph_HX", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_costh2_PX = new TH1D( "h_costh2_PX", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_cos2ph_PX = new TH1D( "h_cos2ph_PX", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
TH1D* h_sin2thcosph_PX = new TH1D( "h_sin2thcosph_PX", "", int((l_max-l_min)/l_step_1D), l_min, l_max );
double costh2;
double cos2ph;
double sin2thcosph;
double Phi;
const int n_step = n_events/5;
int n_step_=1;
cout << endl;
cout << "Generating " << n_events << " dilepton events"<< endl;
cout << "------------------------------------------------------------" << endl;
cout << "Progress: "<<endl;
/////////////////// CYCLE OF EVENTS ////////////////////////
for(int i_event = 1; i_event <= n_events; i_event++){
if (i_event%n_step == 0) {cout << n_step_*20 <<" % "<<endl; n_step_++;}
// generation of dilepton in the pp event in the pp CM
// mass
isBG = 0;
if ( gRandom->Uniform() < f_BG ) { mass = gRandom->Uniform(mass_min, mass_max); isBG = 1; }
else { do { mass = gRandom->Gaus(mass_signal_peak, mass_signal_sigma); }
while ( mass < mass_min || mass > mass_max ); }
// pT:
pT = pT_distr->GetRandom();
// pL:
double rap_sign = gRandom->Uniform(-1., 1.); rap_sign /= TMath::Abs(rap_sign);
rap = rap_distr->GetRandom() * rap_sign;
double mT = sqrt( mass*mass + pT*pT );
double pL1 = 0.5 *mT * exp(rap);
double pL2 = - 0.5 *mT * exp(-rap);
double pL = pL1 + pL2;
// Phi:
double Phi = 2. * gPI * gRandom->Uniform(1.);
// 4-vector:
TLorentzVector dilepton;
dilepton.SetXYZM( pT * cos(Phi) , pT * sin(Phi), pL, mass );
// generation of polarization (generic reference frame)
double lambda_theta = lambda_theta_sig;
double lambda_phi = lambda_phi_sig;
double lambda_thetaphi = lambda_thetaphi_sig;
bool HX_is_natural = HX_is_natural_sig;
bool PX_is_natural = PX_is_natural_sig;
if ( isBG ) {
lambda_theta = lambda_theta_bkg;
lambda_phi = lambda_phi_bkg;
lambda_thetaphi = lambda_thetaphi_bkg;
HX_is_natural = HX_is_natural_bkg;
PX_is_natural = PX_is_natural_bkg;
}
double costhphidistr_max = 1. + TMath::Abs(lambda_phi) + TMath::Abs(lambda_thetaphi);
double costhphidistr_rnd;
double costhphidistr;
double costh_gen;
double sinth_gen;
double phi_gen;
if ( lambda_theta > 0. ) costhphidistr_max += lambda_theta;
do { costh_gen = -1. + 2. * gRandom->Uniform(1.);
phi_gen = 2. * gPI * gRandom->Uniform(1.);
sinth_gen = sqrt( 1. - costh_gen*costh_gen );
costhphidistr_rnd = costhphidistr_max * gRandom->Uniform(1.);
costhphidistr = 1. + lambda_theta * costh_gen*costh_gen
+ lambda_phi * sinth_gen*sinth_gen * cos(2.*phi_gen)
+ lambda_thetaphi * 2.* sinth_gen*costh_gen * cos(phi_gen);
} while ( costhphidistr_rnd > costhphidistr );
// lepton momentum in the dilepton rest frame:
double p_lepton_DILEP = sqrt( 0.25*mass*mass - Mlepton*Mlepton );
TLorentzVector lepton_DILEP;
lepton_DILEP.SetXYZM( p_lepton_DILEP * sinth_gen * cos(phi_gen),
p_lepton_DILEP * sinth_gen * sin(phi_gen),
p_lepton_DILEP * costh_gen,
Mlepton );
// reference directions to calculate angles:
TVector3 lab_to_dilep = -dilepton.BoostVector();
TLorentzVector beam1_DILEP = beam1_LAB;
beam1_DILEP.Boost(lab_to_dilep); // beam1 in the dilepton rest frame
TLorentzVector beam2_DILEP = beam2_LAB;
beam2_DILEP.Boost(lab_to_dilep); // beam2 in the dilepton rest frame
TVector3 beam1_direction = beam1_DILEP.Vect().Unit();
TVector3 beam2_direction = beam2_DILEP.Vect().Unit();
TVector3 dilep_direction = dilepton.Vect().Unit();
TVector3 beam1_beam2_bisect = ( beam1_direction - beam2_direction ).Unit();
deltaHXCS = dilep_direction.Angle(beam1_beam2_bisect) * 180./gPI;
// all polarization frames have the same Y axis = the normal to the plane formed by
// the directions of the colliding hadrons
TVector3 Yaxis = ( beam1_direction.Cross( beam2_direction ) ).Unit();
// flip of y axis with rapidity
if ( rap < 0 ) Yaxis = - Yaxis;
TVector3 perpendicular_to_beam = ( beam1_beam2_bisect.Cross( Yaxis ) ).Unit();
// step 1: transform (rotation) lepton momentum components from generation frame
// to the frame with x,y,z axes as in the laboratory
TVector3 oldZaxis = beam1_beam2_bisect;
if ( HX_is_natural ) oldZaxis = dilep_direction;
if ( PX_is_natural ) oldZaxis = perpendicular_to_beam;
TVector3 oldYaxis = Yaxis;
TVector3 oldXaxis = oldYaxis.Cross(oldZaxis);
TRotation rotation;
rotation.RotateAxes(oldXaxis, oldYaxis, oldZaxis);
// transforms coordinates from the "old" frame to the "xyz" frame
TLorentzVector lepton_DILEP_xyz = lepton_DILEP;
lepton_DILEP_xyz.Transform(rotation);
// lepton_DILEP_xyz is the lepton in the dilepton rest frame
// wrt to the lab axes
// lepton 4-vectors in the LAB frame:
TVector3 dilep_to_lab = dilepton.BoostVector();
*lepP = lepton_DILEP_xyz;
lepP->Boost(dilep_to_lab);
lepN->SetPxPyPzE(-lepton_DILEP_xyz.Px(),-lepton_DILEP_xyz.Py(),-lepton_DILEP_xyz.Pz(),lepton_DILEP_xyz.E());
lepN->Boost(dilep_to_lab);
/////////////////////////////////////////////////////////////////////
// CS frame
TVector3 newZaxis = beam1_beam2_bisect;
TVector3 newYaxis = Yaxis;
TVector3 newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert(); // transforms coordinates from the "xyz" frame to the new frame
TVector3 lepton_DILEP_rotated = lepton_DILEP_xyz.Vect();
lepton_DILEP_rotated.Transform(rotation);
costh_CS = lepton_DILEP_rotated.CosTheta();
phi_CS = lepton_DILEP_rotated.Phi() * 180. / gPI;
if ( costh_CS < 0. ) phith_CS = phi_CS - 135.;
if ( costh_CS > 0. ) phith_CS = phi_CS - 45.;
if ( phith_CS < -180. ) phith_CS = 360. + phith_CS;
/////////////////////////////////////////////////////////////////////
// HELICITY frame
newZaxis = dilep_direction;
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
lepton_DILEP_rotated = lepton_DILEP_xyz.Vect();
lepton_DILEP_rotated.Transform(rotation);
costh_HX = lepton_DILEP_rotated.CosTheta();
phi_HX = lepton_DILEP_rotated.Phi() * 180. / gPI;
if ( costh_HX < 0. ) phith_HX = phi_HX - 135.;
if ( costh_HX > 0. ) phith_HX = phi_HX - 45.;
if ( phith_HX < -180. ) phith_HX = 360. + phith_HX;
/////////////////////////////////////////////////////////////////////
// PERPENDICULAR HELICITY frame
newZaxis = perpendicular_to_beam;
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
lepton_DILEP_rotated = lepton_DILEP_xyz.Vect();
lepton_DILEP_rotated.Transform(rotation);
costh_PX = lepton_DILEP_rotated.CosTheta();
phi_PX = lepton_DILEP_rotated.Phi() * 180. / gPI;
if ( costh_PX < 0. ) phith_PX = phi_PX - 135.;
if ( costh_PX > 0. ) phith_PX = phi_PX - 45.;
if ( phith_PX < -180. ) phith_PX = 360. + phith_PX;
/////////////////////////////////////////////////////////////////////
// invariant polarization angle
cosalpha = sqrt( 1. - pow(costh_PX, 2.) ) * sin( lepton_DILEP_rotated.Phi() );
////// Filling Histograms of costh2, cos2ph and sin2thcosph for the extraction of the actual generated polarization
if ( !isBG ){
costh2=pow(costh_CS,2.);
Phi = phi_CS/180. * gPI ;
cos2ph = cos(2.*Phi);
sin2thcosph= sin(2.*acos(costh_CS))*cos(Phi);
h_costh2_CS->Fill( costh2 );
h_cos2ph_CS->Fill( cos2ph );
h_sin2thcosph_CS->Fill( sin2thcosph );
costh2=pow(costh_HX,2.);
Phi = phi_HX/180. * gPI ;
cos2ph = cos(2.*Phi);
sin2thcosph= sin(2.*acos(costh_HX))*cos(Phi);
h_costh2_HX->Fill( costh2 );
h_cos2ph_HX->Fill( cos2ph );
h_sin2thcosph_HX->Fill( sin2thcosph );
costh2=pow(costh_PX,2.);
Phi = phi_PX/180. * gPI ;
cos2ph = cos(2.*Phi);
sin2thcosph= sin(2.*acos(costh_PX))*cos(Phi);
h_costh2_PX->Fill( costh2 );
h_cos2ph_PX->Fill( cos2ph );
h_sin2thcosph_PX->Fill( sin2thcosph );
}
// filling of the ntuple:
genData->Fill();
} // end of external loop (generated events)
cout << endl;
double lamth_CS;
double lamph_CS;
double lamtp_CS;
costh2=h_costh2_CS->GetMean();
lamth_CS = (1. - 3. * costh2 ) / ( costh2 - 3./5. );
cos2ph=h_cos2ph_CS->GetMean();
lamph_CS = cos2ph * (3. + lamth_CS);
sin2thcosph=h_sin2thcosph_CS->GetMean();
lamtp_CS = sin2thcosph * 5./4. * (3. + lamth_CS);
double lamth_HX;
double lamph_HX;
double lamtp_HX;
costh2=h_costh2_HX->GetMean();
lamth_HX = (1. - 3. * costh2 ) / ( costh2 - 3./5. );
cos2ph=h_cos2ph_HX->GetMean();
lamph_HX = cos2ph * (3. + lamth_HX);
sin2thcosph=h_sin2thcosph_HX->GetMean();
lamtp_HX = sin2thcosph * 5./4. * (3. + lamth_HX);
double lamth_PX;
double lamph_PX;
double lamtp_PX;
costh2=h_costh2_PX->GetMean();
lamth_PX = (1. - 3. * costh2 ) / ( costh2 - 3./5. );
cos2ph=h_cos2ph_PX->GetMean();
lamph_PX = cos2ph * (3. + lamth_PX);
sin2thcosph=h_sin2thcosph_PX->GetMean();
lamtp_PX = sin2thcosph * 5./4. * (3. + lamth_PX);
char resfilename[200];
sprintf(resfilename,"%s/GenResults.root",dirstruct);
TFile* GenResultFile = new TFile(resfilename, "RECREATE", "GenResultFile");
TTree* GenResults = new TTree("GenResults","GenResults");
GenResults->Branch("lthCS", &lamth_CS, "lthCS/D");
GenResults->Branch("lphCS", &lamph_CS, "lphCS/D");
GenResults->Branch("ltpCS", &lamtp_CS, "ltpCS/D");
GenResults->Branch("lthHX", &lamth_HX, "lthHX/D");
GenResults->Branch("lphHX", &lamph_HX, "lphHX/D");
GenResults->Branch("ltpHX", &lamtp_HX, "ltpHX/D");
GenResults->Branch("lthPX", &lamth_PX, "lthPX/D");
GenResults->Branch("lphPX", &lamph_PX, "lphPX/D");
GenResults->Branch("ltpPX", &lamtp_PX, "ltpPX/D");
GenResults->Fill();
GenResultFile->Write();
GenResultFile->Close();
hfileout->Write();
hfileout->Close();
} // end of main
//=========================================
// calculation of decay angular parameters
//=========================================
void calcPol(TLorentzVector muplus_LAB,
TLorentzVector muminus_LAB){
TLorentzVector qqbar_LAB = muplus_LAB + muminus_LAB;
Double_t rapidity = qqbar_LAB.Rapidity();
// boost beams and positive muon into the q-qbar rest frame:
TVector3 LAB_to_QQBAR = -qqbar_LAB.BoostVector();
TLorentzVector beam1_QQBAR = eff::beam1_LAB;
beam1_QQBAR.Boost( LAB_to_QQBAR );
TLorentzVector beam2_QQBAR = eff::beam2_LAB;
beam2_QQBAR.Boost( LAB_to_QQBAR );
TLorentzVector muplus_QQBAR = muplus_LAB;
muplus_QQBAR.Boost( LAB_to_QQBAR );
// reference directions in the Jpsi rest frame:
TVector3 beam1_direction = beam1_QQBAR.Vect().Unit();
TVector3 beam2_direction = beam2_QQBAR.Vect().Unit();
TVector3 qqbar_direction = qqbar_LAB.Vect().Unit();
TVector3 beam1_beam2_bisect = ( beam1_direction - beam2_direction ).Unit();
// all polarization frames have the same Y axis = the normal to the plane formed by
// the directions of the colliding hadrons
TVector3 Yaxis = ( beam1_direction.Cross( beam2_direction ) ).Unit();
if ( rapidity < 0. ) Yaxis = -Yaxis; //H: added (5 Dec 2010)
/////////////////////////////////////////////////////////////////////
// CS frame
TVector3 newZaxis = beam1_beam2_bisect;
TVector3 newYaxis = Yaxis;
TVector3 newXaxis = newYaxis.Cross( newZaxis );
TRotation rotation;
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert(); // transforms coordinates from the "xyz" system
// to the "new" (rotated) system having the polarization axis
// as z axis
TVector3 muplus_QQBAR_rotated(muplus_QQBAR.Vect());
muplus_QQBAR_rotated.Transform( rotation );
thisCosTh[eff::CS] = muplus_QQBAR_rotated.CosTheta();
thisPhi_rad[eff::CS] = muplus_QQBAR_rotated.Phi();
thisPhi[eff::CS] = muplus_QQBAR_rotated.Phi() * 180. / TMath::Pi();
//if ( thisPhi[eff::CS] < 0. ) thisPhi[eff::CS]= 360. + thisPhi[eff::CS]; // phi defined in degrees from 0 to 360
// thisPhi[eff::CS] += 180.; //H: don't add anything...
/////////////////////////////////////////////////////////////////////
// HELICITY frame
newZaxis = qqbar_direction;
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
muplus_QQBAR_rotated = muplus_QQBAR.Vect();
muplus_QQBAR_rotated.Transform( rotation );
thisCosTh[eff::HX] = muplus_QQBAR_rotated.CosTheta();
thisPhi_rad[eff::HX] = muplus_QQBAR_rotated.Phi();
thisPhi[eff::HX] = muplus_QQBAR_rotated.Phi() * 180. / TMath::Pi();
//if ( thisPhi[eff::HX] < 0. ) thisPhi[eff::HX] = 360. + thisPhi[eff::HX]; // phi defined in degrees from 0 to 360
//thisPhi[eff::HX] += 180.;//H: don't add anything...
/////////////////////////////////////////////////////////////////////
// GJ1 frame
newZaxis = beam1_direction;
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
muplus_QQBAR_rotated = muplus_QQBAR.Vect();
muplus_QQBAR_rotated.Transform( rotation );
thisCosTh[eff::GJ1] = muplus_QQBAR_rotated.CosTheta();
thisPhi_rad[eff::GJ1] = muplus_QQBAR_rotated.Phi();
thisPhi[eff::GJ1] = muplus_QQBAR_rotated.Phi() * 180. / TMath::Pi();
//if ( thisPhi[eff::GJ1] < 0. ) thisPhi[eff::GJ1] = 360. + thisPhi[eff::GJ1]; // phi defined in degrees from 0 to 360
//thisPhi[eff::GJ1] += 180.;//H: don't add anything...
/////////////////////////////////////////////////////////////////////
// GJ2 frame
newZaxis = beam2_direction;
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
muplus_QQBAR_rotated = muplus_QQBAR.Vect();
muplus_QQBAR_rotated.Transform( rotation );
thisCosTh[eff::GJ2] = muplus_QQBAR_rotated.CosTheta();
thisPhi_rad[eff::GJ2] = muplus_QQBAR_rotated.Phi();
thisPhi[eff::GJ2] = muplus_QQBAR_rotated.Phi() * 180. / TMath::Pi();
//if ( thisPhi[eff::GJ2] < 0. ) thisPhi[eff::GJ2] = 360. + thisPhi[eff::GJ2]; // phi defined in degrees from 0 to 360
//thisPhi[eff::GJ2] += 180.;//H: don't add anything...
/////////////////////////////////////////////////////////////////////
// sGJ frame (symmetrized GJ)
newZaxis = beam1_direction; if( rapidity < 0. ) newZaxis = beam2_direction;
newYaxis = Yaxis;
// try to swith the following line on or off
//if( rapidity < 0. ) newYaxis = -Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
muplus_QQBAR_rotated = muplus_QQBAR.Vect();
muplus_QQBAR_rotated.Transform( rotation );
thisCosTh[eff::sGJ] = muplus_QQBAR_rotated.CosTheta();
thisPhi_rad[eff::sGJ] = muplus_QQBAR_rotated.Phi();
thisPhi[eff::sGJ] = muplus_QQBAR_rotated.Phi() * 180. / TMath::Pi();
//if ( thisPhi[eff::sGJ] < 0. ) thisPhi[eff::sGJ] = 360. + thisPhi[eff::sGJ]; // phi defined in degrees from 0 to 360
//thisPhi[eff::sGJ] += 180.;//H: don't add anything...
/////////////////////////////////////////////////////////////////////
// PHX frame ("perpendicular helicity frame" - z axis perpendicular
// to the CS axis)
newZaxis = newZaxis = ( beam1_beam2_bisect.Cross( Yaxis ) ).Unit();
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
muplus_QQBAR_rotated = muplus_QQBAR.Vect();
muplus_QQBAR_rotated.Transform( rotation );
thisCosTh[eff::PHX] = muplus_QQBAR_rotated.CosTheta();
thisPhi_rad[eff::PHX] = muplus_QQBAR_rotated.Phi();
thisPhi[eff::PHX] = muplus_QQBAR_rotated.Phi() * 180. / TMath::Pi();
//if ( thisPhi[eff::PHX] < 0. ) thisPhi[eff::PHX] = 360. + thisPhi[eff::PHX]; // phi defined in degrees from 0 to 360
//thisPhi[eff::PHX] += 180.;//H: don't add anything...
}
void pgsAnalysis::Loop()
{
double tHrec, tZ1m, tZ2m, tcosthetaStar, tPhi, tPhi1, tcostheta1, tcostheta2,tHrec_constr,tZ1m_constr, tZ2m_constr;
string ttype;
hists->Branch("Hrec", &tHrec);
hists->Branch("Z1m", &tZ1m);
hists->Branch("Z2m", &tZ2m);
hists->Branch("costhetaStar", &tcosthetaStar);
hists->Branch("Phi", &tPhi);
hists->Branch("Phi1", &tPhi1);
hists->Branch("costheta1", &tcostheta1);
hists->Branch("costheta2", &tcostheta2);
hists->Branch("type", &ttype);
//event type!!
int eeee, xxxx, eexx, xxee;
double Zmass = 91.19;
double vZmass;
if (pairing == 0){
vZmass = 91.19;
}
else{
vZmass = 45.;
}
TVectorT<double> elSum(4);
TVectorT<double> muSum(4);
//electrons array
vector<int> el; int elC = 0;
//muons array
vector<int> mu; int muC = 0;
//antielectrons array
vector<int> antiel; int antielC = 0;
//antimuons array
vector<int> antimu; int antimuC = 0;
vector<TVector3> leptons;
TVector3 lep1,lep2,lep3,lep4;
TVector3 Za, Zb, Zc, Zd, H;
int lCounter = 0;
int totaLlCounter = 0;
int goodEventCounter = 0;
int histCounter = 0;
if (fChain == 0) return;
int nentries = n;
// cout << " nentries are "<<nentries<<endl;
Long64_t nbytes = 0, nb = 0;
for (Long64_t jentry=0; jentry<nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// if (Cut(ientry) < 0) continue;
el.clear();
antiel.clear();
mu.clear();
antimu.clear();
lCounter = 0;
eeee = 0;
xxxx = 0;
eexx = 0;
xxee = 0;
//particles identified by type, ntrk
for (int inst = 0; inst < npart; inst++){ // inst from "instance" on the scan tree
// cout<< " instance "<< inst <<endl;
// cout<< pT[inst]<< endl;
//fill el mu vectors
if ( typ[inst] == 1 && ntrk[inst] == -1){
el.push_back(inst);
elC++;
lCounter++;
totaLlCounter++;
}
if ( typ[inst] == 1 && ntrk[inst] == 1){
antiel.push_back(inst);
antielC++;
lCounter++;
totaLlCounter++;
}
if ( typ[inst] == 2 && ntrk[inst] == -1){
mu.push_back(inst);
muC++;
lCounter++;
totaLlCounter++;
}
if ( typ[inst] == 2 && ntrk[inst] == 1){
antimu.push_back(inst);
antimuC++;
lCounter++;
totaLlCounter++;
}
if ( (typ[inst] == 4 && jmas[inst] > 10. )|| (typ[inst] == 6 && pT[inst] > 10. )){
lCounter = 0; //dont count the event
}
}//end instance loop (particles in an event
// cout<< "leptons in the event are "<< lCounter<<endl;
// if (lCounter == 4) {
fillFlag = false;
// If else if loops reconstructing the particles according to the type 4e,4mu, 2e2mu
if (el.size() == 1 && mu.size() == 1 && antiel.size() == 1 && antimu.size() == 1){ //2e2m
goodEventCounter++;
lep1.SetPtEtaPhi( pT[el[0]], eta[el[0]] , phi[el[0]]); //set up of lepton four-vectors
lep2.SetPtEtaPhi( pT[antiel[0]], eta[antiel[0]] , phi[antiel[0]]);
lep3.SetPtEtaPhi( pT[mu[0]], eta[mu[0]] , phi[mu[0]]);
lep4.SetPtEtaPhi( pT[antimu[0]], eta[antimu[0]] , phi[antimu[0]]);
Za = lep1 + lep2;
Zb = lep3 + lep4;
mZ1 = sqrt(pow(lep1.Mag()+lep2.Mag(),2)-Za.Mag2()); // reconstruct z masses
mZ2 = sqrt(pow(lep3.Mag()+lep4.Mag(),2)-Zb.Mag2());
//select leading Z
if(mZ1 > mZ2) { Z1.SetVectM( Za, mZ1); Z2.SetVectM(Zb,mZ2); lep_min1.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus1.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag()); lep_min2.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus2.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag());eexx++;} //to set the highest mass the z
else { Z2.SetVectM( Za, mZ1); Z1.SetVectM(Zb,mZ2); lep_min2.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus2.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag()); lep_min1.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus1.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag());xxee++;}
fillFlag = true;
}
else if (el.size() == 2 && mu.size() == 0 && antiel.size() == 2 && antimu.size() == 0){ //4e
goodEventCounter++;
lep1.SetPtEtaPhi( pT[el[0]], eta[el[0]] , phi[el[0]]);
lep2.SetPtEtaPhi( pT[antiel[0]], eta[antiel[0]] , phi[antiel[0]]);
lep3.SetPtEtaPhi( pT[el[1]], eta[el[1]] , phi[el[1]]);
lep4.SetPtEtaPhi( pT[antiel[1]], eta[antiel[1]] , phi[antiel[1]]);
Za = lep1 + lep2;
Zb = lep3 + lep4;
Zc = lep1 + lep4;
Zd = lep3 + lep2;
double mZa = sqrt(pow(lep1.Mag()+lep2.Mag(),2)-Za.Mag2());
double mZb = sqrt(pow(lep3.Mag()+lep4.Mag(),2)-Zb.Mag2());
double mZc = sqrt(pow(lep1.Mag()+lep4.Mag(),2)-Zc.Mag2());
double mZd = sqrt(pow(lep2.Mag()+lep3.Mag(),2)-Zd.Mag2());
double s1a;
double s1b;
double s2a;
double s2b;
if ( pairing == 0){
s1a = pow(mZa-vZmass,2) + pow(mZb-Zmass,2);
s1b = pow(mZa-Zmass,2) + pow(mZb-vZmass,2);
s2a = pow(mZc-vZmass,2) + pow(mZd-Zmass,2);
s2b = pow(mZc-Zmass,2) + pow(mZd-vZmass,2);
}
else{
s1a = fabs(mZb-Zmass);
s1b = fabs(mZa-Zmass);
s2a = fabs(mZd-Zmass);
s2b = fabs(mZc-Zmass);
}
elSum[0] = s1a;
elSum[1] = s1b;
elSum[2] = s2a;
elSum[3] = s2b;
int min = TMath::LocMin(4, &elSum[0]);
if( (min == 0 || min == 1) ){
if(mZa > mZb) { Z1.SetVectM( Za, mZa); Z2.SetVectM(Zb,mZb); lep_min1.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus1.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag()); lep_min2.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus2.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag());} //to set the highest mass the z
else { Z2.SetVectM( Za, mZa); Z1.SetVectM(Zb,mZb); lep_min2.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus2.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag()); lep_min1.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus1.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag());}
}
else if( (min == 2 || min == 3) ){
if(mZc > mZd) { Z1.SetVectM( Zc, mZc); Z2.SetVectM(Zd,mZd); lep_min1.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus1.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag()); lep_min2.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus2.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag());} //to set the highest mass the z
else { Z2.SetVectM( Zc, mZc); Z1.SetVectM(Zd,mZd); lep_min2.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus2.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag()); lep_min1.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus1.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag());}
}
eeee++;
fillFlag = true;
}
else if(el.size() == 0 && mu.size() == 2 && antiel.size() == 0 && antimu.size() == 2 ) { //4m
goodEventCounter++;
lep1.SetPtEtaPhi( pT[mu[0]], eta[mu[0]] , phi[mu[0]]);
lep2.SetPtEtaPhi( pT[antimu[0]], eta[antimu[0]] , phi[antimu[0]]);
lep3.SetPtEtaPhi( pT[mu[1]], eta[mu[1]] , phi[mu[1]]);
lep4.SetPtEtaPhi( pT[antimu[1]], eta[antimu[1]] , phi[antimu[1]]);
Za = lep1 + lep2;
Zb = lep3 + lep4;
Zc = lep1 + lep4;
Zd = lep3 + lep2;
double mZa = sqrt(pow(lep1.Mag()+lep2.Mag(),2)-Za.Mag2());
double mZb = sqrt(pow(lep3.Mag()+lep4.Mag(),2)-Zb.Mag2());
double mZc = sqrt(pow(lep1.Mag()+lep4.Mag(),2)-Zc.Mag2());
double mZd = sqrt(pow(lep2.Mag()+lep3.Mag(),2)-Zd.Mag2());
double s1a;
double s1b;
double s2a;
double s2b;
if ( pairing == 0){
s1a = pow(mZa-vZmass,2) + pow(mZb-Zmass,2);
s1b = pow(mZa-Zmass,2) + pow(mZb-vZmass,2);
s2a = pow(mZc-vZmass,2) + pow(mZd-Zmass,2);
s2b = pow(mZc-Zmass,2) + pow(mZd-vZmass,2);
}
else{
s1a = fabs(mZb-Zmass);
s1b = fabs(mZa-Zmass);
s2a = fabs(mZd-Zmass);
s2b = fabs(mZc-Zmass);
}
muSum[0] = s1a;
muSum[1] = s1b;
muSum[2] = s2a;
muSum[3] = s2b;
int min = TMath::LocMin(4, &muSum[0]);
if( (min == 0 || min == 1) ){
if(mZa > mZb) { Z1.SetVectM( Za, mZa); Z2.SetVectM(Zb,mZb); lep_min1.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus1.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag()); lep_min2.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus2.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag());} //to set the highest mass the z
else { Z2.SetVectM( Za, mZa); Z1.SetVectM(Zb,mZb); lep_min2.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus2.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag()); lep_min1.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus1.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag());}
}
else if( (min == 2 || min == 3) ){
if(mZc > mZd) { Z1.SetVectM( Zc, mZc); Z2.SetVectM(Zd,mZd); lep_min1.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus1.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag()); lep_min2.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus2.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag());} //to set the highest mass the z
else { Z2.SetVectM( Zc, mZc); Z1.SetVectM(Zd,mZd); lep_min2.SetPtEtaPhiE(lep1.Pt(),lep1.Eta(), lep1.Phi(),lep1.Mag()); lep_plus2.SetPtEtaPhiE(lep4.Pt(),lep4.Eta(), lep4.Phi(),lep4.Mag()); lep_min1.SetPtEtaPhiE(lep3.Pt(),lep3.Eta(), lep3.Phi(),lep3.Mag()); lep_plus1.SetPtEtaPhiE(lep2.Pt(),lep2.Eta(), lep2.Phi(),lep2.Mag());}
}
xxxx++;
fillFlag = true;
}
if ( fillFlag == true && goodEventCounter < 25001) { //if it fullfills the specs then fill and find angles
rec_H = Z1 + Z2;
double Hmass = rec_H.M();
tHrec = Hmass;
// cout<<tHrec<<endl;
double Z1mass = Z1.M();
tZ1m = Z1mass;
double Z2mass = Z2.M();
tZ2m = Z2mass;
double ptlepp1 = lep_plus1.Pt();
double ptlepm1 = lep_min1.Pt();
double ptlepp2 = lep_plus2.Pt();
double ptlepm2 = lep_min2.Pt();
double dR1 = sqrt(pow(fabs(lep_min1.Eta() - lep_plus1.Eta()),2)+pow(fabs(lep_min1.DeltaPhi(lep_plus1)),2));
double dR2 = sqrt(pow(fabs(lep_min2.Eta() - lep_plus2.Eta()),2)+pow(fabs(lep_min2.DeltaPhi(lep_plus2)),2));
// if ( /*Hmass<120 || Hmass>130 || */Z1mass < 49 || Z1mass>107 || Z2mass < 12 || Z2mass> 115 ){continue;} //constrains
//filling the simple histogram values
h_Z1_m -> Fill(Z1.M());
h_Z1_E -> Fill(Z1.E());
h_Z1_Pt -> Fill(Z1.Pt());
h_Z1_eta -> Fill(Z1.Eta());
h_Z1_phi -> Fill(Z1.Phi());
h_Z2_m -> Fill(Z2.M());
h_Z2_E -> Fill(Z2.E());
h_Z2_Pt -> Fill(Z2.Pt());
h_Z2_eta -> Fill(Z2.Eta());
h_Z2_phi -> Fill(Z2.Phi());
h_rec_H_m -> Fill(Hmass);
h_rec_H_E -> Fill(rec_H.E());
h_rec_H_Pt -> Fill(rec_H.Pt());
h_rec_H_eta -> Fill(rec_H.Eta());
h_rec_H_phi -> Fill(rec_H.Phi());
h_lep_plus1_E -> Fill(lep_plus1.E());
h_lep_plus1_Pt -> Fill(ptlepp1);
h_lep_plus1_eta -> Fill(lep_plus1.Eta());
h_lep_plus1_phi -> Fill(lep_plus1.Phi());
h_lep_min1_E -> Fill(lep_min1.E());
h_lep_min1_Pt -> Fill(ptlepm1);
h_lep_min1_eta -> Fill(lep_min1.Eta());
h_lep_min1_phi -> Fill(lep_min1.Phi());
h_lep_plus2_E -> Fill(lep_plus2.E());
h_lep_plus2_Pt -> Fill(ptlepp2);
h_lep_plus2_eta -> Fill(lep_plus2.Eta());
h_lep_plus2_phi -> Fill(lep_plus2.Phi());
h_lep_min2_E -> Fill(lep_min2.E());
h_lep_min2_Pt -> Fill(ptlepm2);
h_lep_min2_eta -> Fill(lep_min2.Eta());
h_lep_min2_phi -> Fill(lep_min2.Phi());
//reconstructing the two lepton pairs Lorentz vectors
lpair1 = lep_plus1 + lep_min1;
lpair2 = lep_plus2 + lep_min2;
//constructing 3-vectors in the lab frame
lep_plus1_lab = lep_plus1.Vect();
lep_plus2_lab = lep_plus2.Vect(); //.Vect() gives 3 vector from 4vector
lep_min1_lab = lep_min1.Vect();
lep_min2_lab = lep_min2.Vect();
lpair1_lab = lep_plus1_lab.Cross(lep_min1_lab);
lpair2_lab = lep_plus2_lab.Cross(lep_min2_lab);
// cout << " pt of lepton pair1 on rest frame is: "<< lpair1.Perp()<<endl;
//Filling up Histograms with angles defined in the lab frame
h_angle_lab_pair1 -> Fill(lep_plus1_lab.Angle(lep_min1_lab));
h_angle_lab_pair2 -> Fill(lep_plus2_lab.Angle(lep_min2_lab));
//Filling up histograms with variables from articles
h_angle_lab_deleta1 -> Fill(fabs(lep_min1.Eta() - lep_plus1.Eta()));
h_angle_lab_delphi1 -> Fill(fabs(lep_min1.DeltaPhi(lep_plus1)));
h_angle_lab_deleta2 -> Fill(fabs(lep_min2.Eta() - lep_plus2.Eta()));
h_angle_lab_delphi2 -> Fill(fabs(lep_min2.DeltaPhi(lep_plus2)));
//Looking at the Higgs rest frame
TVector3 boost_rH = -rec_H.BoostVector(); //NOTE the minus sign! WHY - sign???
TVector3 boost_rZ1 = -Z1.BoostVector();
TVector3 boost_rZ2 = -Z2.BoostVector();
Higgs_rest = rec_H;
Z1_rH = Z1;
Z2_rH = Z2;
lep_p1_rH = lep_plus1; //
lep_m1_rH = lep_min1;
lep_p2_rH = lep_plus2;
lep_m2_rH = lep_min2;
lep_p1_rZ1 = lep_plus1;
lep_m2_rZ2 = lep_min2;
lep_p2_rZ2 = lep_plus2;
lep_m1_rZ1 = lep_min1;
//Boosting vectors to the Higgs rest frame
Higgs_rest.Boost(boost_rH);
Z1_rH.Boost(boost_rH);
Z2_rH.Boost(boost_rH);
lep_p1_rH.Boost(boost_rH);
lep_m1_rH.Boost(boost_rH);
lep_p2_rH.Boost(boost_rH);
lep_m2_rH.Boost(boost_rH);
//Boosting leptons to Z rest frames
lep_p1_rZ1.Boost(boost_rZ1);
lep_m1_rZ1.Boost(boost_rZ1);
lep_p2_rZ2.Boost(boost_rZ2);
lep_m2_rZ2.Boost(boost_rZ2);
//Setting 3Vectors in Higgs rest frame
Z3_1_rH = Z1_rH.Vect();
Z3_2_rH = Z2_rH.Vect();
lep3_plus1_rH = lep_p1_rH.Vect();
lep3_min1_rH = lep_m1_rH.Vect();
lep3_plus2_rH = lep_p2_rH.Vect();
lep3_min2_rH = lep_m2_rH.Vect();
TVector3 Z3_1plane_rH = lep3_plus1_rH.Cross(lep3_min1_rH); //wrong?
TVector3 Z3_2plane_rH = lep3_plus2_rH.Cross(lep3_min2_rH);
//Setting 3Vectors in Z1/Z2 rest frame
lep3_plus1_rZ1 = lep_p1_rZ1.Vect();
lep3_plus2_rZ2 = lep_p2_rZ2.Vect();
lep3_min1_rZ1 = lep_m1_rZ1.Vect();
lep3_min2_rZ2 = lep_m2_rZ2.Vect();
//Filling up histogram for the phi angle distribution
//pairnoume ta monadiaia dianysmata twn kathetwn pediwn, prwta ypologizoume to metro tous, meta eswteriko ginomeno, meta tokso tou costheta tous
double metro1 = sqrt((pow(Z3_1plane_rH.X(),2))+(pow(Z3_1plane_rH.Y(),2))+(pow(Z3_1plane_rH.Z(),2)));
double metro2 = sqrt((pow(Z3_2plane_rH.X(),2))+(pow(Z3_2plane_rH.Y(),2))+(pow(Z3_2plane_rH.Z(),2)));
TVector3 Z3_1plane_rH_un = Z3_1plane_rH.Unit();
TVector3 Z3_2plane_rH_un = Z3_2plane_rH.Unit();
TVector3 drtPlane = Z3_1plane_rH_un.Cross(Z3_2plane_rH_un);
double phi = acos(-Z3_1plane_rH_un.Dot(Z3_2plane_rH_un))*(Z3_1_rH.Dot(skata))/fabs(Z3_1_rH.Dot(skata));
h_angle_rH_phi -> Fill( phi );
tPhi = phi;
//****Phi one angle , same procedure as before. Now the plane is the first Z boson vector with beam axis, so they form a plane, phi1 is angle between this plane and the Z1 plane (apo to decay twn 2 leptoniwn)
TVector3 niScatter_un = (beamAxis.Cross(Z3_1_rH)).Unit();
TVector3 drtPlane2 = Z3_1plane_rH_un.Cross(niScatter_un);
double phiOne = acos(Z3_1plane_rH_un.Dot(niScatter_un))*(Z3_1_rH.Dot(skata2))/fabs(Z3_1_rH.Dot(skata2));
h_angle_rH_phiOne -> Fill( phiOne );
tPhi1 = phiOne;
//Filling up histogram for theta* angle: Z1/Z2 with Higgs boost vector
h_angle_rH_thetaZ2 -> Fill(Z3_2_rH.CosTheta());
double cosThetaStar = Z3_1_rH.CosTheta();
h_angle_rH_thetaZ1 -> Fill(cosThetaStar);
tcosthetaStar = cosThetaStar;
// boosting the z to the other z frame
TLorentzVector Z_1_rZ2 = Z1;
Z_1_rZ2.Boost(boost_rZ2);
TVector3 Z3_1_rZ2 = Z_1_rZ2.Vect();
TLorentzVector Z_2_rZ1 = Z2;
Z_2_rZ1.Boost(boost_rZ1);
TVector3 Z3_2_rZ1 = Z_2_rZ1.Vect();
double cosTheta1 = cos(lep3_min1_rZ1.Angle(-Z3_2_rZ1));
double cosTheta2 = cos(lep3_min2_rZ2.Angle(-Z3_1_rZ2));
h_angle_rZ1_lp1Z1 -> Fill(cos(lep3_plus1_rZ1.Angle(-Z3_2_rZ1)));
h_angle_rZ1_lm1Z1 -> Fill(cosTheta1); // theta1
h_angle_rZ2_lp2Z2 -> Fill(cos(lep3_plus2_rZ2.Angle(-Z3_1_rZ2)));
h_angle_rZ2_lm2Z2 -> Fill(cosTheta2); // theta2
tcostheta1 = cosTheta1;
tcostheta2 = cosTheta2;
h_angle_rH_delphi1 -> Fill(fabs(lep_p1_rH.DeltaPhi(lep_m1_rH)));
h_angle_rH_delphi2 -> Fill(fabs(lep_p2_rH.DeltaPhi(lep_m2_rH)));
h_mZ1mZ2 -> Fill(Z1.M(),Z2.M());
h_mVsPtZ1 -> Fill(Z1.M(),Z1.Pt());
h_delphi1VsPtZ1_lab -> Fill(Z1.Pt(),fabs(lep_min1.DeltaPhi(lep_plus1)));
h_delphi2VsPtZ2_lab -> Fill(Z2.Pt(),fabs(lep_min2.DeltaPhi(lep_plus2)));
if (eexx ==1){ttype = "eexx";}
else if(xxee ==1){ttype = "xxee";}
else if(eeee ==1){ttype = "eeee";}
else if(xxxx ==1){ttype = "xxxx";}
hists->Fill();
histCounter++;
hists->Close();
} //end if fill
////////////// fill out the decay type
// filling the TTree
}//end entries loop (events)
//some regular reports
cout<<endl;
cout<<" good events are "<<goodEventCounter<<endl;
cout<<" we see % "<< (double) goodEventCounter/n <<endl;
cout<<endl;
cout<<" histogram fills are "<<histCounter<<endl;
// cout<<" we see % "<< (double) goodEventCounter/n <<endl;
}//end loop void
void figureOutpiover2(int ptBin, double ptCutLo, double ptCutHi, int massBin, double mCutLo, double mCutHi, int etaBin, double etaCutLo, double etaCutHi) {
//OPTIONS AND CUTS------------
bool useBlueBeam = false;
bool useYellowBeam = true;
double PI = 3.14159265359;
if (useBlueBeam && useYellowBeam) {
cout << "using both beams" << endl;
}
if (useBlueBeam && !useYellowBeam) {
cout << "using blue beam" << endl;
}
if (!useBlueBeam && useYellowBeam) {
cout << "using yellow beam" << endl;
}
//PION PAIR CUTS:
/*
double ptCutLo = 4;
double ptCutHi = 10;
double mCutLo = .4;
double mCutHi = 1;
double etaCutLo = -1.4;
double etaCutHi = 1.4;
//*/
//double phiCutLo = -.5;
//double phiCutHi = .5;
//----------------------------
//LOAD LIBS
cout << "\n";
gROOT->Macro("StRoot/LoadLibs.C");
gSystem->Load("pionPair");
cout << " loading of pionPair library done" << endl;
//SET UP INPUT FILE
//TFile* infile = new TFile("/star/u/klandry/ucladisk/2012IFF/all2012dataAll.root");
//TFile* infile = new TFile("/star/u/klandry/ucladisk/2012IFF/schedOutputWithinRad/allWithRadcut.root");
TFile* infile = new TFile("/star/u/klandry/ucladisk/2012IFF/schedOutAllDataTry1/allDataTry1.root");
//SET UP TREE TO RECEIVE INPUT
pionPair* pair1 = new pionPair();
TTree* pairTree = infile->Get("pionPairTree");
pairTree->SetBranchAddress("pionPair", &pair1);
//SET UP HISTOGRAMS
//event variable histograms
TH1D* hInvarM = new TH1D("invarM","invarM",80,0,2);
TH1D* hEtaTot = new TH1D("etaTot","etaTot",60,-1.5,1.5);
TH1D* hPhiR = new TH1D("hPhiR","hPhiR",60,-4,4);
TH1D* hPhiS = new TH1D("hPhiS","hPhiS",60,-4,4);
TH1D* hPhiSR = new TH1D("hPhiSR","hPhiSR",60,-4,4);
TH1D* hTheta = new TH1D("hTheta","hTheta",30,-0.85,4);
TH1D* hCosTheta = new TH1D("hCosTheta","hCosTheta",80,-1,1);
TH1D* hZ = new TH1D("hZ","hZ",80,0,1);
TH1D* hPtot = new TH1D("hPtot","hPtot",80,0,20);
TH1D* hPtTOT = new TH1D("hPt","hPt",80,0,15);
//histos for asym analysis
double histMin = -PI;
double histMax = PI;
const int binNumber = 16;
TH1D * hNumberUp = new TH1D("hNumberUp","hNumberUp",binNumber,histMin,histMax);
TH1D * hNumberDown = new TH1D("hNumberDown","hNumberDown",binNumber,histMin,histMax);
TH1D * hDiff = new TH1D("hNumberSum","hNumberSum",binNumber,histMin,histMax);
TH1D * hAut = new TH1D("Aut","Aut",binNumber,histMin,histMax);
//BEAM POLARIZATION
ifstream polFile;
polFile.open("/star/u/klandry/ucladisk/2012IFF/BeamPolarization2012.txt");
map<int, double> polarizationOfFill_Y;
map<int, double> polErrOfFill_Y;
map<int, double> polarizationOfFill_B;
map<int, double> polErrOfFill_B;
int fill;
int beamE;
int startT;
string plusminus;
double pAvrgBlue;
double pErrAvrgBlue;
double pInitialBlue;
double pErrInitialBlue;
double dPdTBlue;
double dPdTErrBlue;
double pAvrgYellow;
double pErrAvrgYellow;
double pInitialYellow;
double pErrInitialYellow;
double dPdTYellow;
double dPdTErrYellow;
string header;
for (int i=0; i<19; i++) {
polFile >> header;
}
while (!polFile.eof())
{
polFile >> fill;
polFile >> beamE;
polFile >> startT;
polFile >> pAvrgBlue;
polFile >> plusminus;
polFile >> pErrAvrgBlue;
polFile >> pInitialBlue;
polFile >> plusminus;
polFile >> pErrInitialBlue;
polFile >> dPdTBlue;
polFile >> plusminus;
polFile >> dPdTErrBlue;
polFile >> pAvrgYellow;
polFile >> plusminus;
polFile >> pErrAvrgYellow;
polFile >> pInitialYellow;
polFile >> plusminus;
polFile >> pErrInitialYellow;
polFile >> dPdTYellow;
polFile >> plusminus;
polFile >> dPdTErrYellow;
polarizationOfFill_B[fill] = pAvrgBlue/100.;
polErrOfFill_B[fill] = pErrAvrgBlue/100.;
polarizationOfFill_Y[fill] = pAvrgYellow/100.;
polErrOfFill_Y[fill] = pErrAvrgYellow/100.;
}
double avgPolOfBinUp[binNumber];
double polOfBinSumUp[binNumber];
double avgPerrorOfBinUp[binNumber];
double pErrorOfBinUp[binNumber];
double avgPolOfBinDown[binNumber];
double polOfBinSumDown[binNumber];
double avgPerrorOfBinDown[binNumber];
double pErrorOfBinDown[binNumber];
for (int i=0; i<binNumber; i++)
{
avgPolOfBinUp[i] = 0;
polOfBinSumUp[i] = 0;
avgPerrorOfBinUp[i] = 0;
pErrorOfBinUp[i] = 0;
avgPolOfBinDown[i] = 0;
polOfBinSumDown[i] = 0;
avgPerrorOfBinDown[i] = 0;
pErrorOfBinDown[i] = 0;
}
// ======================================================================
//============================================================================
//START ANALYSIS==============================================================
//============================================================================
// ======================================================================
cout << pairTree->GetEntries() << endl;
cout << "\n";
cout << "<----STARTING ANALYSIS---->" << endl;
cout << "\n";
double blueFillNo;
double yellowFillNo;
int bin;
TLorentzVector sum;
TLorentzVector sumY;
TLorentzVector sumB;
TRandom3 r;
int totalPairsFinal = 0;
for (int iPair = 0; iPair < pairTree->GetEntries(); iPair++)
{
if (iPair%10000 == 0) {
cout << "processing pair number " << iPair << endl;
}
//cout << "processing pair number " << iPair << endl;
//if (iPair == 80000){break;}
pairTree->GetEntry(iPair);
if (pair1->withinRadius(0.05, 0.3))
{
bool triggerFired = false;
bool fromKaon = false;
StTriggerId trigId = pair1->triggerIds();
if (trigId.isTrigger(370601) || trigId.isTrigger(370611) || trigId.isTrigger(370621))
{
triggerFired = true;
}
if (trigId.isTrigger(370501) || trigId.isTrigger(370511) || trigId.isTrigger(370522) || trigId.isTrigger(370531))
{
triggerFired = true;
}
if (pair1->invarientMass() > .4921 && pair1->invarientMass() < .4990)
{
fromKaon = true;
}
if (triggerFired)
{
blueFillNo = pair1->runInfo().beamFillNumber(1); //1 = blue beam
yellowFillNo = pair1->runInfo().beamFillNumber(0); //0 = yellow beam
//cout << blueFillNo << " " << yellowFillNo << endl;
if (polarizationOfFill_B[blueFillNo] == 0 || polarizationOfFill_Y[yellowFillNo] == 0)
{
continue;
}
hInvarM->Fill(pair1->invarientMass());
TVector3 spinVec;
sum = pair1->piPlusLV() + pair1->piMinusLV();
sumB = sum; //blue beam.
//yellow beam must rotate around y axis by pi so the eta cut can be the same for both beams.
sumY = sum;
sumY.RotateY(PI);
double randomSpin = r.Uniform(0, 1);
int randomSpinBit;
if (randomSpin >=0 && randomSpin <0.25) {
randomSpinBit = 5;
}
if (randomSpin >=0.25 && randomSpin <0.5) {
randomSpinBit = 6;
}
if (randomSpin >=0.5 && randomSpin <0.75) {
randomSpinBit = 9;
}
if (randomSpin >=0.75 && randomSpin <1.0) {
randomSpinBit = 10;
}
//CHECK CUTS
if (sumB.Pt() > ptCutLo && sumB.Pt() < ptCutHi && sumB.M() > mCutLo && sumB.M() < mCutHi && sumB.Eta() > etaCutLo && sumB.Eta() < etaCutHi && useBlueBeam == true)
{
//BLUE BEAM SPIN UP: spin bin 9 and 10
if (pair1->spinBit() == 9 || pair1->spinBit() == 10)
{
bin = hNumberUp->FindBin(pair1->phiSR('b'));
//hNumberUp->Fill(pair1->phiSR('b'));
polOfBinSumUp[bin] += polarizationOfFill_B[blueFillNo];
pErrorOfBinUp[bin] += polErrOfFill_B[blueFillNo];
}
//BLUE BEAM SPIN DOWN: spin bin 5 and 6
if (pair1->spinBit() == 5 || pair1->spinBit() == 6)
{
bin = hNumberDown->FindBin(pair1->phiSR('b'));
hNumberDown->Fill(pair1->phiSR('b'));
polOfBinSumDown[bin] += polarizationOfFill_B[blueFillNo];
pErrorOfBinDown[bin] += polErrOfFill_B[blueFillNo];
}
}//end blue cuts
TVector3 Pa;
Pa.SetXYZ(0, 0, 1); //blue is unpolarized beam
TVector3 Pb;
Pb.SetXYZ(0, 0, -1); //yellow is polarized beam
if (sumY.Pt()>ptCutLo && sumY.Pt() < ptCutHi && sumY.M() > mCutLo && sumY.M() < mCutHi && sumY.Eta() > etaCutLo && sumY.Eta() < etaCutHi && useYellowBeam == true)
{
//YELLOW BEAM SPIN UP: spin bin 6 and 10
//if (pair1->spinBit() == 6 || pair1->spinBit() == 10)
if (randomSpinBit == 6 || randomSpinBit == 10)
{
totalPairsFinal++;
spinVec.SetXYZ(0, 1, 0);
TVector3 Ph = pair1->piPlusLV().Vect() + pair1->piMinusLV().Vect();
TVector3 Rh = pair1->piPlusLV().Vect() - pair1->piMinusLV().Vect();
double cosPhi_S = -Pb.Unit().Cross(Ph).Unit() * Pb.Unit().Cross(spinVec).Unit();
double cosPhi_R = Ph.Unit().Cross(Pb).Unit() * Ph.Unit().Cross(Rh).Unit();
double sinPhi_S = Ph.Cross(spinVec) * Pb.Unit() / (Pb.Unit().Cross(Ph).Mag() * Pb.Unit().Cross(spinVec).Mag());
double sinPhi_R = Pb.Cross(Rh) * Ph.Unit() / (Ph.Unit().Cross(Pb).Mag() * Ph.Unit().Cross(Rh).Mag());
double sinPhi_S_R = sinPhi_S*cosPhi_R - cosPhi_S*sinPhi_R;
double cosPhi_S_R = cosPhi_S*cosPhi_R + sinPhi_S*sinPhi_R;
double phi_S_R;
if (cosPhi_S_R >= 0)
{
phi_S_R = asin(sinPhi_S_R);
}
else if (cosPhi_S_R < 0)
{
if (sinPhi_S_R >= 0)
{
phi_S_R = TMath::Pi() - asin(sinPhi_S_R);
}
if (sinPhi_S_R < 0)
{
phi_S_R = -TMath::Pi() - asin(sinPhi_S_R);
}
}
//cout << "phisr = " << phi_S_R << endl;
bin = hNumberUp->FindBin(phi_S_R);
hNumberUp->Fill(phi_S_R);
polOfBinSumUp[bin] += polarizationOfFill_Y[yellowFillNo];
pErrorOfBinUp[bin] += polErrOfFill_Y[yellowFillNo];
}
//YELLOW BEAM SPIN DOWN: spin bit 5 and 9
if (randomSpinBit == 5 || randomSpinBit == 9)
{
totalPairsFinal++;
spinVec.SetXYZ(0, -1, 0);
TVector3 Ph = pair1->piPlusLV().Vect() + pair1->piMinusLV().Vect();
TVector3 Rh = pair1->piPlusLV().Vect() - pair1->piMinusLV().Vect();
double cosPhi_S = -Pb.Unit().Cross(Ph).Unit() * Pb.Unit().Cross(spinVec).Unit();
double cosPhi_R = Ph.Unit().Cross(Pa).Unit() * Ph.Unit().Cross(Rh).Unit();
double sinPhi_S = Ph.Cross(spinVec) * Pb.Unit() / (Pb.Unit().Cross(Ph).Mag() * Pb.Unit().Cross(spinVec).Mag());
double sinPhi_R = Pa.Cross(Rh) * Ph.Unit() / (Ph.Unit().Cross(Pa).Mag() * Ph.Unit().Cross(Rh).Mag());
double sinPhi_S_R = sinPhi_S*cosPhi_R - cosPhi_S*sinPhi_R;
double cosPhi_S_R = cosPhi_S*cosPhi_R + sinPhi_S*sinPhi_R;
double phi_S_R;
if (cosPhi_S_R >= 0)
{
phi_S_R = asin(sinPhi_S_R);
}
else if (cosPhi_S_R < 0)
{
if (sinPhi_S_R >= 0)
{
phi_S_R = TMath::Pi() - asin(sinPhi_S_R);
}
if (sinPhi_S_R < 0)
{
phi_S_R = -TMath::Pi() - asin(sinPhi_S_R);
}
}
// cout << "phisr = " << phi_S_R << endl;
bin = hNumberDown->FindBin(phi_S_R);
hNumberDown->Fill(phi_S_R);
polOfBinSumDown[bin] += polarizationOfFill_Y[yellowFillNo];
pErrorOfBinDown[bin] += polErrOfFill_Y[yellowFillNo];
}
}//end yellow cuts
}//end triger check
}//end radius check
}//end pairTree loop
//CALCULATE ASYMMETRY BIN BY BIN
cout << "\n";
cout << "<----CALCULATING ASYMMETRY---->" << endl;
cout << "\n";
//*
for (int ibin=1; ibin<=binNumber; ibin++)
{
if (ibin <= binNumber*0.5)
{
double nUp = hNumberUp->GetBinContent(ibin);
double nUpPi = hNumberUp->GetBinContent(ibin+binNumber*0.5);
double nDown = hNumberDown->GetBinContent(ibin);
double nDownPi = hNumberDown->GetBinContent(ibin+binNumber*0.5);
cout << nUp << " " << nUpPi << " " << nDown << " " << nDownPi << " " << endl;
int binIndexPi = ibin+binNumber*0.5;
double avgPolA = (polOfBinSumUp[ibin]+polOfBinSumDown[binIndexPi])/(nUp+nDownPi);
double avgPolB = (polOfBinSumUp[binIndexPi]+polOfBinSumDown[ibin])/(nUpPi+nDown);
double realAvgPol = (polOfBinSumUp[ibin]+polOfBinSumDown[binIndexPi]+polOfBinSumUp[binIndexPi]+polOfBinSumDown[ibin])/(nUp+nUpPi+nDown+nDownPi);
}
else
{
double nUp = hNumberUp->GetBinContent(ibin);
double nUpPi = hNumberUp->GetBinContent(ibin-binNumber*0.5);
double nDown = hNumberDown->GetBinContent(ibin);
double nDownPi = hNumberDown->GetBinContent(ibin-binNumber*0.5);
int binIndexPi = ibin-binNumber*0.5;
cout << nUp << " " << nUpPi << " " << nDown << " " << nDownPi << " " << endl;
double avgPolA = (polOfBinSumUp[ibin]+polOfBinSumDown[binIndexPi])/(nUp+nDownPi);
double avgPolB = (polOfBinSumUp[binIndexPi]+polOfBinSumDown[ibin])/(nUpPi+nDown);
double realAvgPol = (polOfBinSumUp[ibin]+polOfBinSumDown[binIndexPi]+polOfBinSumUp[binIndexPi]+polOfBinSumDown[ibin])/(nUp+nUpPi+nDown+nDownPi);
double realAvgPolE = (pErrorOfBinUp[ibin]+pErrorOfBinDown[binIndexPi]+pErrorOfBinUp[binIndexPi]+pErrorOfBinDown[ibin])/(nUp+nUpPi+nDown+nDownPi);
}
cout << avgPolA << " " << avgPolB << endl;
hDiff->SetBinContent(ibin, sqrt(nUp*nDownPi) - sqrt(nDown*nUpPi));
//hAut->SetBinContent(ibin, (1/avgPolA * sqrt(nUp*nDownPi) - 1/avgPolB * sqrt(nDown*nUpPi)) / (sqrt(nUp*nDownPi) + sqrt(nDown*nUpPi)) );
hAut->SetBinContent(ibin, 1/realAvgPol * (sqrt(nUp*nDownPi) - sqrt(nDown*nUpPi)) / (sqrt(nUp*nDownPi) + sqrt(nDown*nUpPi)) );
//error
if (realAvgPol*pow(sqrt(nUp*nDownPi)+sqrt(nDown*nUpPi), 2) != 0)
{
double a = sqrt(nUp*nDownPi);
double b = sqrt(nUpPi*nDown);
double firstTerm = realAvgPol**2 * (nUpPi*nDown*(nUp+nDownPi) + nDownPi*nUp*(nUpPi+nDown));
//double secondTerm = ((nUp*nDownPi)**2 +(nUpPi*nDown)**2 - 2*nUp*nDown*nUpPi*nDownPi)*realAvgPolE**2;
double secondTerm = 0;
double binError = 1/realAvgPol**2 * 1/(a+b)**2 * sqrt(firstTerm + secondTerm);
}
else
{
double binError = 0.01;
cout << "bin " << ibin << " Has problem with error" << endl;
}
hAut->SetBinError(ibin, binError);
}//end Asym calc
//*/
//DRAW HISTOGRAMS
hInvarM->Draw();
TCanvas* cNup = new TCanvas();
hNumberUp->Draw();
TCanvas* cNdown = new TCanvas();
hNumberDown->Draw();
TCanvas* cAut = new TCanvas();
cAut->SetName("cAut");
TF1* fitFunc = new TF1("fitFunc","[0]*sin(x)+[1]",-PI,PI);
//hAut->Fit("fitFunc","R");
hAut->Draw();
hAut->GetXaxis()->SetTitle("#phi_{S} - #phi_{R}");
char title[150];
sprintf(title, "%.1f < P_{T}^{#pi^{+}#pi^{-}} < %.1f %.1f < M_{inv}^{#pi^{+}#pi^{-}} < %.1f %.1f < #eta^{#pi^{+}#pi^{-}} < %.1f", ptCutLo, ptCutHi, mCutLo, mCutHi, etaCutLo, etaCutHi);
hAut->SetTitle(title);
//SAVE CANVAS
stringstream pt;
stringstream eta;
stringstream mass;
string part1 = "_ptBin";
string part2 = "_massBin";
string part3 = "_etaBin";
string ptBinStr;
string etaBinStr;
string massBinStr;
pt << ptBin;
eta << etaBin;
mass << massBin;
if (ptBin == 9) {
ptBinStr = "All";
}
else {
ptBinStr = pt.str();
}
if (massBin == 9) {
massBinStr = "All";
}
else {
massBinStr = mass.str();
}
if (etaBin == 9) {
etaBinStr = "All";
}
else {
etaBinStr = eta.str();
}
cout << "total pairs " << totalPairsFinal << endl;
string outFileName = "./resultsTesting/piover2issue"+part1+ptBinStr+part2+massBinStr+part3+etaBinStr+".root";
TFile* outFile = new TFile(outFileName.c_str(),"Recreate");
cout << "---WRITING FILE---" << endl;
//cAut->SaveAs(outFileName.c_str());
hAut->Write();
hNumberUp->Write();
hNumberDown->Write();
cout << "---END---" << endl;
}
void testRotation(){
//LOAD LIBS
cout << "\n";
gROOT->Macro("StRoot/LoadLibs.C");
gSystem->Load("pionPair");
cout << " loading of pionPair library done" << endl;
TFile* infile = new TFile("/star/u/klandry/ucladisk/2012IFF/schedOutputAll/all_0.root");
//SET UP TREE TO RECEIVE INPUT
pionPair* pair1 = new pionPair();
TTree* pairTree = infile->Get("pionPairTree");
pairTree->SetBranchAddress("pionPair", &pair1);
for (int iPair = 0; iPair < pairTree->GetEntries(); iPair++)
{
if (iPair%10000 == 0) {cout << "processing pair number " << iPair << endl;}
//cout << "processing pair number " << iPair << endl;
//if (iPair == 661){continue;}
pairTree->GetEntry(iPair);
TVector3 spinVec;
if (pair1->withinRadius(0.05, 0.3))
{
int spinB = pair1->spinBit();
if (spinB == 5 || spinB == 9) //yelow down
{
spinVec.SetXYZ(0, -1, 0);
}
if (spinB == 6 || spinB == 10) //yellow up
{
spinVec.SetXYZ(0, 1, 0);
}
if (spinB == 5 || spinB == 6 || spinB == 9 || spinB == 10)
{
TVector3 Ph = pair1->piPlusLV().Vect() + pair1->piMinusLV().Vect();
TVector3 Rh = pair1->piPlusLV().Vect() - pair1->piMinusLV().Vect();
TVector3 Pa;
Pa.SetXYZ(0, 0, 1); //blue is unpolarized beam
TVector3 Pb;
Pb.SetXYZ(0, 0, -1); //yellow is polarized beam
//ROTATE EVERYTHING BY PI AROUND Y AXIS
Ph.RotateY(TMath::Pi());
Rh.RotateY(TMath::Pi());
Pa.RotateY(TMath::Pi());
Pb.RotateY(TMath::Pi());
// cout << Ph << endl;
// cout << Rh << endl;
// cout << Pa << endl;
// cout << Pb << endl;
//cout << "\n";
//cout << Ph.Unit().Cross(Pa) << endl;
//cout << Ph.Unit().Cross(Rh) << endl;
double cosPhi_S = Pb.Unit().Cross(Ph).Unit() * Pb.Unit().Cross(spinVec).Unit();
double cosPhi_R = Ph.Unit().Cross(Pa).Unit() * Ph.Unit().Cross(Rh).Unit();
double sinPhi_S = Ph.Cross(spinVec) * Pb.Unit() / (Pb.Unit().Cross(Ph).Mag() * Pb.Unit().Cross(spinVec).Mag());
double sinPhi_R = Pa.Cross(Rh) * Ph.Unit() / (Ph.Unit().Cross(Pa).Mag() * Ph.Unit().Cross(Rh).Mag());
double sinPhi_S_R = sinPhi_S*cosPhi_R - cosPhi_S*sinPhi_R;
double cosPhi_S_R = cosPhi_S*cosPhi_R + sinPhi_S*sinPhi_R;
double phi_S_R;
if (cosPhi_S_R >= 0)
{
phi_S_R = asin(sinPhi_S_R);
}
else if (cosPhi_S_R < 0)
{
if (sinPhi_S_R >= 0)
{
phi_S_R = TMath::Pi() - asin(sinPhi_S_R);
}
if (sinPhi_S_R < 0)
{
phi_S_R = -TMath::Pi() - asin(sinPhi_S_R);
}
}
cout << "regular Phi_SR = " << pair1->phiSR('y') << " rotated Phi_SR = " << phi_S_R << endl;
}
}
}
}
void test_allEvt::ComputeAllVarPietro(TLorentzVector lepP,TLorentzVector lepN){
// Preliminary definitions:
const double pbeam = 7000.; // exact number irrelevant as long as pbeam >> Mprot
const double Mprot = 0.9382720;
const double Mlepton = 0.10566; // (muon)
const double gPI = TMath::Pi();
const double Ebeam = sqrt( pbeam*pbeam + Mprot*Mprot );
TLorentzVector beam1_LAB( 0., 0., pbeam, Ebeam );
TLorentzVector beam2_LAB( 0., 0., -pbeam, Ebeam );
// assuming that we have a TTree "data" (data ntuple) containing the 4-vectors lepP and lepN of lepton and antilepton
// event by event (in some loop over dilepton events in the data ntuple):
// data->GetEvent( i_event );
// double lepP_pT = lepP->Pt();
// double lepN_pT = lepN->Pt();
// double lepP_eta = lepP->PseudoRapidity();
// double lepN_eta = lepN->PseudoRapidity();
// dilepton 4-vector:
TLorentzVector dilepton = lepP + lepN;
double pT = dilepton.Pt();
double rap = dilepton.Rapidity();
double mass = dilepton.M();
// calculation of decay angles in three polarization frames
// reference directions to calculate angles:
TVector3 lab_to_dilep = -dilepton.BoostVector();
TLorentzVector beam1_DILEP = beam1_LAB;
beam1_DILEP.Boost(lab_to_dilep); // beam1 in the dilepton rest frame
TLorentzVector beam2_DILEP = beam2_LAB;
beam2_DILEP.Boost(lab_to_dilep); // beam2 in the dilepton rest frame
TVector3 beam1_direction = beam1_DILEP.Vect().Unit();
TVector3 beam2_direction = beam2_DILEP.Vect().Unit();
TVector3 dilep_direction = dilepton.Vect().Unit();
TVector3 beam1_beam2_bisect = ( beam1_direction - beam2_direction ).Unit();
// all polarization frames have the same Y axis = the normal to the plane formed by
// the directions of the colliding hadrons:
TVector3 Yaxis = ( beam1_direction.Cross( beam2_direction ) ).Unit();
// flip of y axis with rapidity:
if ( rap < 0. ) Yaxis = - Yaxis;
TVector3 perpendicular_to_beam = ( beam1_beam2_bisect.Cross( Yaxis ) ).Unit();
// positive lepton in the dilepton rest frame:
TLorentzVector lepton_DILEP = lepP;
lepton_DILEP.Boost(lab_to_dilep);
// CS frame angles:
TVector3 newZaxis = beam1_beam2_bisect;
TVector3 newYaxis = Yaxis;
TVector3 newXaxis = newYaxis.Cross( newZaxis );
TRotation rotation;
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert(); // transforms coordinates from the "xyz" frame to the new frame
TVector3 lepton_DILEP_rotated = lepton_DILEP.Vect();
lepton_DILEP_rotated.Transform(rotation);
/* double */ costh_CS = lepton_DILEP_rotated.CosTheta();
/* double */ phi_CS = lepton_DILEP_rotated.Phi() * 180. / gPI;
double phith_CS;
if ( costh_CS < 0. ) phith_CS = phi_CS - 135.;
if ( costh_CS > 0. ) phith_CS = phi_CS - 45.;
if ( phith_CS < -180. ) phith_CS = 360. + phith_CS;
phi_CS = phi_CS / 180. * gPI;
// HELICITY frame angles:
newZaxis = dilep_direction;
newYaxis = Yaxis;
newXaxis = newYaxis.Cross( newZaxis );
rotation.SetToIdentity();
rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
rotation.Invert();
lepton_DILEP_rotated = lepton_DILEP.Vect();
lepton_DILEP_rotated.Transform(rotation);
/* double */ costh_HX = lepton_DILEP_rotated.CosTheta();
/* double */ phi_HX = lepton_DILEP_rotated.Phi() * 180. / gPI;
double phith_HX;
if ( costh_HX < 0. ) phith_HX = phi_HX - 135.;
if ( costh_HX > 0. ) phith_HX = phi_HX - 45.;
if ( phith_HX < -180. ) phith_HX = 360. + phith_HX;
phi_HX = phi_HX / 180. * gPI;
// // PERPENDICULAR HELICITY frame angles:
// newZaxis = perpendicular_to_beam;
// newYaxis = Yaxis;
// newXaxis = newYaxis.Cross( newZaxis );
// rotation.SetToIdentity();
// rotation.RotateAxes( newXaxis, newYaxis, newZaxis );
// rotation.Invert();
// lepton_DILEP_rotated = lepton_DILEP.Vect();
// lepton_DILEP_rotated.Transform(rotation);
// double costh_PX = lepton_DILEP_rotated.CosTheta();
// double phi_PX = lepton_DILEP_rotated.Phi() * 180. / gPI;
// double phith_PX;
// if ( costh_PX < 0. ) phith_PX = phi_PX - 135.;
// if ( costh_PX > 0. ) phith_PX = phi_PX - 45.;
// if ( phith_PX < -180. ) phith_PX = 360. + phith_PX;
// phi_PX = phi_PX / 180. * gPI;
}
