// analisi
Bool_t CheckSingle(const char* esdFileName,Bool_t kGRID){
//inizializzo a zero ncluster (di tree T)
//for (int ifc=0;ifc<10000;ifc++) ncluster[ifc]=0;
// check the content of the ESD
AliPIDResponse *pidr = new AliPIDResponse();
// open the ESD file
TFile* esdFile = TFile::Open(esdFileName);
if (!esdFile || !esdFile->IsOpen()){
Error("CheckESD", "opening ESD file %s failed", esdFileName);
return kFALSE;
}
TString mctrkref(esdFileName);
mctrkref.ReplaceAll("AliESDs.root","TrackRefs.root");
TString fgal(esdFileName);
fgal.ReplaceAll("AliESDs.root","galice.root");
if(kGRID){
fgal.Insert(0,"alien://");
mctrkref.Insert(0,"alien://");
}
TTree *trkref;
printf("ESD = %s\n",esdFileName);
TFile *ftrkref;
if(isMC) ftrkref = TFile::Open(mctrkref.Data());
AliHeader *h = new AliHeader();
TFile *fgalice;
if(isMC) fgalice = TFile::Open(fgal.Data());
TTree *tgalice;
if(isMC){
tgalice = (TTree *) fgalice->Get("TE");
tgalice->SetBranchAddress("Header",&h);
}
AliRunLoader* runLoader = NULL;
AliRun *gAlice;
if(isMC) runLoader = AliRunLoader::Open(fgal.Data());
if(runLoader){
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
Error("CheckESD", "no galice object found");
return kFALSE;
}
runLoader->LoadKinematics();
runLoader->LoadHeader();
}
AliESDEvent * esd = new AliESDEvent;
// printf("esd object = %x\n",esd);
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree){
Error("CheckESD", "no ESD tree found");
return kFALSE;
}
esd->ReadFromTree(tree); // crea link tra esd e tree
TClonesArray* tofcl; // array dinamico
TClonesArray* tofhit;
TClonesArray* tofmatch;
Int_t nev = tree->GetEntries(); //ogni entries evento
Float_t mag;
printf("nev = %i\n",nev);
//azzero il contatore delle tracce del TTree T
//ntracks=0;
AliStack* stack=NULL;
Int_t trkassociation[1000000];
for(Int_t ie=0;ie < nev;ie++){
if(runLoader){
runLoader->GetEvent(ie);
// select simulated primary particles, V0s and cascades
stack = runLoader->Stack();
}
if(isMC) trkref = (TTree *) ftrkref->Get(Form("Event%i/TreeTR",ie));
tree->GetEvent(ie);
if(isMC) tgalice->GetEvent(ie);
if(isMC) interactiontime = h->GenEventHeader()->InteractionTime()*1E+12;
mag = esd->GetMagneticField();
AliTOFHeader *tofh = esd->GetTOFHeader();
ntofcl = tofh->GetNumberOfTOFclusters();
esd->ConnectTracks(); // Deve essere sempre chiamato dopo aver letto l'evento (non troverebbe l'ESDevent). Scrivo in tutte le tracce l origine dell evento così poi da arrivare ovunque(tipo al cluster e al tempo quindi).
//Riempio variabile del tree "T"
//nevento=ie;
if(! esd->GetVertex()){
esd->ResetStdContent();
continue;// una volta fatto il connect manda un flag ; siccome qua c'era un continue(non si arriva in fondo al ciclo) bisogna resettarlo altrimenti lo trova già attivo.
}
tofcl = esd->GetESDTOFClusters(); // AliESDTOFCluster *cltof = tofcl->At(i);
if(tofcl->GetEntries() == 0){
esd->ResetStdContent();
continue;
}
tofhit = esd->GetESDTOFHits(); // AliESDTOFHit *hittof = tofhit->At(i);
tofmatch = esd->GetESDTOFMatches(); // AliESDTOFHit *mathctof = tofmatch->At(i);
// loop over tracks
pidr->SetTOFResponse(esd,AliPIDResponse::kTOF_T0); //per recuperare lo start time ("esd", "tipo start time"), tipo cioè o il TOF stesso o il T0 o il best, ovvero la combinazione dei 2
Int_t ntrk = esd->GetNumberOfTracks();
//printf("%i) TPC tracks = %i -- TOF cluster = %i - TOF hit = %i -- matchable info = %i\n",ie,ntrk,tofcl->GetEntries(),tofhit->GetEntries(),tofmatch->GetEntries());
Double_t time[AliPID::kSPECIESC];
if(isMC && stack){// create association trackref
printf("nMC track = %i\n",stack->GetNtrack());
for(Int_t ist=0;ist < stack->GetNtrack();ist++){
trkassociation[ist]=-1;
}
for(Int_t iref=0;iref < trkref->GetEntries();iref++){
trkref->GetEvent(iref);
Int_t trkreference = trkref->GetLeaf("TrackReferences.fTrack")->GetValue();
if(trkreference > -1 && trkreference < 1000000){
trkassociation[trkreference] = iref;
}
}
}
for (Int_t iTrack = 0; iTrack < ntrk; iTrack++){
AliESDtrack* track = esd->GetTrack(iTrack);
// select tracks of selected particles
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) continue;//almeno un hit nell ITS
if (track->GetConstrainedChi2() > 4) continue; //se brutto X^2
if ((track->GetStatus() & AliESDtrack::kTOFout) == 0) continue; //se traccia matchata con tof
if(track->GetNumberOfTPCClusters() < 70) continue;
Float_t p =track->P();
itrig = 0;
timetrig = 0;
if(p > 0.9 && p < 1.1){
track->GetIntegratedTimes(time);
itrig = iTrack;
timetrig = track->GetTOFsignal() - time[2];
iTrack = ntrk;
}
}
printf("real loop, ntrk = %i\n",ntrk);
for (Int_t iTrack = 0; iTrack < ntrk; iTrack++){
AliESDtrack* track = esd->GetTrack(iTrack);
// select tracks of selected particles
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) continue;//almeno un hit nell ITS
if (track->GetConstrainedChi2() > 4) continue; //se brutto X^2
//if ((track->GetStatus() & AliESDtrack::kTOFout) == 0) continue; //se traccia matchata con tof
if(track->GetNumberOfTPCClusters() < 70) continue;
TOFout = (track->GetStatus() & AliESDtrack::kTOFout) > 0;
track->GetIntegratedTimes(time);
Float_t dx = track->GetTOFsignalDx(); //leggo i residui tra traccia e canale tof acceso
Float_t dz = track->GetTOFsignalDz();
mism = 0;
dedx = track->GetTPCsignal();
Int_t label = TMath::Abs(track->GetLabel());
if(stack){
TParticle *part=stack->Particle(label);
pdg = part->GetPdgCode();
}
Int_t TOFlabel[3];
track->GetTOFLabel(TOFlabel);
// printf("%i %i %i %i\n",label,TOFlabel[0],TOFlabel[1],TOFlabel[2]);
ChannelTOF[0] = track->GetTOFCalChannel();
// printf("geant time = %f\n",gtime);
//getchar();
// if(TMath::Abs(dx) > 1.25 || TMath::Abs(dz) > 1.75) continue; // is inside the pad
//riempio il numro di cludter e impulso trasverso per traccia del TTree T
ncluster=track->GetNTOFclusters();
impulso_trasv=track->Pt();
impulso=track->P();
StartTime = pidr->GetTOFResponse().GetStartTime(track->P());
StartTimeRes = pidr->GetTOFResponse().GetStartTimeRes(track->P());
if(track->Pt() > 0.9 && track->Pt() < 1.5){ //impulso non troppo alto per separazione tra particelle
Float_t dt = track->GetTOFsignal() - time[2] - pidr->GetTOFResponse().GetStartTime(track->P());//tempo TOF(è lo stesso di Gettime, solo che lo prendo dale tracce)(già calibrato) -ip del PI (posizione 0 e, posizione 1 mu, pos 2 PI, pos 3 K,pos 4 p) -start time
Float_t dtKa = track->GetTOFsignal() - time[3] - pidr->GetTOFResponse().GetStartTime(track->P());
Float_t dtPr = track->GetTOFsignal() - time[4] - pidr->GetTOFResponse().GetStartTime(track->P());
hdt->Fill(dt);
hdtKa->Fill(dtKa);
hdtPr->Fill(dtPr);
}
charge = track->Charge();
phi = track->Phi();
eta = track->Eta();
GetPositionAtTOF(track,mag,coord);
phiExt = TMath::ATan2(coord[1],coord[0]);
etaExt = -TMath::Log(TMath::Tan(0.5*TMath::ATan2(sqrt(coord[0]*coord[0]+coord[1]*coord[1]),coord[2])));
for (int i=0;i<(track->GetNTOFclusters());i++){
int idummy=track->GetTOFclusterArray()[i];
AliESDTOFCluster *cl = (AliESDTOFCluster *) tofcl->At(idummy);
tempo[i]=cl->GetTime();
tot[i]=cl->GetTOT();
ChannelTOF[i]=cl->GetTOFchannel();
if(i==0){
GetResolutionAtTOF(track,mag,ChannelTOF[i],res);
}
for(int im=cl->GetNMatchableTracks();im--;){ //o così o da n-1 a 0 //for(int im=cl->GetNMatchableTracks();im>0;im--) non andava bene perchè non prendeva mai lo 0
// if(track->GetNTOFclusters()==2) printf("-- %i) %f %f\n",im,cl->GetLength(im),cl->GetIntegratedTime(2,im));
if(cl->GetTrackIndex(im) == track->GetID()){
exp_time_el[i] = cl->GetIntegratedTime(0,im); // pi = 2
exp_time_mu[i] = cl->GetIntegratedTime(1,im); // pi = 2
exp_time_pi[i] = cl->GetIntegratedTime(2,im); // pi = 2
exp_time_ka[i] = cl->GetIntegratedTime(3,im); // pi = 2
exp_time_pr[i] = cl->GetIntegratedTime(4,im); // pi = 2
L[i] = cl->GetLength(im);
// if(track->GetNTOFclusters()==2)printf("%i) %f %f\n",i,L[i],exp_time_pi[i]);
DeltaX[i]=cl->GetDx(im); // mettendolo dentro questo if dovrei prendere i residui di una stessa traccia
DeltaZ[i]=cl->GetDz(im);
}
}
}
//ReMatch();
Int_t jref=0;
if(isMC){
if(TOFlabel[0] > -1 && TOFlabel[0] < 1000000){
trkref->GetEvent(trkassociation[TOFlabel[0]]);
if(TOFlabel[0] == trkref->GetLeaf("TrackReferences.fTrack")->GetValue()){
// printf("trk -> %i (%i)\n",trkref->GetLeaf("TrackReferences.fTrack")->GetValue(),trkref->GetLeaf("TrackReferences.fTrack")->GetValue(jref));
while(jref > -1 && trkref->GetLeaf("TrackReferences.fTrack")->GetValue(jref) != 0){
//printf("det = %i\n",trkref->GetLeaf("TrackReferences.fDetectorId")->GetValue(jref));
if(trkref->GetLeaf("TrackReferences.fDetectorId")->GetValue(jref) == 4){
gtime=trkref->GetLeaf("TrackReferences.fTime")->GetValue(jref)*1E+12;
xgl = trkref->GetLeaf("TrackReferences.fX")->GetValue(jref);
ygl = trkref->GetLeaf("TrackReferences.fY")->GetValue(jref);
zgl = trkref->GetLeaf("TrackReferences.fZ")->GetValue(jref);
MakeTrueRes();
jref = 100;
}
jref++;
}
}
}
}
if(TMath::Abs(label) != TOFlabel[0] && stack){
mism=2;
while(TOFlabel[0] != -1 && TOFlabel[0] != label){
TOFlabel[0] = stack->Particle(TOFlabel[0])->GetMother(0);
}
if(label == TOFlabel[0])
mism=1;
}
//AddDelay();
T->Fill(); //cout<<"riempio il tree "<<endl; //Riempio tree "T"
//incremento il contatore delle tracce del TTree T matchate e che superano i tagli
//ntracks++;
}//end of for(tracks)
esd->ResetStdContent();
} //end of for(events)
if(runLoader){
runLoader->UnloadHeader();
runLoader->UnloadKinematics();
delete runLoader;
}
esdFile->Close();
if(isMC) ftrkref->Close();
if(isMC) fgalice->Close();
}
void gen(Int_t nev = 1,
const char* genConfig = "$ALICE_ROOT/MUON/macros/genTestConfig.C")
{
// Load libraries
// gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT");
gSystem->Load("liblhapdf"); // Parton density functions
gSystem->Load("libEGPythia6"); // TGenerator interface
gSystem->Load("libpythia6"); // Pythia
gSystem->Load("libAliPythia6"); // ALICE specific implementations
AliPDG::AddParticlesToPdgDataBase();
TDatabasePDG::Instance();
// Run loader
AliRunLoader* rl = AliRunLoader::Open("galice.root","FASTRUN","recreate");
rl->SetCompressionLevel(2);
rl->SetNumberOfEventsPerFile(nev);
rl->LoadKinematics("RECREATE");
rl->MakeTree("E");
gAlice->SetRunLoader(rl);
// Create stack
rl->MakeStack();
AliStack* stack = rl->Stack();
// Header
AliHeader* header = rl->GetHeader();
// Create and Initialize Generator
gROOT->LoadMacro(genConfig);
AliGenerator* gener = genConfig();
// Go to galice.root
rl->CdGAFile();
// Forbid some decays. Do it after gener->Init(0, because
// the initialization of the generator includes reading of the decay table.
// ...
//
// Event Loop
//
TStopwatch timer;
timer.Start();
for (Int_t iev = 0; iev < nev; iev++) {
cout <<"Event number "<< iev << endl;
// Initialize event
header->Reset(0,iev);
rl->SetEventNumber(iev);
stack->Reset();
rl->MakeTree("K");
// Generate event
stack->Reset();
stack->ConnectTree(rl->TreeK());
gener->Generate();
cout << "Number of particles " << stack->GetNprimary() << endl;
// Finish event
header->SetNprimary(stack->GetNprimary());
header->SetNtrack(stack->GetNtrack());
// I/O
stack->FinishEvent();
header->SetStack(stack);
rl->TreeE()->Fill();
rl->WriteKinematics("OVERWRITE");
} // event loop
timer.Stop();
timer.Print();
// Termination
// Generator
gener->FinishRun();
// Write file
rl->WriteHeader("OVERWRITE");
gener->Write();
rl->Write();
}
void fastGen(Tune_t tune = kPyTuneCDFA , Float_t energy, Int_t nev = 1, TString process)
{
// Add all particles to the PDG database
AliPDG::AddParticlesToPdgDataBase();
// set the random seed
TDatime date;
UInt_t seed = date.Get()+gSystem->GetPid();
gRandom->SetSeed(seed);
cout<<"Seed for random number generation= "<<seed<<endl;
// Runloader
AliRunLoader* rl = AliRunLoader::Open("galice.root", "FASTRUN","recreate");
rl->SetCompressionLevel(2);
rl->SetNumberOfEventsPerFile(nev);
rl->LoadKinematics("RECREATE");
rl->MakeTree("E");
gAlice->SetRunLoader(rl);
// Create stack
rl->MakeStack();
AliStack* stack = rl->Stack();
// Header
AliHeader* header = rl->GetHeader();
//
// Create and Initialize Generator
AliGenerator *gener = CreateGenerator(tune,energy);
gener->Init();
// if nsd switch off single diffraction
if ( process == "NSD"){
if(tune != kPhojet) {
AliPythia::Instance()-> SetMSUB(92,0); // single diffraction AB-->XB
AliPythia::Instance()-> SetMSUB(93,0); // single diffraction AB-->AX
}
else {
cout << "NSD not yet implemented in the phojet case" << endl;
exit(1);
}
}
gener->SetStack(stack);
//
// Event Loop
//
Int_t iev;
for (iev = 0; iev < nev; iev++) {
if(!(iev%500)) printf("\n \n Event number %d \n \n", iev);
// Initialize event
header->Reset(0,iev);
rl->SetEventNumber(iev);
stack->Reset();
rl->MakeTree("K");
// stack->ConnectTree();
// Generate event
gener->Generate();
// Analysis
// Int_t npart = stack->GetNprimary();
// printf("Analyse %d Particles\n", npart);
// for (Int_t part=0; part<npart; part++) {
// TParticle *MPart = stack->Particle(part);
// Int_t mpart = MPart->GetPdgCode();
// printf("Particle %d\n", mpart);
// }
// Finish event
header->SetNprimary(stack->GetNprimary());
header->SetNtrack(stack->GetNtrack());
// I/O
//
stack->FinishEvent();
header->SetStack(stack);
rl->TreeE()->Fill();
rl->WriteKinematics("OVERWRITE");
} // event loop
//
// Termination
// Generator
gener->FinishRun();
// Write file
rl->WriteHeader("OVERWRITE");
gener->Write();
rl->Write();
}
int main(int argc, char* argv[])
{
TApplication theApp(srcName.Data(), &argc, argv);
//=============================================================================
for (int i=0; i<argc; i++) cout << i << ", " << argv[i] << endl;
//=============================================================================
if (argc<5) return -1;
TString sPath = argv[1]; if (sPath.IsNull()) return -1;
TString sFile = argv[2]; if (sFile.IsNull()) return -1;
TString sJetR = argv[3]; if (sJetR.IsNull()) return -1;
TString sSjeR = argv[4]; if (sSjeR.IsNull()) return -1;
//=============================================================================
sPath.ReplaceAll("#", "/");
//=============================================================================
double dJetR = -1.;
if (sJetR=="JetR02") dJetR = 0.2;
if (sJetR=="JetR03") dJetR = 0.3;
if (sJetR=="JetR04") dJetR = 0.4;
if (sJetR=="JetR05") dJetR = 0.5;
if (dJetR<0.) return -1;
cout << "Jet R = " << dJetR << endl;
//=============================================================================
double dSjeR = -1.;
if (sSjeR=="SjeR01") dSjeR = 0.1;
if (sSjeR=="SjeR02") dSjeR = 0.2;
if (sSjeR=="SjeR03") dSjeR = 0.3;
if (sSjeR=="SjeR04") dSjeR = 0.4;
if (dSjeR<0.) return -1;
cout << "Sub-jet R = " << dSjeR << endl;
//=============================================================================
const double dJetsPtMin = 0.001;
const double dCutEtaMax = 1.6;
const double dJetEtaMax = 1.;
const double dJetAreaRef = TMath::Pi() * dJetR * dJetR;
fastjet::GhostedAreaSpec areaSpc(dCutEtaMax);
fastjet::JetDefinition jetsDef(fastjet::antikt_algorithm, dJetR, fastjet::BIpt_scheme, fastjet::Best);
//fastjet::AreaDefinition areaDef(fastjet::active_area,areaSpc);
fastjet::AreaDefinition areaDef(fastjet::active_area_explicit_ghosts,areaSpc);
//fastjet::JetDefinition bkgsDef(fastjet::kt_algorithm, 0.2, fastjet::BIpt_scheme, fastjet::Best);
//fastjet::AreaDefinition aBkgDef(fastjet::active_area_explicit_ghosts, areaSpc);
fastjet::Selector selectJet = fastjet::SelectorAbsEtaMax(dJetEtaMax);
//fastjet::Selector selectRho = fastjet::SelectorAbsEtaMax(dCutEtaMax-0.2);
//fastjet::Selector selecHard = fastjet::SelectorNHardest(2);
//fastjet::Selector selectBkg = selectRho * (!(selecHard));
//fastjet::JetMedianBackgroundEstimator bkgsEstimator(selectBkg, bkgsDef, aBkgDef);
//fastjet::Subtractor bkgSubtractor(&bkgsEstimator);
fastjet::JetDefinition subjDef(fastjet::antikt_algorithm, dSjeR, fastjet::BIpt_scheme, fastjet::Best);
//=============================================================================
std::vector<fastjet::PseudoJet> fjInput;
//=============================================================================
TList *list = new TList();
TH1D *hPtHat = new TH1D("hPtHat", "", 1000, 0., 1000.);
TH1D *hJet = new TH1D("hJet", "", 1000, 0., 1000.); hJet->Sumw2(); list->Add(hJet);
TH2D *hJetNsj = new TH2D("hJetNsj", "", 1000, 0., 1000., 101, -0.5, 100.5); hJetNsj->Sumw2(); list->Add(hJetNsj);
TH2D *hJetIsj = new TH2D("hJetIsj", "", 1000, 0., 1000., 1000, 0., 1000.); hJetIsj->Sumw2(); list->Add(hJetIsj);
TH2D *hJet1sj = new TH2D("hJet1sj", "", 1000, 0., 1000., 1000, 0., 1000.); hJet1sj->Sumw2(); list->Add(hJet1sj);
TH2D *hJet2sj = new TH2D("hJet2sj", "", 1000, 0., 1000., 1000, 0., 1000.); hJet2sj->Sumw2(); list->Add(hJet2sj);
TH2D *hJetDsj = new TH2D("hJetDsj", "", 1000, 0., 1000., 1000, 0., 1000.); hJetDsj->Sumw2(); list->Add(hJetDsj);
TH2D *hJetIsz = new TH2D("hJetIsz", "", 1000, 0., 1000., 120, 0., 1.2); hJetIsz->Sumw2(); list->Add(hJetIsz);
TH2D *hJet1sz = new TH2D("hJet1sz", "", 1000, 0., 1000., 120, 0., 1.2); hJet1sz->Sumw2(); list->Add(hJet1sz);
TH2D *hJet2sz = new TH2D("hJet2sz", "", 1000, 0., 1000., 120, 0., 1.2); hJet2sz->Sumw2(); list->Add(hJet2sz);
TH2D *hJetDsz = new TH2D("hJetDsz", "", 1000, 0., 1000., 120, 0., 1.2); hJetDsz->Sumw2(); list->Add(hJetDsz);
//=============================================================================
AliRunLoader *rl = AliRunLoader::Open(Form("%s/galice.root",sPath.Data())); if (!rl) return -1;
if (rl->LoadHeader()) return -1;
if (rl->LoadKinematics("READ")) return -1;
//=============================================================================
for (Int_t iEvent=0; iEvent<rl->GetNumberOfEvents(); iEvent++) {
fjInput.resize(0);
if (rl->GetEvent(iEvent)) continue;
//=============================================================================
AliStack *pStack = rl->Stack(); if (!pStack) continue;
AliHeader *pHeader = rl->GetHeader(); if (!pHeader) continue;
//=============================================================================
AliGenPythiaEventHeader *pHeadPy = (AliGenPythiaEventHeader*)pHeader->GenEventHeader();
if (!pHeadPy) continue;
hPtHat->Fill(pHeadPy->GetPtHard());
//=============================================================================
for (Int_t i=0; i<pStack->GetNtrack(); i++) if (pStack->IsPhysicalPrimary(i)) {
TParticle *pTrk = pStack->Particle(i); if (!pTrk) continue;
if (TMath::Abs(pTrk->Eta())>dCutEtaMax) { pTrk = 0; continue; }
// TParticlePDG *pPDG = pTrk->GetPDG(); if (!pPDG) { pTrk = 0; continue; }
fjInput.push_back(fastjet::PseudoJet(pTrk->Px(), pTrk->Py(), pTrk->Pz(), pTrk->P()));
// pPDG = 0;
pTrk = 0;
}
//=============================================================================
fastjet::ClusterSequenceArea clustSeq(fjInput, jetsDef, areaDef);
std::vector<fastjet::PseudoJet> includJets = clustSeq.inclusive_jets(dJetsPtMin);
// std::vector<fastjet::PseudoJet> subtedJets = bkgSubtractor(includJets);
std::vector<fastjet::PseudoJet> selectJets = selectJet(includJets);
// std::vector<fastjet::PseudoJet> sortedJets = fastjet::sorted_by_pt(selectJets);
for (int j=0; j<selectJets.size(); j++) {
double dJet = selectJets[j].pt();
hJet->Fill(dJet);
//=============================================================================
fastjet::Filter trimmer(subjDef, fastjet::SelectorPtFractionMin(0.));
fastjet::PseudoJet trimmdJet = trimmer(selectJets[j]);
std::vector<fastjet::PseudoJet> trimmdSj = trimmdJet.pieces();
double nIsj = 0.;
double d1sj = -1.; int k1sj = -1;
double d2sj = -1.; int k2sj = -1;
for (int i=0; i<trimmdSj.size(); i++) {
double dIsj = trimmdSj[i].pt(); if (dIsj<0.001) continue;
hJetIsj->Fill(dJet, dIsj);
hJetIsz->Fill(dJet, dIsj/dJet);
if (dIsj>d1sj) {
d2sj = d1sj; k2sj = k1sj;
d1sj = dIsj; k1sj = i;
} else if (dIsj>d2sj) {
d2sj = dIsj; k2sj = i;
} nIsj += 1.;
}
hJetNsj->Fill(dJet, nIsj);
if (d1sj>0.) { hJet1sj->Fill(dJet, d1sj); hJet1sz->Fill(dJet, d1sj/dJet); }
if (d2sj>0.) { hJet2sj->Fill(dJet, d2sj); hJet2sz->Fill(dJet, d2sj/dJet); }
if ((d1sj>0.) && (d2sj>0.)) {
double dsj = d1sj - d2sj;
double dsz = dsj / dJet;
hJetDsj->Fill(dJet, dsj);
hJetDsz->Fill(dJet, dsz);
}
}
//=============================================================================
pStack = 0;
pHeadPy = 0;
pHeader = 0;
}
//=============================================================================
rl->UnloadgAlice();
rl->UnloadHeader();
rl->UnloadKinematics();
rl->RemoveEventFolder();
//=============================================================================
TFile *file = TFile::Open(Form("%s/pyxsec_hists.root",sPath.Data()), "READ");
TList *lXsc = (TList*)file->Get("cFilterList");
file->Close();
TH1D *hWeightSum = (TH1D*)lXsc->FindObject("h1Trials"); hWeightSum->SetName("hWeightSum");
TProfile *hSigmaGen = (TProfile*)lXsc->FindObject("h1Xsec"); hSigmaGen->SetName("hSigmaGen");
//=============================================================================
file = TFile::Open(Form("%s.root",sFile.Data()), "NEW");
hPtHat->Write();
hWeightSum->Write();
hSigmaGen->Write();
list->Write();
file->Close();
//=============================================================================
cout << "DONE" << endl;
//=============================================================================
return 0;
}
void AliITSVertexerTracksTest2(Int_t evFirst=0,Int_t evLast=0,
const Char_t *galiceName="galice.root",
const Char_t *trksName="AliITStracksV2.root",
const Char_t *vtxName="AliITSVertices.root") {
/*******************************************************************
* *
* Test macro for vertexing in pp using tracks. *
* Input file must contain trees with AliITStrackV2 objects. *
* Output file can be the same file with the tracks *
* or another file. *
* If the file galice.root is available, B is taken from there, *
* otherwise is can be set here "by hand". *
* *
* Origin: A.Dainese, Padova [email protected] *
*******************************************************************/
// Look for field value in galice.root
Double_t field = 0.4;
Int_t kDebug = 0;
TFile *galice = 0;
if(!gSystem->AccessPathName(galiceName,kFileExists)) {
galice = new TFile(galiceName);
gAlice = (AliRun*)galice->Get("gAlice");
AliMagF *fiel = TGeoGlobalMagField::Instance()->GetField();
field=(Double_t)fiel->SolenoidField()/10.;
AliKalmanTrack::SetConvConst(100/0.299792458/field);
printf(" B = %3.1f read from gAlice and set\n",field);
} else {
printf(" File galice.root not found: default 0.4 T being used!\n");
}
// Open input and output files
TFile *inFile = TFile::Open(trksName);
TFile *outFile = TFile::Open(vtxName,"recreate");
// Create vertexer
AliITSVertexerTracks *vertexer =
new AliITSVertexerTracks(inFile,outFile,field,0.,0.);
vertexer->SetDebug(0);
vertexer->SetUseThrustFrame(0);
vertexer->PrintStatus();
AliITSVertex *vert = 0;
// Find vertices
for(Int_t i=evFirst; i<=evLast; i++){
if(i%100==0)cout<<"processing event "<<i<<endl;
gAlice->GetEvent(i);
// The true Z coord. is fetched for comparison
AliHeader *header = gAlice->GetHeader();
AliGenEventHeader* genEventHeader = header->GenEventHeader();
TArrayF primaryVertex(3);
genEventHeader->PrimaryVertex(primaryVertex);
vert = vertexer->FindVertexForCurrentEvent(i);
if(kDebug>0){
// Prints the results
cout <<"========================================================\n";
cout << "Event number: "<<i<<") Z Vertex:"<<endl;
if(vert){
cout<<"FOUND: "<<vert->GetZ()<<"; "<<vert->GetZRes()<<endl;
cout <<" True Z position "<<primaryVertex[2]<<endl;
cout<<", diff= "<<(primaryVertex[2]-vert->GetZ())*10000.<<endl;
}
else {
cout<<"NOT FOUND "<<endl;
}
}
if(vert){
Double_t pos[3];
for(Int_t kk=0;kk<3;kk++)pos[kk]=(Double_t)primaryVertex[kk];
vert->SetTruePos(pos);
vertexer->WriteCurrentVertex();
}
}
delete vertexer;
inFile->Close();
outFile->Close();
delete inFile;
delete outFile;
galice->Close();
delete galice;
return;
}
