//Particles mixer. Careful, magic is done here...
int main(int argc, char **argv)
{
if(argc < 2)
{
cout << "Usage: mixer0 <filenumber>" << endl;
return -1;
}
UInt_t filenumber = atoi(argv[1]);
TString filename = "ParticleTree";
TString outputfile = "MixedParticleTree";
filename += filenumber;
outputfile += filenumber;
filename += ".root";
outputfile += ".root";
TFile *input_root_file = new TFile(filename);
TTree* input_tree = (TTree*)input_root_file->Get("events");
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long64_t ev;
UInt_t part;
UInt_t Npart;
vector<UInt_t> events_vect;
vector<UInt_t> particles_vect;
vector<UInt_t> mult_vect;
map<UInt_t,unsigned> events_map;
TRandom2 randgen(time(NULL));
for(ev=0; ev<treeNentries; ++ev)
{
input_tree->GetEntry(ev);
events_map.insert(pair<UInt_t,unsigned>(event->GetEid(),ev));
Npart = event->GetNpa();
mult_vect.push_back(Npart);
for(part = 0; part<Npart; ++part)
{
particle = event->GetParticle(part);
events_vect.push_back(event->GetEid());
particles_vect.push_back(particle->GetPid());
}
if(!(ev%50000))
cout << "Event: " << ev << endl;
}
cout << "ParticleTree loaded. " << treeNentries << " events (" << ev << ")" << endl;
cout << "First EID: " << events_vect[0] << " | Last EID: " << events_vect[events_vect.size()-1] << endl;
const UInt_t firstPID = particles_vect[0];
const UInt_t lastPID = particles_vect[particles_vect.size()-1];
UInt_t list_size = lastPID - firstPID;
cout << "First PID: " << firstPID << " | last PID: " << lastPID << " | size: " << list_size << endl;
ParticleTree output_tree(outputfile);
set<int> unique_events_set;
unsigned control=0;
int rand_evid, rand_part;
unsigned int Nentries = events_map.size();
unsigned long switch_counter=0,
switch_limit = Nentries*Nentries;
bool event_cancelled = false;
//Magic starts here
for(ev = 0; ev<Nentries; ++ev)
{
unique_events_set.clear();
control = 0;
input_tree->GetEntry(ev);
output_tree.BeginEvent(event->GetEid());
switch_counter = 0;
event_cancelled = false;
for(int j=0; j<mult_vect[ev]; )
{
rand_part = randgen.Rndm()*particles_vect.size();
rand_evid = events_vect[rand_part];
unique_events_set.insert(rand_evid);
if(unique_events_set.size()>control)
{
input_tree->GetEntry(events_map[rand_evid]);
particle = event->GetParticle(particles_vect[rand_part] - event->GetFirstParticle());
output_tree.AddParticle(
particles_vect[rand_part], particle->GetCharge(), particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
events_vect.erase(events_vect.begin() + rand_part);
particles_vect.erase(particles_vect.begin() + rand_part);
++control;
j=j+1;
}
else
{
if(switch_counter > switch_limit)
{
event_cancelled = true;
break;
}
if(!(++switch_counter%Nentries))
cout << "Rejected. Event: " << ev << " | from old event: " << rand_evid << " ctr:" << switch_counter << "/" << switch_limit << endl;
continue;
}
}
//Magic ends here
if(event_cancelled)
output_tree.CancelEvent();
else
output_tree.EndEvent();
if(!(ev%500))
cout << ev << "/" << treeNentries << " multiplicity: "<< mult_vect[ev] << ", from diff. events: " << unique_events_set.size()<< endl;
}
cout << "Closing" << endl;
output_tree.Close();
input_root_file->Close();
return 0;
}
//pT cut. Default value is 1.5 GeV/c. Which means it takes everything between 0 and 1.5.
//For ptcut values lower than 0, the cut will take everything between abs(ptcut) and infinity.
void RunPtCut(TString inputfile, TString outputfile, const Float_t ptcut=1.5)
{
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
ParticleTree output_tree(outputfile);
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long_t particles_in = 0, particles_out = 0;
Long64_t ev;
UInt_t Npa;
UInt_t part;
Double_t pt;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%1000))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
output_tree.BeginEvent();
particles_in += Npa;
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
pt = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2));
if(ptcut >= 0)
{
if(pt > ptcut)
continue;
}
else if(ptcut < 0)
{
if(pt < TMath::Abs(ptcut))
continue;
}
++particles_out;
output_tree.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
output_tree.EndEvent();
}
output_tree.Close();
input_rootfile->Close();
cout << "pT cut summary\n------------" << endl
<< "Particles before cut: " << particles_in << endl
<< "Particles after cut: " << particles_out << endl
<< "Cutted particles: " << (particles_in-particles_out) << endl
<< "Ratio: " << ((Double_t)particles_out/particles_in) << endl;
}
//Particle Population Matrix cut
void RunPPMCut(TString inputfile, TString outputfile, TString system, TString energy)
{
cout << "Running particle population matrix mode" << endl;
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
ParticleTree output_tree(outputfile);
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long64_t ev;
UInt_t Npa;
UInt_t part;
UInt_t particles_in, particles_out;
//PPMCut class defined in PPMCut.h
PPMCut partpopmatrix("PartPopMatrix.root",system, energy);
float pt, p, angle;
particles_in = particles_out = 0;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%5000))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
output_tree.BeginEvent();
particles_in += Npa;
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
pt = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2));
p = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2)+TMath::Power(particle->GetPz(),2));
angle = TMath::ATan2(particle->GetPy(), particle->GetPx());
//The cut itself
if(partpopmatrix.PartPopMatrixCut(particle->GetCharge(),p,pt,angle))
{
output_tree.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
particles_out++;
}
}
output_tree.EndEvent();
}
output_tree.Close();
input_rootfile->Close();
cout << "Particle population matrix cut summary\n------------" << endl
<< "Particles before cut: " << particles_in << endl
<< "Particles after cut: " << particles_out << endl
<< "Cutted particles: " << (particles_in-particles_out) << endl
<< "Ratio: " << ((Double_t)particles_out/particles_in) << endl;
}
void RunElasticCut(TString inputfile, TString outputfile, Int_t energy)
{
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
ParticleTree output_tree(outputfile);
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long64_t ev;
Long_t particles_in = 0, particles_out = 0, events_out = 0;
UInt_t part, Npa;
Float_t p;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%500))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
//If, after cuts before, we left only with one positively charged particle with momentum close to beam momentum, I assume that it is a proton from beam which interacted elastically with target. I reject this proton and therefore whole event.
if(Npa == 1)
{
particle = event->GetParticle(0);
p = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2)+TMath::Power(particle->GetPz(),2));
if((particle->isPositive()) && (p > energy - 3))
{
particles_in++;
continue;
}
}
particles_in+=Npa;
events_out++;
output_tree.BeginEvent();
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
output_tree.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
output_tree.EndEvent();
particles_out+=Npa;
}
output_tree.Close();
input_rootfile->Close();
cout << "Elastic cut summary\n------------" << endl
<< "Events before cut: " << treeNentries << endl
<< "Events after cut: " << events_out << endl
<< "Cutted events: " << (treeNentries-events_out) << endl
<< "Ratio: " << ((Double_t)events_out/treeNentries) << "\n------------" << endl
<< "Particles before cut: " << particles_in << endl
<< "Particles after cut: " << particles_out << endl
<< "Cutted particles: " << (particles_in-particles_out) << endl
<< "Ratio: " << ((Double_t)particles_out/particles_in) << endl;
}
//dEdx cut based on parametrized curves defined in "is_electron" function
void RunDedxCut2(TString inputfile, TString outputfile)
{
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
ParticleTree output_tree(outputfile);
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long_t particles_in = 0, particles_out = 0;
Long64_t ev;
UInt_t Npa;
UInt_t part;
//Float_t dedx_uppercut = 3.;
float p;
//cout << "Cut dE/dx > " << dedx_uppercut << " applied" << endl;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%500))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
output_tree.BeginEvent();
particles_in += Npa;
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
p = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2)+TMath::Power(particle->GetPz(),2));
if(is_electron(TMath::Log10(p),particle->GetdEdx()))
continue;
++particles_out;
output_tree.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
output_tree.EndEvent();
}
output_tree.Close();
input_rootfile->Close();
cout << "dEdx cut summary\n------------" << endl
<< "Particles before cut: " << particles_in << endl
<< "Particles after cut: " << particles_out << endl
<< "Cutted particles: " << (particles_in-particles_out) << endl
<< "Ratio: " << ((Double_t)particles_out/particles_in) << endl;
}
//dEdx cut based on graphical cut defined in dEdxCut.cpp
void RunDedxCut(TString inputfile, TString outputfile, TString system, Int_t energy)
{
cout << "Running dE/dx mode with energy " << energy << endl;
TCutG* cutg = initialise_dedx_cutg(system, energy);
cout << "Graphcut intialized" << endl;
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
ParticleTree output_tree(outputfile);
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long64_t ev;
UInt_t Npa;
UInt_t part;
Float_t local_dedx;
Float_t dedx_uppercut = 3.;
if(!(system.CompareTo("PbPb")))
{
if((energy == 158 ) || (energy == 160))
dedx_uppercut = 1.65;
else if(energy == 20)
dedx_uppercut = 1.6;
}
float p;
cout << "Cut dE/dx > " << dedx_uppercut << " applied" << endl;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%500))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
output_tree.BeginEvent();
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
p = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2)+TMath::Power(particle->GetPz(),2));
local_dedx = choose_dedx(particle, system);
if(cutg->IsInside(p,local_dedx))
continue;
if(local_dedx > dedx_uppercut)
continue;
output_tree.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
output_tree.EndEvent();
}
output_tree.Close();
input_rootfile->Close();
}
//Multiplicity splitter to multiplicity bins analysis
void RunMultSplit(TString inputfile, TString outputfile, const TString mult_string)
{
cout << "Running multiplicity splitter (" << mult_string << ") mode" << endl;
const UInt_t multiplicity = atoi(mult_string);
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
//Three output files of all, positively and negatively charged particles
ParticleTree output_tree_all(outputfile + "_all.root");
ParticleTree output_tree_pos(outputfile + "_pos.root");
ParticleTree output_tree_neg(outputfile + "_neg.root");
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long64_t ev;
UInt_t Npa;
UInt_t Npos;
UInt_t Nneg;
UInt_t part;
UInt_t all_count = 0;
UInt_t pos_count = 0;
UInt_t neg_count = 0;
//cout << "Event\t\tAll\tPos\tNeg" << endl;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%10000))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
Npos = event->GetNpos();
Nneg = event->GetNneg();
if(Npa==multiplicity)
{
output_tree_all.BeginEvent();
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
output_tree_all.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
++all_count;
output_tree_all.EndEvent();
}
if(Npos==multiplicity)
{
output_tree_pos.BeginEvent();
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
if(!(particle->isPositive()))
continue;
output_tree_pos.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
++pos_count;
output_tree_pos.EndEvent();
}
if(Nneg==multiplicity)
{
output_tree_neg.BeginEvent();
for(part=0; part<Npa; part++)
{
particle = event->GetParticle(part);
if(particle->isPositive())
continue;
output_tree_neg.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
}
++neg_count;
output_tree_neg.EndEvent();
}
//cout << "\r" << ev << "\t\t" << all_count << "\t" << pos_count << "\t" << neg_count;
}
cout << "\nEvents\t\tAll\tPos\tNeg" << endl << ev << "\t\t" << all_count << "\t" << pos_count << "\t" << neg_count << endl;
output_tree_all.Close();
output_tree_pos.Close();
output_tree_neg.Close();
input_rootfile->Close();
}
void RunAccCut(const TString inputfile, const TString outputfile, const int momentum)
{
cout << "Running acceptance mode" << endl;
//Input ParticleTree file
TFile *input_rootfile = new TFile(inputfile);
TTree* input_tree = (TTree*)input_rootfile->Get("events");
//Output ParticleTree file
ParticleTree output_tree(outputfile);
Event *event = new Event();
Particle *particle;
input_tree->SetBranchAddress("event",&event);
const Long64_t treeNentries = input_tree->GetEntries();
Long64_t ev;
UInt_t Npa;
UInt_t part;
AccCut acc_map("acceptance-map.root",momentum);
float pt, E, p, y, angle;
const float pion_mass = 0.13957018; //GeV/c^2
const float nucleon_mass = 0.9389186795; //GeV/c^2
const float beta = momentum/(TMath::Sqrt(momentum*momentum+nucleon_mass*nucleon_mass)+nucleon_mass);
const float y_cms = 0.5*TMath::Log((1+beta)/(1-beta));
cout << "beta = " << beta << endl << "y_cms=" << y_cms << endl;
UInt_t particles_in = 0, particles_out = 0;
for(ev=0; ev<treeNentries; ++ev)
{
if(!(ev%5000))
cout << "Event: " << ev << endl;
input_tree->GetEntry(ev);
Npa = event->GetNpa();
output_tree.BeginEvent();
for(part=0; part<Npa; part++)
{
++particles_in;
particle = event->GetParticle(part);
pt = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2));
p = TMath::Sqrt(TMath::Power(particle->GetPx(),2)+TMath::Power(particle->GetPy(),2)+TMath::Power(particle->GetPz(),2));
E = TMath::Sqrt(pion_mass*pion_mass+p*p);
y = 0.5*TMath::Log((E+particle->GetPz())/(E-particle->GetPz())) - y_cms;
angle = TMath::ATan2(particle->GetPy(), particle->GetPx());
if(acc_map.acceptanceCut(particle->GetCharge(),y,angle,pt))
{
output_tree.AddParticle(particle->GetCharge(),
particle->GetBx(), particle->GetBy(),
particle->GetPx(), particle->GetPy(), particle->GetPz(),
particle->GetdEdx(), particle->GetdEdxVtpc1(), particle->GetdEdxVtpc2(), particle->GetdEdxMtpc(),
particle->GetNdEdx(), particle->GetNdEdxVtpc1(), particle->GetNdEdxVtpc2(), particle->GetNdEdxMtpc());
++particles_out;
}
}
output_tree.EndEvent();
}
output_tree.Close();
input_rootfile->Close();
cout << "Acceptance map cut summary\n------------" << endl
<< "Particles before cut: " << particles_in << endl
<< "Particles after cut: " << particles_out << endl
<< "Cutted particles: " << (particles_in-particles_out) << endl
<< "Ratio: " << ((Double_t)particles_out/particles_in) << endl;
}
