TLorentzVector doCalEnergy(double BeamEnergy,
TLorentzVector Particle1,
TLorentzVector Particle2,
double nucleusMass,
double Particle2Mass,
double Particle3Mass)
{
double E_Particle1 = Particle1.E();
double p_Particle1_x = Particle1.Px();
double p_Particle1_y = Particle1.Py();
double p_Particle1_z = Particle1.Pz();
double p_Particle1 = sqrt(TMath::Power(p_Particle1_x,2.0) +
TMath::Power(p_Particle1_y,2.0) +
TMath::Power(p_Particle1_z,2.0));
double phi = Particle2.Phi();
double theta = Particle2.Theta();
double b = 2.0 * ( p_Particle1_x * cos(phi) * sin(theta) +
p_Particle1_y * sin(phi) * sin(theta) +
p_Particle1_z * cos(theta) -
BeamEnergy * cos(theta)
);
double c = p_Particle1 * p_Particle1 + BeamEnergy * BeamEnergy - 2.0 * BeamEnergy * p_Particle1_z;
double d = BeamEnergy + nucleusMass - E_Particle1;
double e = TMath::Power(Particle3Mass,2.0) - TMath::Power(Particle2Mass,2.0) - d * d + c;
double Delta = 16.0 * TMath::Power(d,2.0) * (TMath::Power(e,2.0) +
TMath::Power(b * Particle2Mass,2.0) -
TMath::Power(d * Particle2Mass * 2.0,2.0));
TLorentzVector NewParticle(0.0,0.0,0.0,0.0);
if(Delta>0.)
{
double sol2 = (2.0 * e * b + sqrt(Delta)) / (2.0 * (4.0 * TMath::Power(d,2.0) - TMath::Power(b,2.0)));
double newpxcal = sol2 * cos(phi) * sin(theta);
double newpycal = sol2 * sin(phi) * sin(theta);
double newpzcal = sol2 * cos(theta);
double energy = sqrt(TMath::Power(sol2,2.0) + TMath::Power(Particle2Mass,2.0));
TLorentzVector NewParticle2(newpxcal,newpycal,newpzcal,energy);
NewParticle = NewParticle2;
}
return NewParticle;
}
void fill(int const kf, TLorentzVector* b, double weight, TLorentzVector const& p1Mom, TLorentzVector const& p2Mom, TVector3 v00)
{
int const centrality = floor(nCent * gRandom->Rndm());
TVector3 const vertex = getVertex(centrality);
// smear primary vertex
// float const sigmaVertex = sigmaVertexCent[cent];
// TVector3 const vertex(gRandom->Gaus(0, sigmaVertex), gRandom->Gaus(0, sigmaVertex), gRandom->Gaus(0, sigmaVertex));
v00 += vertex;
// smear momentum
TLorentzVector const p1RMom = smearMom(0, p1Mom);
TLorentzVector const p2RMom = smearMom(0, p2Mom);
// smear position
TVector3 const p1RPos = smearPosData(0, vertex.z(), centrality, p1RMom, v00);
TVector3 const p2RPos = smearPosData(0, vertex.z(), centrality, p2RMom, v00);
// TVector3 const kRPos = smearPos(kMom, kRMom, v00);
// TVector3 const pRPos = smearPos(pMom, pRMom, v00);
// reconstruct
TLorentzVector const rMom = p1RMom + p2RMom;
float const p1Dca = dca(p1Mom.Vect(), v00, vertex);
float const p2Dca = dca(p2Mom.Vect(), v00, vertex);
float const p1RDca = dca(p1RMom.Vect(), p1RPos, vertex);
float const p2RDca = dca(p2RMom.Vect(), p2RPos, vertex);
TVector3 v0;
float const dca12 = dca1To2(p1RMom.Vect(), p1RPos, p2RMom.Vect(), p2RPos, v0);
float const decayLength = (v0 - vertex).Mag();
float const dcaD0ToPv = dca(rMom.Vect(), v0, vertex);
float const cosTheta = (v0 - vertex).Unit().Dot(rMom.Vect().Unit());
float const angle12 = p1RMom.Vect().Angle(p2RMom.Vect());
TLorentzVector p1RMomRest = p1RMom;
TVector3 beta;
beta.SetMagThetaPhi(rMom.Beta(), rMom.Theta(), rMom.Phi());
p1RMomRest.Boost(-beta);
float const cosThetaStar = rMom.Vect().Unit().Dot(p1RMomRest.Vect().Unit());
// save
float arr[100];
int iArr = 0;
arr[iArr++] = centrality;
arr[iArr++] = vertex.X();
arr[iArr++] = vertex.Y();
arr[iArr++] = vertex.Z();
arr[iArr++] = kf;
arr[iArr++] = b->M();
arr[iArr++] = b->Perp();
arr[iArr++] = b->PseudoRapidity();
arr[iArr++] = b->Rapidity();
arr[iArr++] = b->Phi();
arr[iArr++] = v00.X();
arr[iArr++] = v00.Y();
arr[iArr++] = v00.Z();
arr[iArr++] = rMom.M();
arr[iArr++] = rMom.Perp();
arr[iArr++] = rMom.PseudoRapidity();
arr[iArr++] = rMom.Rapidity();
arr[iArr++] = rMom.Phi();
arr[iArr++] = v0.X();
arr[iArr++] = v0.Y();
arr[iArr++] = v0.Z();
arr[iArr++] = dca12;
arr[iArr++] = decayLength;
arr[iArr++] = dcaD0ToPv;
arr[iArr++] = cosTheta;
arr[iArr++] = angle12;
arr[iArr++] = cosThetaStar;
arr[iArr++] = p1Mom.M();
arr[iArr++] = p1Mom.Perp();
arr[iArr++] = p1Mom.PseudoRapidity();
arr[iArr++] = p1Mom.Rapidity();
arr[iArr++] = p1Mom.Phi();
arr[iArr++] = p1Dca;
arr[iArr++] = p1RMom.M();
arr[iArr++] = p1RMom.Perp();
arr[iArr++] = p1RMom.PseudoRapidity();
arr[iArr++] = p1RMom.Rapidity();
arr[iArr++] = p1RMom.Phi();
arr[iArr++] = p1RPos.X();
arr[iArr++] = p1RPos.Y();
arr[iArr++] = p1RPos.Z();
arr[iArr++] = p1RDca;
arr[iArr++] = tpcReconstructed(0,1,centrality,p1RMom);
arr[iArr++] = p2Mom.M();
arr[iArr++] = p2Mom.Perp();
arr[iArr++] = p2Mom.PseudoRapidity();
arr[iArr++] = p2Mom.Rapidity();
arr[iArr++] = p2Mom.Phi();
arr[iArr++] = p2Dca;
arr[iArr++] = p2RMom.M();
arr[iArr++] = p2RMom.Perp();
arr[iArr++] = p2RMom.PseudoRapidity();
arr[iArr++] = p2RMom.Rapidity();
arr[iArr++] = p2RMom.Phi();
arr[iArr++] = p2RPos.X();
arr[iArr++] = p2RPos.Y();
arr[iArr++] = p2RPos.Z();
arr[iArr++] = p2RDca;
arr[iArr++] = tpcReconstructed(0,-1,centrality,p2RMom);
arr[iArr++] = matchHft(1, vertex.z(), centrality, p1RMom);
arr[iArr++] = matchHft(0, vertex.z(), centrality, p2RMom);
nt->Fill(arr);
}
void recursive_inter_with_air(){
TFile *f1 = new TFile("muon.root", "recreate");
TCanvas *c1 = new TCanvas("test", "test", 600, 700);
TH1F * mu_c_1 = new TH1F("mu_c_1", "mu_c_1", 100, 0, 500);
TH1F * mu_c_2 = new TH1F("mu_c_2", "mu_c_2", 100, 0, 500);
TH1F * mu_c_3 = new TH1F("mu_c_3", "mu_c_3", 100, 0, 500);
fn_muon_dxde = new TF1("f1", dxde_muon, M_mu, 1000, 1);
TNtuple * ntuple = new TNtuple("ntuple", "ntuple", "nobs:detz:theta:press");
// TNtuple *ntuple = new TNtuple("ntuple", "ntuple", "id:flag:e:px:py:pz:x:y:z");
r = new TRandom();
// r ->SetSeed(12232);
for (int ievertex_nt = 0; ievertex_nt < 500; ievertex_nt++)
{
n_particle = 0;
// init muon conunter
int mu_counter1 = 0;
int mu_counter2 = 0;
int mu_counter3 = 0;
double E = 1000; // GeV
double theta = 0;
// double theta = acos(r->Rndm());
double phi = r->Rndm()*pi*2;
double x = 0, y = 0, z = 1.0e10; //infinity
double vertex_z, vertex_x, vertex_y; //km
Get_Int_Posi(pdg_proton_p, theta, phi, x, y, z, vertex_x, vertex_y, vertex_z);
Hillas_Split(pdg_proton_p, E, theta, phi, vertex_x, vertex_y, vertex_z);
double proton_threshold = 10;
double pion_threshold = 10;
int i_particle = 0;
while(i_particle < n_particle){
int id = Ptcl_bank[i_particle].id;
int flag = Ptcl_bank[i_particle].flag;
double e = Ptcl_bank[i_particle].e;
double x = Ptcl_bank[i_particle].vertex_x;
double y = Ptcl_bank[i_particle].vertex_y;
double z = Ptcl_bank[i_particle].vertex_z;
if (id == pdg_proton_p && flag == 1 && e > proton_threshold)
{
Get_Int_Posi(id, theta, phi, x, y, z, vertex_x, vertex_y, vertex_z);
if (vertex_z > 0)
{
Hillas_Split(id, e, theta, phi, vertex_x, vertex_y, vertex_z);
Ptcl_bank[i_particle].flag = 0;
}
}
if (id == pdg_pion_p &&flag == 1){
Get_Int_Posi(id, theta, phi, x, y, z, vertex_x, vertex_y, vertex_z) ;
double l_to_interaction = sqrt((vertex_x-x)*(vertex_x-x)+(vertex_y-y)*(vertex_y-y)+(vertex_z-z)*(vertex_z-z));
double l_to_decay = get_decay_length(pdg_pion_p, tau_pion, e);
if (l_to_decay>l_to_interaction){
if (vertex_z > 0){
Hillas_Split(id, e, theta, phi, vertex_x, vertex_y, vertex_z);
Ptcl_bank[i_particle].flag = 0;
}
}else{ // pion decay
Ptcl_bank[i_particle].flag = 0;
double px = Ptcl_bank[i_particle].px;
double py = Ptcl_bank[i_particle].py;
double pz = Ptcl_bank[i_particle].pz; // GeV
TLorentzVector pion(px, py, pz, e);
double decay_particle_mass[2] = {M_mu, M_neu};
TGenPhaseSpace event;
event.SetDecay(pion, 2, decay_particle_mass);
event.Generate();
TLorentzVector Muon = *(event.GetDecay(0));
TLorentzVector Neu = *(event.GetDecay(1));
double mu_theta = Muon.Theta();
double mu_phi = Muon.Phi();
if (mu_theta>pi/2.) {
double mu_E = Muon.E();
double muon_decay_time = r ->Exp(tau_muon);
double muon_decay_length = get_decay_length(pdg_muon_n, tau_muon, mu_E);
float det_x = 0;
float det_y = 0;
float det_z = 0;
mu_counter1++;
double l_mu_vtx_to_det = sqrt(pow(vertex_x-det_x,2)+pow(vertex_y-det_y,2)+pow(vertex_z-det_z,2));
// cout << "MuE" << mu_E << " Mass" <<M_mu<< " dl" << muon_decay_length << " lvd" << l_mu_vtx_to_det << endl;
if (muon_decay_length > l_mu_vtx_to_det)
{
mu_counter2++;
double mu_stop_x;
double mu_stop_y;
double mu_stop_z;
get_muon_stop_position(mu_E, mu_theta, mu_phi, vertex_x, vertex_y, vertex_z, mu_stop_x, mu_stop_y, mu_stop_z);
double l_muon_stop = sqrt(pow(vertex_x-mu_stop_x,2)+pow(vertex_y-mu_stop_y,2)+pow(vertex_z-mu_stop_z,2));
// cout << l_muon_stop << " " << l_mu_vtx_to_det <<endl;
if (l_muon_stop > l_mu_vtx_to_det)
{
mu_counter3++;
}
}
}
}
}
i_particle++;
}
mu_c_1 ->Fill(mu_counter1);
mu_c_2 ->Fill(mu_counter2);
mu_c_3 ->Fill(mu_counter3);
// for (int i_particle = 0; i_particle < n_particle; ++i_particle){
// int id = Ptcl_bank[i_particle].id;
// int flag = Ptcl_bank[i_particle].flag;
// double e = Ptcl_bank[i_particle].e;
// double px = Ptcl_bank[i_particle].px;
// double py = Ptcl_bank[i_particle].py;
// double pz = Ptcl_bank[i_particle].pz;
// double x = Ptcl_bank[i_particle].vertex_x;
// double y = Ptcl_bank[i_particle].vertex_y;
// double z = Ptcl_bank[i_particle].vertex_z;
// ntuple->Fill(id, flag, e, px, py, pz, x, y, z);
// }
}
mu_c_3 ->Draw();
mu_c_2 ->SetLineColor(2);
mu_c_2 ->Draw("same");
mu_c_1 ->SetLineColor(4);
mu_c_1 ->Draw("same");
// ntuple->Draw("z");
}
bool leptonic_fitter_algebraic::fit( const TLorentzVector& B, const TH1& BITF, const TF1& Beff,
const TLorentzVector& lep,
double MEX, double MEY, const TF1& dnuPDF )
{
if( _dbg > 19 ) cout<<"DBG20 Entered leptonic_fitter_algebraic::fit with B mass: "<<B.M()<<", l_m:"<<lep.M()<<", MET: "<<MEX<<" "<<MEY<<endl;
if( B.M() <= 0 ) throw std::runtime_error( "leptonic_fitter_algebraic was given a b-jet with an illegal (non-positive) mass!");
if( lep.M() < 0 ) throw std::runtime_error( "leptonic_fitter_algebraic was given a lepton with an illegal (negative) mass!");
_converged = _swapped = false;
_obsB = B;
_obsL = lep;
_BITF = &BITF;
_Beff = &Beff;
_dnuPDF = dnuPDF;
_b_m2 = B.M2();
double lep_b_angle = lep.Angle( B.Vect() );
double cos_lep_b = TMath::Cos( lep_b_angle );
double sin_lep_b = TMath::Sin( lep_b_angle );
double b_p = B.P();
double b_e = B.E();
_denom = b_e - cos_lep_b * b_p;
_lep_p = lep.P();
_x0 = - _W_m2 / ( 2 * _lep_p );
_y1 = - sin_lep_b * _x0 * b_p / _denom;
_x1_0 = _x0 * b_e / _denom - _y1*_y1 / _x0;
_Z2_0 = _x0*_x0 - _W_m2 - _y1*_y1;
if( _dbg > 219 ) cout<<"DBG220 lfa updated lepton with: "<<lv2str( lep )<<" -> x0:"<<_x0<<", y1: "<<_y1<<", x1_0: "<<_x1_0<<", Z2_0: "<<_Z2_0<<endl;
static double bnums[3];
bnums[0] = B.X();
bnums[1] = B.Y();
bnums[2] = B.Z();
TMatrixD bXYZ( 3, 1, bnums );
_R_T = rotation( 2, lep.Phi() ); // R_z^T
_R_T *= rotation( 1, lep.Theta() - 0.5*TMath::Pi() ); // R_z^T R_y^T
TMatrixD rotation_vect( _R_T, TMatrixD::kTransposeMult, bXYZ ); // R_y R_z
double* rotation_array = rotation_vect.GetMatrixArray();
double phi_x = - TMath::ATan2( rotation_array[2], rotation_array[1] );
if( _dbg > 99 ) cout<<"DBG100 lfa x rotation vector is:"<<rotation_array[0]<<" "<<rotation_array[1]<<" "<<rotation_array[2]<<" -> phi_x:"<<phi_x<<endl;
_R_T *= rotation( 0, - phi_x ); // R_z^T R_y^T R_x^T
// set up _Nu's non-zero elements so that \vec{nu} = Nu \vec{t} for any \vec{t} (since only t's 3nd component is used, and its always 1).
_Nu[0][2] = MEX;
_Nu[1][2] = MEY;
double iVarMET = TMath::Power( TMath::Max( 1., dnuPDF.GetHistogram()->GetRMS() ), -2 );
_invFlatVar[0][0] = _invFlatVar[1][1] = iVarMET; // set up the chi^2 distance with the right order of magnitude (generalizes to rotated covariance matrix)
if( _dbg > 209 ) cout<<"DBG210 lfa "<<dnuPDF.GetName()<<" --> iVarMET:"<<iVarMET<<endl;
// (re)define fit parameter, so all fits start off on an equal footing
_mini->SetPrintLevel( _minimizer_print_level );
_mini->Clear();
_mini->SetFunction( _functor );
leptonic_fitter_algebraic_object = this; // set the function in the functor pointing back to this object. Doubtfull that all this redirection is needed...
_mini->SetTolerance( _tolerance );
bool OK = _mini->SetLimitedVariable( 0, "sB", 1.0, 0.4, 0.1, 6.0 );
//bool OK = _mini->SetVariable( 0, "sB", 1.0, 0.4 );
if( ! OK ) {cerr<<"minimizer (@lfa) failed to SetVariable."<<endl; return false;}
// define 1 sigma in terms of the function
_mini->SetErrorDef( 0.5 ); // since this is a likelihood fit
// do the minimization
OK = _mini->Minimize();
if( _dbg > 19 && ( ! OK || _dbg > 59 ) ) cout<<"DBG INFO: initial fit @lfa returned OK: "<<OK<<", has status: "<<_mini->Status()<<endl;
_converged = OK; // use status somehow? depends on fitter?
// read parameters
const double *xs = _mini->X();
for( int ip = 0; ip < 1; ++ip ) _params[ ip ] = xs[ ip ];
// return all intermediate results to the minimum, in particular, the discriminant
calc_MLL( _params, true );
TMatrixD nu_vec( _Emat, TMatrixD::kMult, _tvec );
update_nu_and_decay_chain( nu_vec );
if( _dbg > 203 ) cout<<"DBG204 lfa finalized _genN: "<<lv2str(_genN)<<", _W: "<<lv2str(_W)<<", & _t: "<<lv2str(_T)<<endl;
_MLL = _mini->MinValue();
return true;
}
Int_t dieleAna(TString inputlist, TString outfile, Int_t nev=-1, Int_t whichweight = 0)
{
TH1::SetDefaultSumw2();
TH3F *p3DEffEle[6][NWEIGHTS+1]; // mult bins, MLP weights + HC
TH3F *p3DEffPos[6][NWEIGHTS+1];
TH3F *p3DAccEle[6][NWEIGHTS+1];
TH3F *p3DAccPos[6][NWEIGHTS+1];
readAccEffMatrices(p3DAccEle, p3DAccPos, p3DEffEle, p3DEffPos);
TH2F *smear_ele, *smear_pos;
TFile *file_smear = new TFile("smearing_matrix.root","read");
smear_ele = (TH2F*)file_smear->Get("smear_ele");
smear_pos = (TH2F*)file_smear->Get("smear_pos");
TRandom random;
/*
TFile *pEffFile;
pEffFile = new TFile("Input/EffMatrixMVA2RefAccNewCP_100Mio.root");
if (pEffFile)
{
pEffFile->cd();
for(Int_t i = 0 ; i < 5 ; i++){
p3DEffEle[i][6] = (TH3F*) pEffFile->Get(Form("hHistEff3DMult%iNeg",i));
p3DEffPos[i][6] = (TH3F*) pEffFile->Get(Form("hHistEff3DMult%iPos",i));
// p3DEffEle[i] = (TH3F*) pEffFile->Get("hHistEff3DNeg");
// p3DEffPos[i] = (TH3F*) pEffFile->Get("hHistEff3DPos");
}
}
else
{
Error("DrawFromNtuple constructor","pointer to eff matrix file is NULL");
for(Int_t i = 0 ; i < 5 ; i++){
p3DEffEle[i][6] = NULL;
p3DEffPos[i][6] = NULL;
}
}
*/
TH1F *pEventClass;
TH1F *pEventClass_recur;
TFile *pEventClassFile;
// pEventClassFile = new TFile("eventClass_mult_nonempty_4secmult_200fpj_wait.root");
// pEventClassFile = new TFile("eventClass_target_mult_rplane_nonempty_4secmult.root");
pEventClassFile = new TFile("eventClass_target_mult_rplane_minmom_nmix_w6.root");
if (pEventClassFile) {
pEventClass = (TH1F*)pEventClassFile->Get("eventClass");
pEventClass_recur = (TH1F*)pEventClassFile->Get("eventClass_recur");
if (pEventClass == NULL || pEventClass_recur == NULL) {
Error("DrawFromNtuple constructor","Histogram not found in the event class file");
exit (-1);
}
}
else {
Error("DrawFromNtuple constructor","Event class file not found");
exit (-1);
}
HLoop* loop = new HLoop(kTRUE); // kTRUE : create Hades (needed to work with standard eventstructure)
TString readCategories = "";
if (inputlist.EndsWith(".list")) {
loop->addFilesList(inputlist);
}
else {
loop->addMultFiles(inputlist);
}
if(!loop->setInput(readCategories)) { exit(1); }
loop->printCategories();
loop->readSectorFileList("FileListLepton.list");
int sectors[6];
HGeantKine *kine1;
HGeantKine *kine2;
HCategory* kineCat = (HCategory*)HCategoryManager::getCategory(catGeantKine);
HHistMap hM(outfile.Data());
hM.setSilentFail(kTRUE);
//------------------------------------------------------------------
//--------------- begin histo booking -----------------------------------------------------
//------------------------------------------------------------------------------------------
const Int_t nbins = 26;
Double_t xAxis1[nbins+1] = {0, 0.010, 0.020, 0.030, 0.040, 0.050, 0.060, 0.070, 0.080, 0.090, 0.110, 0.130, 0.150, 0.170, 0.200, 0.250, 0.300, 0.350, 0.400, 0.450, 0.500, 0.550, 0.600, 0.700, 0.800, 0.900, 1.};
hM.addHist(new TH1F(TString("hmassNP"),TString("hmassNP"),nbins,xAxis1));
hM.addHist(new TH1F(TString("hmassPP"),TString("hmassPP"),nbins,xAxis1));
hM.addHist(new TH1F(TString("hmassNN"),TString("hmassNN"),nbins,xAxis1));
hM.addHist(new TH1F(TString("hoAngleNP"),TString("hoAngleNP"),2000,0,200));
hM.addHist(new TH1F(TString("hoAnglePP"),TString("hoAnglePP"),2000,0,200));
hM.addHist(new TH1F(TString("hoAngleNN"),TString("hoAngleNN"),2000,0,200));
hM.addHist(new TH1F(TString("hyNP"),TString("hyNP"),100,0,2));
hM.addHist(new TH1F(TString("hyPP"),TString("hyPP"),100,0,2));
hM.addHist(new TH1F(TString("hyNN"),TString("hyNN"),100,0,2));
hM.addHist(new TH1F(TString("hptNP"),TString("hptNP"),100,0,1000));
hM.addHist(new TH1F(TString("hptPP"),TString("hptPP"),100,0,1000));
hM.addHist(new TH1F(TString("hptNN"),TString("hptNN"),100,0,1000));
hM.addHist(new TH2F(TString("hoAnglemassNP"),TString("hoAnglemassNP"),90,0,180,nbins,xAxis1));
hM.addHist(new TH2F(TString("hoAnglemassPP"),TString("hoAnglemassPP"),90,0,180,nbins,xAxis1));
hM.addHist(new TH2F(TString("hoAnglemassNN"),TString("hoAnglemassNN"),90,0,180,nbins,xAxis1));
hM.addHist(new TH2F(TString("hoAngleptNP"),TString("hoAngleptNP"),90,0,180,120,0,1200));
hM.addHist(new TH2F(TString("hoAngleptPP"),TString("hoAngleptPP"),90,0,180,120,0,1200));
hM.addHist(new TH2F(TString("hoAngleptNN"),TString("hoAngleptNN"),90,0,180,120,0,1200));
hM.addHist(new TH2F(TString("hmassptNP"),TString("hmassptNP"),nbins,xAxis1,120,0,1200));
hM.addHist(new TH2F(TString("hmassptPP"),TString("hmassptPP"),nbins,xAxis1,120,0,1200));
hM.addHist(new TH2F(TString("hmassptNN"),TString("hmassptNN"),nbins,xAxis1,120,0,1200));
hM.addHist(new TH2F(TString("hoAngleyNP"),TString("hoAngleyNP"),90,0,180,100,0,2));
hM.addHist(new TH2F(TString("hoAngleyPP"),TString("hoAngleyPP"),90,0,180,100,0,2));
hM.addHist(new TH2F(TString("hoAngleyNN"),TString("hoAngleyNN"),90,0,180,100,0,2));
hM.addHist(new TH2F(TString("hmassyNP"),TString("hmassyNP"),nbins,xAxis1,100,0,2));
hM.addHist(new TH2F(TString("hmassyPP"),TString("hmassyPP"),nbins,xAxis1,100,0,2));
hM.addHist(new TH2F(TString("hmassyNN"),TString("hmassyNN"),nbins,xAxis1,100,0,2));
hM.addHist(new TH2F(TString("hptyNP"),TString("hptyNP"),120,0,1200,100,0,2));
hM.addHist(new TH2F(TString("hptyPP"),TString("hptyPP"),120,0,1200,100,0,2));
hM.addHist(new TH2F(TString("hptyNN"),TString("hptyNN"),120,0,1200,100,0,2));
hM.addHist(new TH2F(TString("hth1th2NP"),TString("hth1th2NP"),90,0,90,90,0,90));
hM.addHist(new TH2F(TString("hth1th2PP"),TString("hth1th2PP"),90,0,90,90,0,90));
hM.addHist(new TH2F(TString("hth1th2NN"),TString("hth1th2NN"),90,0,90,90,0,90));
hM.addHist(new TH2F(TString("hp1p2NP"),TString("hp1p2NP"),100,0,1100,100,0,1100));
hM.addHist(new TH2F(TString("hp1p2PP"),TString("hp1p2PP"),100,0,1100,100,0,1100));
hM.addHist(new TH2F(TString("hp1p2NN"),TString("hp1p2NN"),100,0,1100,100,0,1100));
for (int i = 0; i < 5; ++i) {
hM.addHist(new TH1F(TString("hmassNP_eff_multbin")+TString::Itoa(i,10),TString("hmassNP_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1));
hM.addHist(new TH1F(TString("hmassPP_eff_multbin")+TString::Itoa(i,10),TString("hmassPP_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1));
hM.addHist(new TH1F(TString("hmassNN_eff_multbin")+TString::Itoa(i,10),TString("hmassNN_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1));
hM.addHist(new TH1F(TString("hoAngleNP_eff_multbin")+TString::Itoa(i,10),TString("hoAngleNP_eff_multbin")+TString::Itoa(i,10),2000,0,200));
hM.addHist(new TH1F(TString("hoAnglePP_eff_multbin")+TString::Itoa(i,10),TString("hoAnglePP_eff_multbin")+TString::Itoa(i,10),2000,0,200));
hM.addHist(new TH1F(TString("hoAngleNN_eff_multbin")+TString::Itoa(i,10),TString("hoAngleNN_eff_multbin")+TString::Itoa(i,10),2000,0,200));
hM.addHist(new TH1F(TString("hyNP_eff_multbin")+TString::Itoa(i,10),TString("hyNP_eff_multbin")+TString::Itoa(i,10),100,0,2));
hM.addHist(new TH1F(TString("hyPP_eff_multbin")+TString::Itoa(i,10),TString("hyPP_eff_multbin")+TString::Itoa(i,10),100,0,2));
hM.addHist(new TH1F(TString("hyNN_eff_multbin")+TString::Itoa(i,10),TString("hyNN_eff_multbin")+TString::Itoa(i,10),100,0,2));
hM.addHist(new TH1F(TString("hptNP_eff_multbin")+TString::Itoa(i,10),TString("hptNP_eff_multbin")+TString::Itoa(i,10),100,0,1000));
hM.addHist(new TH1F(TString("hptPP_eff_multbin")+TString::Itoa(i,10),TString("hptPP_eff_multbin")+TString::Itoa(i,10),100,0,1000));
hM.addHist(new TH1F(TString("hptNN_eff_multbin")+TString::Itoa(i,10),TString("hptNN_eff_multbin")+TString::Itoa(i,10),100,0,1000));
hM.addHist(new TH2F(TString("hoAnglemassNP_eff_multbin")+TString::Itoa(i,10),TString("hoAnglemassNP_eff_multbin")+TString::Itoa(i,10),90,0,180,nbins,xAxis1));
hM.addHist(new TH2F(TString("hoAnglemassPP_eff_multbin")+TString::Itoa(i,10),TString("hoAnglemassPP_eff_multbin")+TString::Itoa(i,10),90,0,180,nbins,xAxis1));
hM.addHist(new TH2F(TString("hoAnglemassNN_eff_multbin")+TString::Itoa(i,10),TString("hoAnglemassNN_eff_multbin")+TString::Itoa(i,10),90,0,180,nbins,xAxis1));
hM.addHist(new TH2F(TString("hoAngleptNP_eff_multbin")+TString::Itoa(i,10),TString("hoAngleptNP_eff_multbin")+TString::Itoa(i,10),90,0,180,120,0,1200));
hM.addHist(new TH2F(TString("hoAngleptPP_eff_multbin")+TString::Itoa(i,10),TString("hoAngleptPP_eff_multbin")+TString::Itoa(i,10),90,0,180,120,0,1200));
hM.addHist(new TH2F(TString("hoAngleptNN_eff_multbin")+TString::Itoa(i,10),TString("hoAngleptNN_eff_multbin")+TString::Itoa(i,10),90,0,180,120,0,1200));
hM.addHist(new TH2F(TString("hmassptNP_eff_multbin")+TString::Itoa(i,10),TString("hmassptNP_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1,120,0,1200));
hM.addHist(new TH2F(TString("hmassptPP_eff_multbin")+TString::Itoa(i,10),TString("hmassptPP_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1,120,0,1200));
hM.addHist(new TH2F(TString("hmassptNN_eff_multbin")+TString::Itoa(i,10),TString("hmassptNN_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1,120,0,1200));
hM.addHist(new TH2F(TString("hoAngleyNP_eff_multbin")+TString::Itoa(i,10),TString("hoAngleyNP_eff_multbin")+TString::Itoa(i,10),90,0,180,100,0,2));
hM.addHist(new TH2F(TString("hoAngleyPP_eff_multbin")+TString::Itoa(i,10),TString("hoAngleyPP_eff_multbin")+TString::Itoa(i,10),90,0,180,100,0,2));
hM.addHist(new TH2F(TString("hoAngleyNN_eff_multbin")+TString::Itoa(i,10),TString("hoAngleyNN_eff_multbin")+TString::Itoa(i,10),90,0,180,100,0,2));
hM.addHist(new TH2F(TString("hmassyNP_eff_multbin")+TString::Itoa(i,10),TString("hmassyNP_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1,100,0,2));
hM.addHist(new TH2F(TString("hmassyPP_eff_multbin")+TString::Itoa(i,10),TString("hmassyPP_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1,100,0,2));
hM.addHist(new TH2F(TString("hmassyNN_eff_multbin")+TString::Itoa(i,10),TString("hmassyNN_eff_multbin")+TString::Itoa(i,10),nbins,xAxis1,100,0,2));
hM.addHist(new TH2F(TString("hptyNP_eff_multbin")+TString::Itoa(i,10),TString("hptyNP_eff_multbin")+TString::Itoa(i,10),120,0,1200,100,0,2));
hM.addHist(new TH2F(TString("hptyPP_eff_multbin")+TString::Itoa(i,10),TString("hptyPP_eff_multbin")+TString::Itoa(i,10),120,0,1200,100,0,2));
hM.addHist(new TH2F(TString("hptyNN_eff_multbin")+TString::Itoa(i,10),TString("hptyNN_eff_multbin")+TString::Itoa(i,10),120,0,1200,100,0,2));
hM.addHist(new TH2F(TString("hth1th2NP_eff_multbin")+TString::Itoa(i,10),TString("hth1th2NP_eff_multbin")+TString::Itoa(i,10),90,0,90,90,0,90));
hM.addHist(new TH2F(TString("hth1th2PP_eff_multbin")+TString::Itoa(i,10),TString("hth1th2PP_eff_multbin")+TString::Itoa(i,10),90,0,90,90,0,90));
hM.addHist(new TH2F(TString("hth1th2NN_eff_multbin")+TString::Itoa(i,10),TString("hth1th2NN_eff_multbin")+TString::Itoa(i,10),90,0,90,90,0,90));
hM.addHist(new TH2F(TString("hp1p2NP_eff_multbin")+TString::Itoa(i,10),TString("hp1p2NP_eff_multbin")+TString::Itoa(i,10),100,0,1100,100,0,1100));
hM.addHist(new TH2F(TString("hp1p2PP_eff_multbin")+TString::Itoa(i,10),TString("hp1p2PP_eff_multbin")+TString::Itoa(i,10),100,0,1100,100,0,1100));
hM.addHist(new TH2F(TString("hp1p2NN_eff_multbin")+TString::Itoa(i,10),TString("hp1p2NN_eff_multbin")+TString::Itoa(i,10),100,0,1100,100,0,1100));
}
//--------------- end histo booking -----------------------------------------------------
HGenericEventMixer<HGeantKine> eventmixer;
eventmixer.setPIDs(2,3,1);
eventmixer.setBuffSize(80);
//eventmixer.setBuffSize(2);
HGenericEventMixer<HGeantKine> eventmixer_eff[5];
for (int mb = 0; mb < 5; ++mb) {
eventmixer_eff[mb].setPIDs(2,3,1);
eventmixer_eff[mb].setBuffSize(80);
//eventmixer_eff[mb].setBuffSize(2);
}
TStopwatch timer;
timer.Reset();
timer.Start();
Float_t impB = -1.;
Float_t impB_bins[] = {9.3, 8.1, 6.6, 4.7, 0.};
Int_t evtsInFile = loop->getEntries();
if(nev < 0 || nev > evtsInFile ) nev = evtsInFile;
for(Int_t i = 1; i < nev; i++)
{
//----------break if last event is reached-------------
//if(!gHades->eventLoop(1)) break;
if(loop->nextEvent(i) <= 0) { cout<<" end recieved "<<endl; break; } // last event reached
HTool::printProgress(i,nev,1,"Analyze :");
loop->getSectors(sectors);
HPartialEvent *fSimul = ((HRecEvent*)gHades->getCurrentEvent())->getPartialEvent(catSimul);
HGeantHeader *fSubHeader = (HGeantHeader*)(fSimul->getSubHeader());
impB = fSubHeader->getImpactParameter();
Int_t multbin = 0;
if (impB >= impB_bins[4] && impB <= impB_bins[3]) {multbin=1;} // most central
if (impB > impB_bins[3] && impB <= impB_bins[2]) {multbin=2;}
if (impB > impB_bins[2] && impB <= impB_bins[1]) {multbin=3;}
if (impB > impB_bins[1] && impB <= impB_bins[0]) {multbin=4;} // most peripheral
if (impB > impB_bins[0]) {multbin=5;}
/*
HParticleEvtInfo* evtinfo;
evtinfo = HCategoryManager::getObject(evtinfo,catParticleEvtInfo,0);
Int_t multbin = 0;
Int_t mult_meta = evtinfo->getSumTofMultCut() + evtinfo->getSumRpcMultHitCut();
if (mult_meta > 60 && mult_meta <= 88) multbin = 4; // most peripheral
if (mult_meta > 88 && mult_meta <= 121) multbin = 3;
if (mult_meta > 121 && mult_meta <= 160) multbin = 2;
if (mult_meta > 160 && mult_meta <= 250) multbin = 1; // most central
if (mult_meta > 250) multbin = 5;
*/
if (multbin == 0 || multbin == 5) continue;
Int_t size = kineCat->getEntries();
// Additional loop to fill vector
vector<HGeantKine *> vep;
vector<HGeantKine *> vem;
vector<HGeantKine *> vep_eff;
vector<HGeantKine *> vem_eff;
vector<HGeantKine *> vep_eff_multbin;
vector<HGeantKine *> vem_eff_multbin;
for(Int_t j = 0; j < size; j ++){
kine1 = HCategoryManager::getObject(kine1,kineCat,j);
Float_t vx,vy,vz;
kine1->getVertex(vx,vy,vz);
Float_t vr = TMath::Sqrt(vx*vx+vy*vy);
if (vz < -60 || vz > 0) continue;
if (vr > 2) continue;
Int_t mamaNum = kine1->getParentTrack();
if (kine1->isInAcceptance()) {
if (kine1->getTotalMomentum() > 100 && kine1->getTotalMomentum() < 1000) {
Float_t px,py,pz;
kine1->getMomentum(px,py,pz);
TH2F *smear_matr;
if (kine1->getID() == 2) {
smear_matr = smear_pos;
} else {
smear_matr = smear_ele;
}
Float_t mom_ideal = kine1->getTotalMomentum();
Float_t mom_reco = smear(mom_ideal,smear_matr,random);
Float_t reco_over_ideal = mom_reco / mom_ideal;
kine1->setMomentum(px*reco_over_ideal,py*reco_over_ideal,pz*reco_over_ideal);
TLorentzVector vec;
HParticleTool::getTLorentzVector(kine1,vec,kine1->getID());
Float_t mom = vec.Vect().Mag();
Float_t the = vec.Theta()*TMath::RadToDeg();
Float_t phi = (vec.Phi()+TMath::Pi())*TMath::RadToDeg();
Float_t chg = (kine1->getID() == 2) ? 1 : -1;
if (kine1->getID() == 3) {
vem.push_back(new HGeantKine(*kine1));
}
if (kine1->getID() == 2) {
vep.push_back(new HGeantKine(*kine1));
}
Float_t eff = 1./getEfficiencyFactor(p3DEffEle[0][6],p3DEffPos[0][6],mom_ideal,the,phi,chg,false,false); // don't debug, don't check min value
if (isinf(eff) || isnan(eff)) eff = 0.;
if (random.Uniform(1) > eff) {
if (kine1->getID() == 3) {
vem_eff.push_back(new HGeantKine(*kine1));
}
if (kine1->getID() == 2) {
vep_eff.push_back(new HGeantKine(*kine1));
}
}
Float_t eff_multbin = 1./getEfficiencyFactor(p3DEffEle[multbin][6],p3DEffPos[multbin][6],mom,the,phi,chg,false,false);
if (isinf(eff_multbin) || isnan(eff_multbin)) eff_multbin = 0.;
if (random.Uniform(1) > eff_multbin) {
if (kine1->getID() == 3) {
vem_eff_multbin.push_back(new HGeantKine(*kine1));
}
if (kine1->getID() == 2) {
vep_eff_multbin.push_back(new HGeantKine(*kine1));
}
}
}
}
}
eventmixer.nextEvent();
eventmixer.addVector(vep,2);
eventmixer.addVector(vem,3);
vector<pair<HGeantKine *, HGeantKine* > >& pairsVec_acc = eventmixer.getMixedVector();
eventmixer_eff[0].nextEvent();
eventmixer_eff[0].addVector(vep_eff,2);
eventmixer_eff[0].addVector(vem_eff,3);
vector<pair<HGeantKine *, HGeantKine* > >& pairsVec_eff = eventmixer_eff[0].getMixedVector();
eventmixer_eff[multbin].nextEvent();
eventmixer_eff[multbin].addVector(vep_eff,2);
eventmixer_eff[multbin].addVector(vem_eff,3);
vector<pair<HGeantKine *, HGeantKine* > >& pairsVec_eff_multbin = eventmixer_eff[multbin].getMixedVector();
for (int imix = 0; imix < 3; ++imix) {
vector<pair<HGeantKine *, HGeantKine* > > pairsVec;
TString suffix;
switch (imix) {
case 0:
pairsVec = pairsVec_acc;
suffix = TString("");
break;
case 1:
pairsVec = pairsVec_eff;
suffix = TString("_eff_multbin0");
break;
case 2:
pairsVec = pairsVec_eff_multbin;
suffix = TString("_eff_multbin")+TString::Itoa(multbin,10);
break;
}
size = pairsVec.size();
for (Int_t j = 0; j < size; j ++) {
pair<HGeantKine*,HGeantKine*>& pair = pairsVec[j];
kine1 = pair.first;
kine2 = pair.second;
TLorentzVector vec1, vec2;
HParticleTool::getTLorentzVector(kine1,vec1,kine1->getID());
HParticleTool::getTLorentzVector(kine2,vec2,kine2->getID());
Float_t mom1 = vec1.Vect().Mag();
Float_t the1 = vec1.Theta()*TMath::RadToDeg();
Float_t mom2 = vec2.Vect().Mag();
Float_t the2 = vec2.Theta()*TMath::RadToDeg();
TLorentzVector dilep = vec1 + vec2;
Float_t oAngle = vec1.Angle(vec2.Vect())*TMath::RadToDeg();
Float_t mass = dilep.M()/1000;
Float_t pt = dilep.Perp();
Float_t y = dilep.Rapidity();
Float_t mbinw = hM.get("hmassNP")->GetBinWidth(hM.get("hmassNP")->FindBin(mass));
if (oAngle < 9) continue;
TString chg = "NP";
if (kine1->getID() == kine2->getID()) {
if (kine1->getID() == 2) chg = "PP";
if (kine1->getID() == 3) chg = "NN";
}
hM.get( TString("hmass") +chg+suffix)->Fill(mass, 1./mbinw);
hM.get( TString("hoAngle") +chg+suffix)->Fill(oAngle );
hM.get( TString("hy") +chg+suffix)->Fill(y );
hM.get( TString("hpt") +chg+suffix)->Fill(pt );
hM.get2(TString("hoAnglemass")+chg+suffix)->Fill(oAngle,mass,1./mbinw);
hM.get2(TString("hoAnglept") +chg+suffix)->Fill(oAngle,pt );
hM.get2(TString("hmasspt") +chg+suffix)->Fill(mass,pt, 1./mbinw);
hM.get2(TString("hoAngley") +chg+suffix)->Fill(oAngle,y );
hM.get2(TString("hmassy") +chg+suffix)->Fill(mass,y, 1./mbinw);
hM.get2(TString("hpty") +chg+suffix)->Fill(pt,y );
hM.get2(TString("hth1th2") +chg+suffix)->Fill(the1,the2 );
hM.get2(TString("hp1p2") +chg+suffix)->Fill(mom1,mom2 );
}
}
//#define DELETE_MIX
#ifdef DELETE_MIX
vector <HGeantKine *>* toDel = eventmixer.getObjectsToDelete();
for (unsigned int ii = 0; ii < toDel->size(); ++ii) {
delete toDel->at(ii);
}
toDel->clear();
delete toDel;
vector <HGeantKine *>* toDel_eff = eventmixer_eff[0].getObjectsToDelete();
for (unsigned int ii = 0; ii < toDel_eff->size(); ++ii) {
delete toDel_eff->at(ii);
}
toDel_eff->clear();
delete toDel_eff;
vector <HGeantKine *>* toDel_eff_multbin = eventmixer_eff[multbin].getObjectsToDelete();
for (unsigned int ii = 0; ii < toDel_eff_multbin->size(); ++ii) {
delete toDel_eff_multbin->at(ii);
}
toDel_eff_multbin->clear();
delete toDel_eff_multbin;
#endif
} // end event loop
timer.Stop();
hM.getFile()->cd();
TMacro m1(__DIELEANA_FILE__);
m1.Write();
hM.writeHists("nomap");
cout<<"####################################################"<<endl;
return 0;
}
