TLorentzVector smearMom(TLorentzVector const& b,TF1 const * const fMomResolution)
{
float const pt = b.Perp();
float const sPt = gRandom->Gaus(pt,pt*fMomResolution->Eval(pt));
TLorentzVector sMom;
sMom.SetXYZM(sPt*cos(b.Phi()),sPt*sin(b.Phi()),sPt*sinh(b.PseudoRapidity()),b.M());
return sMom;
}
double PTCut::HistResp(TLorentzVector tmpP, double respHCAL, double respECAL,
double respEHHCAL, double respEHECAL)
{
double respSum = 0;
// In case of inconsistensies in binning, the bins are checked explicitely
int binHadrf = 0;
int binEcalf = 0;
double trueFracECAL = 0;
double fE = 0;
// H: all energy in HCAL; this is multiplied with HCAL response
binHadrf = pfh->FindBin(tmpP.Perp());
respSum += (pfh->GetBinContent(binHadrf))*respHCAL;
// E: energy only in ECAL, fraction multiplied with ECAL response
binHadrf = pfe->FindBin(tmpP.Perp());
respSum += (pfe->GetBinContent(binHadrf))*respECAL;
// pf0: nothing is added for the lost hadrons, effectively:
// respSum += (pf0->GetBinContent(binHadrf))*0;
// eH: energy in both ECAL and HCAL, mostly HCAL. Does not work
// intuitively (compared to EH). First, approximate H by HCAL
// resp. times tot energy - 0.3 GeV. Move 0.3 GeV to ECAL and
// use response for this.
binHadrf = pfe0h->FindBin(tmpP.Perp());
respSum += (pfe0h->GetBinContent(binHadrf))*( 0.3*(respECAL-1)
+ respHCAL );
// EH: energy in both ECAL and HCAL
binHadrf = pfe1h->FindBin(tmpP.Perp());
binEcalf = pef1->FindBin(tmpP.Perp());
fE = pef1->GetBinContent(binEcalf);
trueFracECAL = fE/((1-fE)*respEHECAL/respEHHCAL+1);
respSum += (pfe1h->GetBinContent(binHadrf))*(trueFracECAL*respEHECAL
+(1-trueFracECAL)*respEHHCAL);
return respSum;
}
void AnalyseParticles(LHEF::Reader *reader, ExRootTreeBranch *branch)
{
const LHEF::HEPEUP &hepeup = reader->hepeup;
Int_t particle;
Double_t signPz, cosTheta;
TLorentzVector momentum;
TRootLHEFParticle *element;
for(particle = 0; particle < hepeup.NUP; ++particle)
{
element = (TRootLHEFParticle*) branch->NewEntry();
element->PID = hepeup.IDUP[particle];
element->Status = hepeup.ISTUP[particle];
element->Mother1 = hepeup.MOTHUP[particle].first;
element->Mother2 = hepeup.MOTHUP[particle].second;
element->ColorLine1 = hepeup.ICOLUP[particle].first;
element->ColorLine2 = hepeup.ICOLUP[particle].second;
element->Px = hepeup.PUP[particle][0];
element->Py = hepeup.PUP[particle][1];
element->Pz = hepeup.PUP[particle][2];
element->E = hepeup.PUP[particle][3];
element->M = hepeup.PUP[particle][4];
momentum.SetPxPyPzE(element->Px, element->Py, element->Pz, element->E);
cosTheta = TMath::Abs(momentum.CosTheta());
signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
element->PT = momentum.Perp();
element->Eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
element->Phi = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
element->Rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
element->LifeTime = hepeup.VTIMUP[particle];
element->Spin = hepeup.SPINUP[particle];
}
}
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 plots() {
gSystem->Load("libEVGEN"); // Needs to be!
AliRunLoader* rl = AliRunLoader::Open("galice.root");
rl->LoadKinematics();
rl->LoadHeader();
// 4pi histograms
TH1* hM = new TH1D("hM", "DIME #rho#rho;M_{4#pi} #(){GeV/#it{c}^{2}}", 100, 1.0, 3.0);
TH1* hPt = new TH1D("hPt", "DIME #rho#rho;p_{T}#(){4#pi} #(){GeV/#it{c}}", 100, 0.0, 3.0);
// pi+- histograms
TH1* hPt1 = new TH1D("hPt1", "DIME #rho#rho;p_{T}#(){#pi^{#pm}} #(){Gev/#it{c}}", 100, 0.0, 3.0);
AliStack* stack = NULL;
TParticle* part = NULL;
TLorentzVector v[4];
TLorentzVector vSum;
// Loop over events
for (Int_t i = 0; i < rl->GetNumberOfEvents(); ++i) {
rl->GetEvent(i);
stack = rl->Stack();
Int_t nPrimary = 0;
// Loop over all particles
for (Int_t j = 0; j < stack->GetNtrack(); ++j) {
part = stack->Particle(j); // Get particle
part->Print(); // Print contents
if (abs(part->GetPdgCode()) == 211 // Is pi+ or pi-
& part->GetStatusCode() == 1 // Is stable final state
& stack->IsPhysicalPrimary(j)) { // Is from generator level
part->Momentum(v[nPrimary]); // Set content of v
++nPrimary;
}
}
if (nPrimary != 4) {
printf("Error: nPrimary=%d != 4 \n", nPrimary);
continue;
}
// 4-vector sum
vSum = v[0] + v[1] + v[2] + v[3];
// Fill 4pi histograms
hM->Fill(vSum.M());
hPt->Fill(vSum.Perp());
// Fill pi+- histograms
for (Int_t k = 0; k < 4; ++k) {
hPt1->Fill(v[k].Perp());
}
printf("\n");
}
// Save plots as pdf
hM->Draw(); c1->SaveAs("plotM.pdf");
hPt->Draw(); c1->SaveAs("plotPt.pdf");
hPt1->Draw(); c1->SaveAs("plotPt1.pdf");
}
void fill(int const kf, TLorentzVector* b, double const weight, TClonesArray& daughters)
{
TLorentzVector kMom;
TLorentzVector p1Mom;
TLorentzVector p2Mom;
int nTrk = daughters.GetEntriesFast();
for (int iTrk = 0; iTrk < nTrk; ++iTrk)
{
TParticle* ptl0 = (TParticle*)daughters.At(iTrk);
switch(abs(ptl0->GetPdgCode()))
{
case 321:
ptl0->Momentum(kMom);
break;
case 211:
if(!p1Mom.P()) ptl0->Momentum(p1Mom);
else ptl0->Momentum(p2Mom);
break;
default:
break;
}
}
daughters.Clear();
// smear and get total momentum
TLorentzVector kRMom = smearMom(kMom,fKaonMomResolution);
TLorentzVector p1RMom = smearMom(p1Mom,fPionMomResolution);
TLorentzVector p2RMom = smearMom(p2Mom,fPionMomResolution);
TLorentzVector rMom = kRMom + p1RMom + p2RMom;
// save
float arr[100];
int iArr = 0;
arr[iArr++] = kf;
arr[iArr++] = weight;
arr[iArr++] = b->M();
arr[iArr++] = b->Perp();
arr[iArr++] = b->PseudoRapidity();
arr[iArr++] = b->Rapidity();
arr[iArr++] = b->Phi();
arr[iArr++] = rMom.M();
arr[iArr++] = rMom.Perp();
arr[iArr++] = rMom.PseudoRapidity();
arr[iArr++] = rMom.Rapidity();
arr[iArr++] = rMom.Phi();
arr[iArr++] = kMom.M();
arr[iArr++] = kMom.Perp();
arr[iArr++] = kMom.PseudoRapidity();
arr[iArr++] = kMom.Rapidity();
arr[iArr++] = kMom.Phi();
arr[iArr++] = kRMom.M();
arr[iArr++] = kRMom.Perp();
arr[iArr++] = kRMom.PseudoRapidity();
arr[iArr++] = kRMom.Rapidity();
arr[iArr++] = kRMom.Phi();
arr[iArr++] = p1Mom.M();
arr[iArr++] = p1Mom.Perp();
arr[iArr++] = p1Mom.PseudoRapidity();
arr[iArr++] = p1Mom.Rapidity();
arr[iArr++] = p1Mom.Phi();
arr[iArr++] = p1RMom.M();
arr[iArr++] = p1RMom.Perp();
arr[iArr++] = p1RMom.PseudoRapidity();
arr[iArr++] = p1RMom.Rapidity();
arr[iArr++] = p1RMom.Phi();
arr[iArr++] = p2Mom.M();
arr[iArr++] = p2Mom.Perp();
arr[iArr++] = p2Mom.PseudoRapidity();
arr[iArr++] = p2Mom.Rapidity();
arr[iArr++] = p2Mom.Phi();
arr[iArr++] = p2RMom.M();
arr[iArr++] = p2RMom.Perp();
arr[iArr++] = p2RMom.PseudoRapidity();
arr[iArr++] = p2RMom.Rapidity();
arr[iArr++] = p2RMom.Phi();
nt->Fill(arr);
}
inline float kinematics::QT( TLorentzVector* pa, TLorentzVector* pb )
{
TLorentzVector pTmp = (*pa)+(*pb);
return pTmp.Perp();
}
void testsl() {
gSystem->Load("libStarLight");
gSystem->Load("libAliStarLight");
TStarLight* sl = new TStarLight("starlight generator", "title", "");
sl->SetParameter("baseFileName = slight #suite of output files will be saved with this base name");
sl->SetParameter("BEAM_1_Z = 82 #Z of projectile");
sl->SetParameter("BEAM_1_A = 208 #A of projectile");
sl->SetParameter("BEAM_2_Z = 82 #Z of target");
sl->SetParameter("BEAM_2_A = 208 #A of target");
sl->SetParameter("BEAM_1_GAMMA = 1470.0 #Gamma of the colliding ion 1");
sl->SetParameter("BEAM_2_GAMMA = 1470.0 #Gamma of the colliding ion 2");
sl->SetParameter("W_MAX = -1 #Max value of w");
sl->SetParameter("W_MIN = -1 #Min value of w");
sl->SetParameter("W_N_BINS = 50 #Bins i w");
sl->SetParameter("RAP_MAX = 9. #max y");
sl->SetParameter("RAP_N_BINS = 200 #Bins i y");
sl->SetParameter("CUT_PT = 0 #Cut in pT? 0 = (no, 1 = yes)");
sl->SetParameter("PT_MIN = 1.0 #Minimum pT in GeV");
sl->SetParameter("PT_MAX = 3.0 #Maximum pT in GeV");
sl->SetParameter("CUT_ETA = 0 #Cut in pseudorapidity? (0 = no, 1 = yes)");
sl->SetParameter("ETA_MIN = -10 #Minimum pseudorapidity");
sl->SetParameter("ETA_MAX = 10 #Maximum pseudorapidity");
sl->SetParameter("PROD_MODE = 2 #gg or gP switch (1 = 2-photon, 2 = coherent vector meson (narrow), 3 = coherent vector meson (wide), 4 = incoherent vector meson)");
sl->SetParameter("N_EVENTS = 1000 #Number of events");
sl->SetParameter("PROD_PID = 443013 #Channel of interest; this is j/psi --> mu+ mu-");
sl->SetParameter("RND_SEED = 5574533 #Random number seed");
sl->SetParameter("BREAKUP_MODE = 5 #Controls the nuclear breakup; a 5 here makes no requirement on the breakup of the ions");
sl->SetParameter("INTERFERENCE = 0 #Interference (0 = off, 1 = on)");
sl->SetParameter("IF_STRENGTH = 1. #percent of intefernce (0.0 - 0.1)");
sl->SetParameter("INT_PT_MAX = 0.24 #Maximum pt considered, when interference is turned on");
sl->SetParameter("INT_PT_N_BINS =120 #Number of pt bins when interference is turned on");
sl->SetParameter("XSEC_METHOD = 1 # Set to 0 to use old method for calculating gamma-gamma luminosity");
sl->SetParameter("PYTHIA_FULL_EVENTRECORD = 0 # Write full pythia information to output (vertex, parents, daughter etc).");
sl->InitStarLight();
sl->PrintInputs(std::cout);
TClonesArray tca("TParticle", 100);
TLorentzVector v[2], vSum;
TH1* hM = new TH1D("hM", "STARLIGHT;M#(){#pi^{+}#pi^{-}}", 200, 3.0, 3.2);
TH1* hPt = new TH1D("hPt", "STARLIGHT;P_{T}#(){#pi^{+}#pi^{-}}", 80, 0., 2.);
TH1* hY = new TH1D("hY", "STARLIGHT;Y#(){#pi^{+}#pi^{-}}", 100,-10., 10.);
std::ofstream ofs("sl.txt");
TParticle *p;
for (Int_t counter(0); counter<20000; ) {
sl->GenerateEvent();
sl->BoostEvent();
sl->ImportParticles(&tca, "ALL");
Bool_t genOK = kTRUE;
TLorentzVector vSum;
for (Int_t i=0; i<tca.GetEntries() && genOK; ++i) {
p = (TParticle*)tca.At(i);
p->Momentum(v[i]);
vSum += v[i];
// genOK = TMath::Abs(v[i].Rapidity()) <= 1.5;
}
tca.Clear();
if (!genOK) continue;
Printf("%5d %d", counter, genOK);
++counter;
vSum = v[0] + v[1];
ofs << std::fixed << std::setprecision(4)
<< vSum.M() << " " << vSum.Perp() << " " << vSum.Rapidity() << " "
<< v[0].Eta() << " " << v[0].Px() << " " << v[0].Py() << " " << v[0].Pz() << " "
<< v[1].Eta() << " " << v[1].Px() << " " << v[1].Py() << " " << v[1].Pz()
<< std::endl;
hM->Fill(vSum.M());
hPt->Fill(vSum.Perp());
hY->Fill(vSum.Rapidity());
}
TFile::Open("sl.root", "RECREATE");
sl->Write();
gFile->Write();
hM->Draw();
c1->SaveAs("SL.pdf(");
hPt->Draw();
c1->SaveAs("SL.pdf");
hY->Draw();
c1->SaveAs("SL.pdf)");
}
bool operator () (const TLorentzVector & x, const TLorentzVector & y)
{
return (x.Perp () < y.Perp () ) ;
}
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;
}