Int_t printDigits()
{
AliRunLoader *rl = AliRunLoader::Open("galice.root");
AliPHOSLoader *prl = (AliPHOSLoader*)rl->GetDetectorLoader("PHOS");
prl->LoadDigits("READ");
//prl->LoadDigits();
Int_t nDigits = 0;
Int_t nSimEvents = rl->GetNumberOfEvents();
for (Int_t ev = 0; ev < nSimEvents; ev++)
{
rl->GetEvent(ev);
Int_t nPhosDigits = prl->Digits()->GetEntries();
//Int_t nDigsFound = 0;
std::cout << "Number of digits found: " << nPhosDigits << std::endl;
TClonesArray *phosDigits = prl->Digits();
for (Int_t iDig = 0; iDig < nPhosDigits; iDig++)
{
//const AliPHOSDigit *digit = prl->Digit(iDig);
AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(iDig);
nDigits++;
//if(digit->GetTime() > 1.4e-08 && digit->GetTime() < 1.6e-08)
std::cout <<"#: " << iDig << " ID: " << digit->GetId() << " " << "Energy: " << digit->GetEnergy() << " Time: " << digit->GetTime() << " N_prim: " << digit->GetNprimary() << " " << digit->GetTimeR() << std::endl;
}
}
return 0;
}
void CountPrimaries(TH1F *hMultCount) {
if (hMultCount==0) hMultCount = new TH1F("mult","averaged multiplicity (charg. prim)",80,-4.,4.);
AliRunLoader *rl = AliRunLoader::Open("galice.root");
rl->SetKineFileName("Kinematics.root");
rl->LoadHeader();
rl->LoadKinematics();
Int_t nEvents = rl->GetNumberOfEvents();
cout<< "N events "<<nEvents<<endl;
for(Int_t iEv=0; iEv<nEvents; iEv++){
rl->GetEvent(iEv);
AliStack *s = rl->Stack();
for(Int_t iP=0; iP<s->GetNtrack(); iP++ ){
TParticle *p = s->Particle(iP);
if (!(s->IsPhysicalPrimary(iP))) continue;
Float_t eta = p->Eta();
if (p->Pt()>0.06) {
hMultCount->Fill(eta);
}
}
}
hMultCount->DrawCopy();
rl->UnloadHeader();
rl->UnloadKinematics();
delete rl;
}
void Kin2Txt() {
AliRunLoader* rl = AliRunLoader::Open("galice.root");
rl->LoadKinematics();
rl->LoadHeader();
TH1* hM = new TH1D("hM", "TreeK;M#(){#pi^{+}#pi^{-}} #(){GeV/#it{c}^{2}}", 100, 0., 2.);
TH1* hPt = new TH1D("hPt", "TreeK;P_{T}#(){#pi^{+}#pi^{-}} #(){GeV/#it{c}}", 100, 0., 1.);
TH1* hY = new TH1D("hY", "TreeK;Y#(){#pi^{+}#pi^{-}}", 160,-8., 8.);
std::ofstream ofs("rho0.txt");
AliStack *stack = NULL;
TParticle *part = NULL;
TLorentzVector v[2], vSum;
for (Int_t i=0, n(rl->GetNumberOfEvents()); i<n; ++i) {
rl->GetEvent(i);
stack = rl->Stack();
Int_t nPrimary(0);
for (Int_t j(0), m(stack->GetNtrack()); j<m; ++j) {
part = stack->Particle(j);
if (part->IsPrimary())
part->Momentum(v[nPrimary++]);
}
if (nPrimary != 2) {
Printf("Error: nPrimary=%d != 2", nPrimary);
continue;
}
vSum = v[0] + v[1];
hM->Fill(vSum.M());
hPt->Fill(vSum.Perp());
hY->Fill(vSum.Rapidity());
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->Draw();
c1->SaveAs("TreeK.pdf(");
hPt->Draw();
c1->SaveAs("TreeK.pdf");
hY->Draw();
c1->SaveAs("TreeK.pdf)");
}
void ExtractOutputHistos(Bool_t onlyPrims=0,Bool_t onlyPion=0,Int_t plotFlag=0) {
// gROOT->SetStyle("Plain");
gStyle->SetPalette(1);
const Int_t nbins=20;
Double_t ptmin=0.06;//04;
Double_t ptmax=2.0;//GeV
Double_t logxmin = TMath::Log10(ptmin);
Double_t logxmax = TMath::Log10(ptmax);
Double_t binwidth = (logxmax-logxmin)/(nbins+1);
enum {nb=nbins+1};
Double_t xbins[nb];
xbins[0] = ptmin;
for (Int_t i=1;i<=nbins;i++) {
xbins[i] = ptmin + TMath::Power(10,logxmin+(i)*binwidth);
// cout<<xbins[i]<<endl;
}
// TH1F *h = new TH1F("h","hist with log x axis",nbins,xbins);
TH1F *hMultCount = new TH1F("mult","averaged multiplicity (charg. prim)",80,-4.,4.);
hMultCount->GetXaxis()->SetTitle("eta");
hMultCount->GetYaxis()->SetTitle("N/d#eta");
TH1F *hAllMC = new TH1F("allMC","All Tracks MC primaries",nbins,xbins);
TH1F *hAllFound = new TH1F("allFound","All Tracks found",nbins,xbins);
TH1F *hImperfect = new TH1F("imperfect","Imperfect tracks",nbins,xbins);
TH1F *hPerfect = new TH1F("perfect","Perfect tracks",nbins,xbins);
TH1F *hEff = new TH1F("efficiency","Efficiency (Perfect tracks in \"ALL MC\")",nbins,xbins);
TH1F *hFake = new TH1F("fake","Fake tracks (Inperfect tracks in \"ALL MC\")",nbins,xbins);
TH1F *hPurity = new TH1F("purity","Purity (Perfect tracks in \"All Found\")",nbins,xbins);
TH1F *hAnna = new TH1F("annaEff","AnnalisaEff ",nbins,xbins);
TH1F *hNoMCTrack = new TH1F("noMCtrack","noMCtrack ",nbins,xbins);
TH1F *hEta = new TH1F("","",50,-2,2);
// TH1F *hEtaMC = new TH1F("","",50,-2,2);
TH2D *h2Ddca = new TH2D("dca2D","DCAvsPt2D",nbins,xbins,50,-0.05,0.05);
TH2D *h2Dpt = new TH2D("dPt2D","dPtdvsPt2D",nbins,xbins,50,-25,25);
// open run loader and load gAlice, kinematics and header
AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
if (!runLoader) {
Error("Check kine", "getting run loader from file %s failed",
"galice.root");
return;
}
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
Error("Check kine", "no galice object found");
return;
}
runLoader->LoadHeader();
runLoader->LoadKinematics();
TFile* esdFile = TFile::Open("AliESDs.root");
if (!esdFile || !esdFile->IsOpen()) {
Error("CheckESD", "opening ESD file %s failed", "AliESDs.root");
return;
}
AliESDEvent *esd = new AliESDEvent();
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree) {
Error("CheckESD", "no ESD tree found");
return;
}
esd->ReadFromTree(tree);
Int_t nTrackTotalMC = 0;
Int_t nTrackFound = 0;
Int_t nTrackImperfect = 0;
Int_t nTrackPerfect = 0;
Int_t nNoMCTrack = 0;
for(Int_t iEv =0; iEv<tree->GetEntries(); iEv++){
tree->GetEvent(iEv);
runLoader->GetEvent(iEv);
printf("+++ event %i (of %lld) +++++++++++++++++++++++ # ESDtracks: %d \n",iEv,tree->GetEntries()-1,esd->GetNumberOfTracks());
Int_t nESDtracks = esd->GetNumberOfTracks();
for (Int_t iTrack = 0; iTrack < nESDtracks; iTrack++) {
AliESDtrack* track = esd->GetTrack(iTrack);
if (!(iTrack%1000)) printf("event %i: ESD track count %d (of %d)\n",iEv,iTrack,nESDtracks);
Int_t label = track->GetLabel();
Int_t idx[12];
// Int_t ncl = track->GetITSclusters(idx);
if(label<0) {
// cout<< " ESD track label " << label;
// cout<<" ---> imperfect track (label "<<label<<"<0) !! -> track Pt: "<< track->Pt() << endl;
}
AliStack* stack = runLoader->Stack();
// nTrackTotalMC += stack->GetNprimary();
TParticle* particle = stack->Particle(TMath::Abs(label));
Double_t pt = track->Pt();
if(particle) {
if (TMath::Abs(particle->Eta())>etaCut) continue;
Double_t ptMC = particle->Pt();
// Efficiencies
if (onlyPion && TMath::Abs(particle->GetPdgCode())!=211) continue;
if ( (!onlyPrims) || stack->IsPhysicalPrimary(TMath::Abs(label))) {
// cout<<" # clusters "<<ncl<<endl;
nTrackFound++;
hAllFound->Fill(ptMC);
hEta->Fill(track->Eta());
if (label<0) {
nTrackImperfect++;
hImperfect->Fill(ptMC);
} else {
nTrackPerfect++;
hPerfect->Fill(ptMC);
}
}
// following only for "true tracks, pions
if(particle->Pt() < 0.001)continue;
if (TMath::Abs(particle->GetPdgCode())!=211) continue;
if (label>0) {
// Impact parameters for Pions only
Double_t dca = track->GetD(0,0,0.5);
h2Ddca->Fill(ptMC,dca);
// Pt resolution for Pions only
Double_t dPt = (pt-ptMC)/ptMC*100;
h2Dpt->Fill(ptMC,dPt);
}
} else {
nNoMCTrackFound++;
hNoMCTrack->Fill(pt);
cout<<" according MC particle not found"<<endl;
}
} //entries track esd
}//entries tree
runLoader->UnloadHeader();
runLoader->UnloadKinematics();
delete runLoader;
// Count trackable MC tracks
CountTrackableMCs(hAllMC, onlyPrims, onlyPion);
// Count trackable MC tracks
CountPrimaries(hMultCount);
// Get Errors right
hMultCount->Sumw2();
hAllMC->Sumw2();
hAllFound->Sumw2();
hPerfect->Sumw2();
hImperfect->Sumw2();
h2Dpt->Sumw2();
h2Ddca->Sumw2();
// -- Global efficienies
nTrackTotalMC = hAllMC->GetEntries();
Double_t eff = ((Double_t)nTrackPerfect)/nTrackTotalMC;
printf("-> Total number of events: %lld -> MCtracks %d -> nPerfect %d -> Eff: %3.2lf \n",
tree->GetEntries(),nTrackTotalMC,nTrackPerfect,eff);
Double_t purity = ((Double_t)nTrackPerfect)/nTrackFound;
printf("-> Total number of events: %lld -> FoundTracks %d -> nPerfect %d -> Purity: %3.2lf \n",
tree->GetEntries(),nTrackFound,nTrackPerfect,purity);
// Efficiencies - and normalize to 100%
TF1 f1("f1","100+x*0",0.,1.e3);
hPurity->Divide(hPerfect,hAllFound,1,1,"b");
hPurity->Multiply(&f1);
hPurity->SetMarkerColor(kGreen);
hPurity->SetMarkerStyle(21);
hPurity->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hPurity->SetStats(0);
hPurity->GetYaxis()->SetRangeUser(0,100);
hPurity->SetTitle("Efficiency & Purity");
hEff->Divide(hPerfect,hAllMC,1,1,"b");
hEff->Multiply(&f1);
hEff->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hEff->SetMarkerColor(kBlue);
hEff->SetMarkerStyle(21);
hEff->SetStats(0);
hFake->Divide(hImperfect,hAllMC,1,1,"b");
hFake->Multiply(&f1);
hFake->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hFake->SetMarkerColor(kRed);
hFake->SetMarkerStyle(21);
hFake->SetStats(0);
hAnna->Divide(hAllFound,hAllMC,1,1,"b");
hAnna->Multiply(&f1);
hAnna->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hAnna->SetMarkerColor(kBlack);
hAnna->SetMarkerStyle(21);
hAnna->SetStats(0);
TCanvas *c1 = new TCanvas("c1","NoMCTrackFound");//,200,10,900,900);
TVirtualPad *pad = c1->cd();
pad->SetGridx(); pad->SetGridy();
hNoMCTrack->Draw();
TCanvas *c2 = new TCanvas("c2","Eff&Purity");//,200,10,900,900);
TVirtualPad *pad = c2->cd();
pad->SetGridx(); pad->SetGridy();
// pad->SetLogx();
hPurity->Draw("E");
hEff->Draw("Same E");
hFake->Draw("Same E");
hAnna->Draw("Same E");
TLegend *leg = new TLegend(0.1,0.8,0.6,0.9);leg->SetFillColor(0);
leg->AddEntry(hPurity,"Purity (\"Perfect tracks\" within \"Found Tracks\")","PE");
leg->AddEntry(hEff,"Efficiency (\"Perfect tracks\" within \"MC findable Tracks\")","PE");
leg->AddEntry(hFake,"Fake (\"Inperfect tracks\" within \"MC findable Tracks\")","PE");
leg->AddEntry(hAnna,"AnnaLisa - Efficiency (\"Found tracks\" within \"MC findable Tracks\")","PE");
leg->Draw();
if (plotFlag==1){
hAllMC->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
hAllMC->Draw(); // MC pt distribution
hAllFound->SetLineColor(2);
hAllFound->Draw("same"); // MC pt distribution
}
/*
.L ~/ITSupgrade/BuildDetector/DetectorK.cxx+
// All NEW
DetectorK its("ALICE","ITS");
its.MakeAliceAllNew(0);
its.SetMaxRadiusOfSlowDetectors(0.01);
its.SolveViaBilloir(0);
TGraph *c = its.GetGraphRecoEfficiency(0,3,2);
c->Draw("C");
// Current
DetectorK its("ALICE","ITS");
its.MakeAliceCurrent(0,0);
its.SetMaxRadiusOfSlowDetectors(0.01);
its.SolveViaBilloir(0);
TGraph *c = its.GetGraphRecoEfficiency(0,4,2);
c->Draw("C");
*/
TCanvas *c3 = new TCanvas("c3","impact");//,200,10,900,900);
c3->Divide(2,1); c3->cd(1);
// Impact parameter
// Impact parameter resolution ---------------
h2Ddca->Draw("colz");
h2Ddca->FitSlicesY() ;
TH2D *dcaM = (TH2D*)gDirectory->Get("dca2D_1"); dcaM->Draw("same");
TH2D *dcaRMS = (TH2D*)gDirectory->Get("dca2D_2"); //dcaRMS->Draw();
TGraphErrors *d0 = new TGraphErrors();
for (Int_t ibin =1; ibin<=dcaRMS->GetXaxis()->GetNbins(); ibin++) {
d0->SetPoint( ibin-1,dcaRMS->GetBinCenter(ibin),dcaRMS->GetBinContent(ibin)*1e4); // microns
d0->SetPointError(ibin-1,0,dcaRMS->GetBinError(ibin)*1e4); // microns
}
d0->SetMarkerStyle(21);
d0->SetMaximum(200); d0->SetMinimum(0);
d0->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
d0->GetYaxis()->SetTitle("R-#phi Pointing Resolution (#mum)");
d0->SetName("dca"); d0->SetTitle("DCAvsPt");
c3->cd(1); h2Ddca->Draw("surf2");
c3->cd(2); d0->Draw("APE");
// PT RESOLUTION ------------
TCanvas *c4 = new TCanvas("c4","pt resolution");//,200,10,900,900);
c4->Divide(2,1); c4->cd(1);
// Impact parameter
h2Dpt->Draw("colz");
h2Dpt->FitSlicesY() ;
TH2D *dPtM = (TH2D*)gDirectory->Get("dPt2D_1"); dPtM->Draw("same");
TH2D *dPtRMS = (TH2D*)gDirectory->Get("dPt2D_2"); // dPtRMS->Draw("");
TGraphErrors *gPt = new TGraphErrors();
for (Int_t ibin =1; ibin<=dPtRMS->GetXaxis()->GetNbins(); ibin++) {
gPt->SetPoint( ibin-1,dPtRMS->GetBinCenter(ibin),dPtRMS->GetBinContent(ibin));
gPt->SetPointError(ibin-1,0,dPtRMS->GetBinError(ibin));
}
gPt->SetMarkerStyle(21);
gPt->SetMaximum(20); gPt->SetMinimum(0);
gPt->GetXaxis()->SetTitle("transverse momentum p_{t} (GeV)");
gPt->GetYaxis()->SetTitle("relative momentum resolution (%)");
gPt->SetName("dPt"); gPt->SetTitle("DPTvsPt");
c4->cd(1); h2Dpt->Draw("surf2");
c4->cd(2); gPt->Draw("APE");
// EXPORT --------
TFile f("histos.root","RECREATE");
hMultCount->Write();
hAllMC->Write();
hAllFound->Write();
hImperfect->Write();
hPerfect->Write();
hNoMCTrack->Write();
hPurity->Write();
hEff->Write();
hFake->Write();
hAnna->Write();
h2Ddca->Write();
d0->Write();
h2Dpt->Write();
gPt->Write();
f.Close();
return;
}
void CountTrackableMCs(TH1F *hAllMC, Bool_t onlyPrims,Bool_t onlyPion) {
gSystem->Load("libITSUpgradeBase");
gSystem->Load("libITSUpgradeSim");
// open run loader and load gAlice, kinematics and header
AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
if (!runLoader) {
Error("Check kine", "getting run loader from file %s failed",
"galice.root");
return;
}
runLoader->LoadHeader();
runLoader->LoadKinematics();
runLoader->LoadTrackRefs();
AliLoader *dl = runLoader->GetDetectorLoader("ITS");
//Trackf
TTree *trackRefTree = 0x0;
TClonesArray *trackRef = new TClonesArray("AliTrackReference",1000);
// TH1F *hRef = new TH1F("","",100,0,100);
TH1F *hR = new TH1F("","",100,0,100);
if (hAllMC==0) hAllMC = new TH1F("","",100,0.1,2);
Float_t ptmin = hAllMC->GetBinCenter(1)-hAllMC->GetBinWidth(1)/2;
Float_t ptmax = hAllMC->GetBinCenter(hAllMC->GetNbinsX())+hAllMC->GetBinWidth(hAllMC->GetNbinsX())/2;
// Int_t nAllMC = 0;
// Detector geometry
TArrayD rmin(0); TArrayD rmax(0);
GetDetectorRadii(&rmin,&rmax);
TArrayI nLaySigs(rmin.GetSize());
printf("Counting trackable MC tracks ...\n");
for(Int_t iEv =0; iEv<runLoader->GetNumberOfEvents(); iEv++){
Int_t nTrackableTracks = 0;
runLoader->GetEvent(iEv);
AliStack* stack = runLoader->Stack();
printf("+++ event %i (of %d) +++++++++++++++++++++++ # total MCtracks: %d \n",iEv,runLoader->GetNumberOfEvents()-1,stack->GetNtrack());
trackRefTree=runLoader->TreeTR();
TBranch *br = trackRefTree->GetBranch("TrackReferences");
if(!br) {
printf("no TR branch available , exiting \n");
return;
}
br->SetAddress(&trackRef);
// init the trackRef tree
trackRefTree=runLoader->TreeTR();
trackRefTree->SetBranchAddress("TrackReferences",&trackRef);
// Count trackable MC tracks
for (Int_t iMC=0; iMC<stack->GetNtrack(); iMC++) {
TParticle* particle = stack->Particle(iMC);
if (TMath::Abs(particle->Eta())>etaCut) continue;
if (onlyPrims && !stack->IsPhysicalPrimary(iMC)) continue;
if (onlyPion && TMath::Abs(particle->GetPdgCode())!=211) continue;
Bool_t isTrackable = 0;
nLaySigs.Reset(0);
trackRefTree->GetEntry(stack->TreeKEntry(iMC));
Int_t nref=trackRef->GetEntriesFast();
for(Int_t iref =0; iref<nref; iref++){
AliTrackReference *trR = (AliTrackReference*)trackRef->At(iref);
if(!trR) continue;
if(trR->DetectorId()!=AliTrackReference::kITS) continue;
Float_t radPos = trR->R();
hR->Fill(radPos);
for (Int_t il=0; il<rmin.GetSize();il++) {
if (radPos>=rmin.At(il)-0.1 && radPos<=rmax.At(il)+0.1) {
// cout<<" in Layer "<<il<<" "<<radPos;
nLaySigs.AddAt(1.,il);
// cout<<" "<<nLaySigs.At(il)<<endl;
}
}
}
if (nLaySigs.GetSum()>=3) {
isTrackable =1;
// cout<<nLaySigs.GetSum()<<endl;
}
if (isTrackable) {
Double_t ptMC = particle->Pt();
// Double_t etaMC = particle->Eta();
// if (ptMC>ptmin&&ptMC<ptmax) {nTrackableTracks++;hAllMC->Fill(ptMC);}
if (ptMC>ptmin) {nTrackableTracks++;hAllMC->Fill(ptMC);}
}
} // entries tracks MC
printf(" -> trackable MC tracks: %d (%d)\n",nTrackableTracks,hAllMC->GetEntries());
}//entries Events
hR->DrawCopy();
hAllMC->DrawCopy();
runLoader->UnloadHeader();
runLoader->UnloadKinematics();
delete runLoader;
}
int getSimulatedDigits(TString digitdir)
{
AliRunLoader *rl = AliRunLoader::Open(digitdir+TString("/galice.root"));
AliPHOSLoader *prl = (AliPHOSLoader*)rl->GetDetectorLoader("PHOS");
prl->LoadSDigits();
prl->LoadDigits();
Int_t nSimEvents = rl->GetNumberOfEvents();
TFile *mydigitsFile = new TFile("mydigits.root", "RECREATE");
TTree *mydigitTree = new TTree("mydigitTree", "mydigitTree");
TClonesArray * mydigits = new TClonesArray(AliPHOSDigit::Class());
mydigitTree->Branch("Digits", &mydigits);
for (Int_t ev = 0; ev < nSimEvents; ev++)
{
rl->GetEvent(ev);
Int_t nPhosDigits = prl->SDigits()->GetEntries();
Int_t nDigsFound = 0;
for (Int_t iDig = 0; iDig < nPhosDigits; iDig++)
{
const AliPHOSDigit *digit = prl->SDigit(iDig);
Int_t id = digit->GetId();
if (id > 3*geom->GetNPhi()*geom->GetNZ()) continue;
for (Int_t n = 0; n < nDigsFound; n++)
{
AliPHOSDigit *tmpDig = (AliPHOSDigit*)mydigits->At(n);
if (id == tmpDig->GetId())
{
*tmpDig += *digit;
digit = 0;
break;
}
}
if (digit)
{
AliPHOSDigit *newDig = new((*mydigits)[nDigsFound]) AliPHOSDigit(-1, id, (float)0.0, (float)0.0);
*newDig += *digit;
nDigsFound++;
}
}
for(int i = 0; i <nDigsFound; i++)
{
AliPHOSDigit *tmpDig = (AliPHOSDigit*)mydigits->At(i);
Int_t relId[4];
geom->AbsToRelNumbering(tmpDig->GetId(), relId);
// Some necessary ugly hacks needed at the moment, need to get these numbers from OCDB
tmpDig->SetEnergy((float)((int)(tmpDig->GetEnergy()/phosCalibData->GetADCchannelEmc(relId[0], relId[3], relId[2]))));
//std::cout << "Sample time step: " << phosCalibData->GetSampleTimeStep() << " " << phosCalibData->GetTimeShiftEmc(relId[0], relId[3], relId[2]) << geom << std::endl;
tmpDig->SetTime(1.5e-8);
tmpDig->SetTimeR(1.5e-8);
}
mydigitTree->Fill();
mydigits->Clear("C");
}
mydigitsFile->Write();
simTree = mydigitTree;
//mydigit
//mydigitsFile->Close();
return 0;
}
Int_t RunHLTITS(Int_t nev=1,Int_t run=0) {
// gSystem->Load("libAliHLTITS");
TStopwatch timer;
timer.Start();
if (gAlice) {
delete gAlice->GetRunLoader();
delete gAlice;
gAlice=0;
}
AliRunLoader *rl = AliRunLoader::Open("galice.root");
if (rl == 0x0) {
cerr<<"Can not open session"<<endl;
return 1;
}
Int_t retval = rl->LoadgAlice();
if (retval) {
cerr<<"AliESDtest.C : LoadgAlice returned error"<<endl;
delete rl;
return 1;
}
retval = rl->LoadHeader();
if (retval) {
cerr<<"AliESDtest.C : LoadHeader returned error"<<endl;
delete rl;
return 2;
}
gAlice=rl->GetAliRun();
AliTracker::SetFieldMap(gAlice->Field());
AliITSLoader* itsl = (AliITSLoader*)rl->GetLoader("ITSLoader");
if (itsl == 0x0) {
cerr<<"AliESDtest.C : Can not get the ITS loader"<<endl;
return 3;
}
itsl->LoadRecPoints("read");
AliITS *dITS = (AliITS*)gAlice->GetDetector("ITS");
if (!dITS) {
cerr<<"AliESDtest.C : Can not find the ITS detector !"<<endl;
return 4;
}
// AliITSgeom *geom = dITS->GetITSgeom();
AliITSgeom *geom = new AliITSgeom();
geom->ReadNewFile("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det");
//An instance of the HLT ITS tracker
AliHLTITStracker itsTracker(geom);
TFile *ef=TFile::Open("AliESDs.root");
if (!ef || !ef->IsOpen()) {cerr<<"Can't AliESDs.root !\n"; return 1;}
AliESD* event = new AliESD;
TTree* tree = (TTree*) ef->Get("esdTree");
if (!tree) {cerr<<"no ESD tree found\n"; return 1;};
tree->SetBranchAddress("ESD", &event);
TFile *itsf=TFile::Open("AliESDits.root","RECREATE");
if ((!itsf)||(!itsf->IsOpen())) {
cerr<<"Can't AliESDits.root !\n"; return 1;
}
Int_t rc=0;
if (nev>rl->GetNumberOfEvents()) nev=rl->GetNumberOfEvents();
//The loop over events
for (Int_t i=0; i<nev; i++) {
cerr<<"\n\nProcessing event number : "<<i<<endl;
tree->GetEvent(i);
rl->GetEvent(i);
TArrayF v(3);
rl->GetHeader()->GenEventHeader()->PrimaryVertex(v);
Double_t vtx[3]={v[0],v[1],v[2]};
Double_t cvtx[3]={0.005,0.005,0.010};
cout<<"MC vertex position: "<<v[2]<<endl;
AliHLTITSVertexerZ vertexer("null");
AliESDVertex* vertex = NULL;
TStopwatch timer2;
timer2.Start();
TTree* treeClusters = itsl->TreeR();
// vertex = vertexer.FindVertexForCurrentEvent(i);
// AliESDVertex *vertex = vertexer.FindVertexForCurrentEvent(geom,treeClusters);
vertex = new AliESDVertex(vtx,cvtx);
timer2.Stop();
timer2.Print();
if(!vertex){
cerr<<"Vertex not found"<<endl;
vertex = new AliESDVertex(vtx,cvtx);
}
else {
vertex->SetTruePos(vtx); // store also the vertex from MC
}
event->SetVertex(vertex);
Double_t vtxPos[3];
Double_t vtxErr[3];
vertex->GetXYZ(vtxPos);
vertex->GetSigmaXYZ(vtxErr);
itsTracker.SetVertex(vtxPos,vtxErr);
TTree *itsTree=itsl->TreeR();
if (!itsTree) {
cerr<<"Can't get the ITS cluster tree !\n";
return 4;
}
itsTracker.LoadClusters(itsTree);
rc+=itsTracker.Clusters2Tracks(event);
// rc+=itsTracker.PropagateBack(event);
itsTracker.UnloadClusters();
if (rc==0) {
TTree* tree = new TTree("esdTree", "Tree with ESD objects");
tree->Branch("ESD", "AliESD", &event);
tree->Fill();
itsf->cd();
tree->Write();
}
if (rc) {
cerr<<"Something bad happened...\n";
}
}
delete event;
itsf->Close();
ef->Close();
// delete rl;
timer.Stop();
timer.Print();
return rc;
}
//_____________________________________________________________________________
Int_t AliTRDdisplayDigits3D(Int_t event = 0, Int_t thresh = 4
, Bool_t sdigits = kFALSE)
{
//
// TRD digits display
//
// Input parameter:
// <event> : Event number
// <thresh> : Threshold to suppress the noise
// <sdigits> : If kTRUE it will display summable digits, normal digits otherwise.
// The signal event is displayed in yellow.
//
Char_t *inputFile = "galice.root";
// Define the objects
AliTRDv1 *trd;
AliTRDgeometry *geo;
TString evfoldname = AliConfig::GetDefaultEventFolderName();
AliRunLoader *runLoader = AliRunLoader::GetRunLoader(evfoldname);
if (!runLoader) {
runLoader = AliRunLoader::Open(inputFile
,AliConfig::GetDefaultEventFolderName()
,"UPDATE");
}
if (!runLoader) {
printf("Can not open session for file %s.",inputFile);
return kFALSE;
}
if (!runLoader->GetAliRun()) {
runLoader->LoadgAlice();
}
gAlice = runLoader->GetAliRun();
if (!gAlice) {
printf("Could not find AliRun object.\n");
return kFALSE;
}
runLoader->GetEvent(event);
AliLoader *loader = runLoader->GetLoader("TRDLoader");
if (!loader) {
printf("Can not get TRD loader from Run Loader");
}
loader->LoadDigits();
// Get the pointer to the detector object
trd = (AliTRDv1*) gAlice->GetDetector("TRD");
// Get the pointer to the geometry object
if (trd) {
geo = trd->GetGeometry();
}
else {
printf("Cannot find the geometry\n");
return 1;
}
AliCDBManager *cdbManager = AliCDBManager::Instance();
cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
calibration->SetRun(0);
TCanvas *c1 = new TCanvas("digits","TRD digits display",0,0,700,730);
TView *v = new TView(1);
v->SetRange(-430,-560,-430,430,560,1710);
v->SetParallel();
c1->Clear();
c1->SetFillColor(1);
c1->SetTheta(90.0);
c1->SetPhi(0.0);
Int_t markerColorSignal = 2;
Int_t markerColorBgnd = 7;
Int_t markerColorMerged = 5;
Int_t mask = 10000000;
// Create the digits manager
AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
digitsManager->SetSDigits(sdigits);
// Read the digits from the file
if (sdigits) {
digitsManager->ReadDigits(loader->TreeS());
}
else {
if (!loader->TreeD()) {
printf("mist\n");
return kFALSE;
}
digitsManager->ReadDigits(loader->TreeD());
}
Int_t totalsignal = 0;
Int_t totalbgnd = 0;
Int_t totalmerged = 0;
Int_t timeMax = calibration->GetNumberOfTimeBins();
// Loop through all detectors
for (Int_t idet = 0; idet < geo->Ndet(); idet++) {
printf("<AliTRDdisplayDigits3D> Loading detector %d\n",idet);
AliTRDdataArrayI *digits = digitsManager->GetDigits(idet);
digits->Expand();
Int_t isec = geo->GetSector(idet);
Int_t icha = geo->GetChamber(idet);
Int_t ipla = geo->GetPlane(idet);
AliTRDpadPlane *padPlane = new AliTRDpadPlane(ipla,icha);
Int_t rowMax = padPlane->GetNrows();
Int_t colMax = padPlane->GetNcols();
Int_t ndigits = digits->GetOverThreshold(thresh);
if (ndigits > 0) {
TPolyMarker3D *pmSignal = new TPolyMarker3D(ndigits);
Int_t isignal = 0;
for (Int_t time = 0; time < timeMax; time++) {
for (Int_t col = 0; col < colMax; col++) {
for (Int_t row = 0; row < rowMax; row++) {
Int_t amp = digits->GetDataUnchecked(row,col,time);
if (amp > thresh) {
Double_t glb[3];
Double_t loc[3];
loc[0] = row;
loc[1] = col;
loc[2] = time;
geo->Local2Global(idet,loc,glb);
Double_t x = glb[0];
Double_t y = glb[1];
Double_t z = glb[2];
pmSignal->SetPoint(isignal,x,y,z);
isignal++;
totalsignal++;
}
}
}
}
digits->Compress(1,0);
pmSignal->SetMarkerSize(1);
pmSignal->SetMarkerColor(markerColorSignal);
pmSignal->SetMarkerStyle(1);
pmSignal->Draw();
}
}
delete padPlane;
TGeometry *geoAlice = gAlice->GetGeometry();
TNode *main = (TNode *) ((geoAlice->GetListOfNodes())->First());
TIter next(main->GetListOfNodes());
TNode *module = 0;
while ((module = (TNode *) next())) {
Char_t ch[100];
sprintf(ch,"%s\n",module->GetTitle());
if ((ch[0] == 'T') && ((ch[1] == 'R') || (ch[1] == 'P'))) {
module->SetVisibility( 3);
}
else {
module->SetVisibility(-1);
}
}
geoAlice->Draw("same");
c1->Modified();
c1->Update();
return 0;
}
void TestEMCALSDigit()
{
// Getting EMCAL Detector and Geometry.
AliRunLoader *rl = AliRunLoader::Open("galice.root",AliConfig::GetDefaultEventFolderName(),"read");
if (rl == 0x0)
cout<<"Can not instatiate the Run Loader"<<endl;
rl->LoadgAlice();//Needed to get geometry
AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>
(rl->GetDetectorLoader("EMCAL"));
TGeoManager::Import("geometry.root");
AliRun * alirun = rl->GetAliRun(); // Needed to get Geometry
AliEMCALGeometry * geom ;
if(alirun){
AliEMCAL * emcal = (AliEMCAL*)alirun->GetDetector("EMCAL");
geom = emcal->GetGeometry();
}
if (geom == 0) cout<<"Did not get geometry from EMCALLoader"<<endl;
else geom->PrintGeometry();
//Load Digits
rl->LoadSDigits("EMCAL");
//Get maximum number of events
Int_t maxevent = rl->GetNumberOfEvents();
cout<<"Number of events "<<maxevent<<endl;
//maxevent = 10 ;
Int_t iEvent = -1 ;
Float_t amp = -1 ;
Float_t time = -1 ;
Int_t id = -1 ;
Int_t iSupMod = 0 ;
Int_t iTower = 0 ;
Int_t iIphi = 0 ;
Int_t iIeta = 0 ;
Int_t iphi = 0 ;
Int_t ieta = 0 ;
AliEMCALDigit * dig;
for ( iEvent=0; iEvent<maxevent; iEvent++)
{
cout << " ======> Event " << iEvent << endl ;
//Load Event
rl->GetEvent(iEvent);
//Fill array of digits
TClonesArray *digits = emcalLoader->SDigits();
//Get digits from the list
for(Int_t idig = 0; idig< digits->GetEntries();idig++){
//cout<<">> idig "<<idig<<endl;
dig = static_cast<AliEMCALDigit *>(digits->At(idig)) ;
if(dig != 0){
id = dig->GetId() ; //cell (digit) label
amp = dig->GetAmplitude(); //amplitude in cell (digit)
time = dig->GetTime();//time of creation of digit after collision
cout<<"Cell ID "<<id<<" Amp "<<amp<<endl;//" time "<<time<<endl;
//Geometry methods
if(geom){
geom->GetCellIndex(id,iSupMod,iTower,iIphi,iIeta);
//Gives SuperModule and Tower numbers
geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,
iIphi, iIeta,iphi,ieta);
//Gives label of cell in eta-phi position per each supermodule
cout<< "SModule "<<iSupMod<<"; Tower "<<iTower <<"; Eta "<<iIeta
<<"; Phi "<<iIphi<<"; Cell Eta "<<ieta<<"; Cell Phi "<<iphi<<endl;
}
}
else
cout<<"Digit pointer 0x0"<<endl;
}
}
}
void compClusHitsMod2(int nev=-1)
{
const int kSplit=0x1<<22;
const int kSplCheck=0x1<<23;
//
gSystem->Load("libITSUpgradeBase");
gSystem->Load("libITSUpgradeSim");
gSystem->Load("libITSUpgradeRec");
gROOT->SetStyle("Plain");
AliCDBManager* man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
man->SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
man->SetSpecificStorage("ITS/Align/Data",
Form("local://%s",gSystem->pwd()));
man->SetSpecificStorage("ITS/Calib/RecoParam",
Form("local://%s",gSystem->pwd()));
man->SetRun(0);
TH1F* hL0A = new TH1F("hL0A", "Layer 0, polar angle", 20, 0, TMath::PiOver2());
hL0A->SetDirectory(0);
hL0A->GetXaxis()->SetTitle("#alpha");
TH1F* hL0B = new TH1F("hL0B", "Layer 0, azimuthal angle", 20, 0, TMath::PiOver2());
hL0B->SetDirectory(0);
hL0B->GetXaxis()->SetTitle("#beta");
TH1F* hL1A = new TH1F("hL1A", "Layer 1, polar angle", 20, 0, TMath::PiOver2());
hL1A->SetDirectory(0);
hL1A->GetXaxis()->SetTitle("#alpha");
TH1F* hL1B = new TH1F("hL1B", "Layer 1, azimuthal angle", 20, 0, TMath::PiOver2());
hL1B->SetDirectory(0);
hL1B->GetXaxis()->SetTitle("#beta");
TH1F* hL2A = new TH1F("hL2A", "Layer 2, polar angle", 20, 0, TMath::PiOver2());
hL2A->SetDirectory(0);
hL2A->GetXaxis()->SetTitle("#alpha");
TH1F* hL2B = new TH1F("hL2B", "Layer 2, azimuthal angle", 20, 0, TMath::PiOver2());
hL2B->SetDirectory(0);
hL2B->GetXaxis()->SetTitle("#beta");
TH1F* hL3A = new TH1F("hL3A", "Layer 3, polar angle", 20, 0, TMath::PiOver2());
hL3A->SetDirectory(0);
hL3A->GetXaxis()->SetTitle("#alpha");
TH1F* hL3B = new TH1F("hL3B", "Layer 3, azimuthal angle", 20, 0, TMath::PiOver2());
hL3B->SetDirectory(0);
hL3B->GetXaxis()->SetTitle("#beta");
TH1F* hL4A = new TH1F("hL4A", "Layer 4, polar angle", 20, 0, TMath::PiOver2());
hL4A->SetDirectory(0);
hL4A->GetXaxis()->SetTitle("#alpha");
TH1F* hL4B = new TH1F("hL4B", "Layer 4, azimuthal angle", 20, 0, TMath::PiOver2());
hL4B->SetDirectory(0);
hL4B->GetXaxis()->SetTitle("#beta");
TH1F* hL5A = new TH1F("hL5A", "Layer 5, polar angle", 20, 0, TMath::PiOver2());
hL5A->SetDirectory(0);
hL5A->GetXaxis()->SetTitle("#alpha");
TH1F* hL5B = new TH1F("hL5B", "Layer 5, azimuthal angle", 20, 0, TMath::PiOver2());
hL5B->SetDirectory(0);
hL5B->GetXaxis()->SetTitle("#beta");
TH1F* hL6A = new TH1F("hL6A", "Layer 6, polar angle", 20, 0, TMath::PiOver2());
hL6A->SetDirectory(0);
hL6A->GetXaxis()->SetTitle("#alpha");
TH1F* hL6B = new TH1F("hL6B", "Layer 6, azimuthal angle", 20, 0, TMath::PiOver2());
hL6B->SetDirectory(0);
hL6B->GetXaxis()->SetTitle("#beta");
gAlice=NULL;
AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
runLoader->LoadHeader();
runLoader->LoadKinematics();
runLoader->LoadRecPoints();
runLoader->LoadSDigits();
runLoader->LoadHits();
AliLoader *dl = runLoader->GetDetectorLoader("ITS");
AliGeomManager::LoadGeometry("geometry.root");
TObjArray algITS;
AliGeomManager::LoadAlignObjsFromCDBSingleDet("ITS",algITS);
AliGeomManager::ApplyAlignObjsToGeom(algITS);
//
AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
AliITSMFTClusterPix::SetGeom(gm);
//
AliITSURecoDet *its = new AliITSURecoDet(gm, "ITSinterface");
its->CreateClusterArrays();
//
Double_t xg1,yg1,zg1=0.,xg0,yg0,zg0=0.,tg0;
Double_t xExit,yExit,zExit,xEnt,yEnt,zEnt,tof1;
//
TTree *cluTree = 0x0;
TTree *hitTree = 0x0;
TClonesArray *hitList=new TClonesArray("AliITSMFTHit");
//
Float_t xyzClGloF[3];
Double_t xyzClGlo[3],xyzClTr[3];
Int_t labels[3];
int nLab = 0;
int nlr=its->GetNLayersActive();
int ntotev = (Int_t)runLoader->GetNumberOfEvents();
printf("N Events : %i \n",ntotev);
if (nev>0) ntotev = TMath::Min(nev,ntotev);
//
// output tree
TFile* flOut = TFile::Open("clInfo.root","recreate");
TTree* trOut = new TTree("clitsu","clitsu");
clSumm cSum;
trOut->Branch("evID", &cSum.evID ,"evID/I");
trOut->Branch("volID",&cSum.volID,"volID/I");
trOut->Branch("lrID", &cSum.lrID ,"lrID/I");
trOut->Branch("clID", &cSum.clID ,"clID/I");
trOut->Branch("nPix", &cSum.nPix ,"nPix/I");
trOut->Branch("nX" , &cSum.nX ,"nX/I");
trOut->Branch("nZ" , &cSum.nZ ,"nZ/I");
trOut->Branch("q" , &cSum.q ,"q/I");
trOut->Branch("pt" , &cSum.pt ,"pt/F");
trOut->Branch("eta" ,&cSum.eta ,"eta/F");
trOut->Branch("phi" , &cSum.phi ,"phi/F");
trOut->Branch("xyz", cSum.xyz, "xyz[3]/F");
trOut->Branch("dX" , &cSum.dX ,"dX/F");
trOut->Branch("dY" , &cSum.dY ,"dY/F");
trOut->Branch("dZ" , &cSum.dZ ,"dZ/F");
trOut->Branch("split",&cSum.split,"split/O");
trOut->Branch("prim", &cSum.prim, "prim/O");
trOut->Branch("pdg", &cSum.pdg, "pdg/I");
trOut->Branch("ntr", &cSum.ntr, "ntr/I");
trOut->Branch("alpha", &cSum.alpha, "alpha/F");
trOut->Branch("beta", &cSum.beta, "beta/F");
trOut->Branch("nRowPatt", &cSum.nRowPatt, "nRowPatt/I");
trOut->Branch("nColPatt", &cSum.nColPatt, "nColPatt/I");
TopDatabase DB;
for (Int_t iEvent = 0; iEvent < ntotev; iEvent++) {
printf("\n Event %i \n",iEvent);
runLoader->GetEvent(iEvent);
AliStack *stack = runLoader->Stack();
cluTree=dl->TreeR();
hitTree=dl->TreeH();
hitTree->SetBranchAddress("ITS",&hitList);
//
// read clusters
for (int ilr=nlr;ilr--;) {
TBranch* br = cluTree->GetBranch(Form("ITSRecPoints%d",ilr));
if (!br) {printf("Did not find cluster branch for lr %d\n",ilr); exit(1);}
br->SetAddress(its->GetLayerActive(ilr)->GetClustersAddress());
}
cluTree->GetEntry(0);
its->ProcessClusters();
//
// read hits
for(Int_t iEnt=0;iEnt<hitTree->GetEntries();iEnt++){//entries loop of the hits
hitTree->GetEntry(iEnt);
int nh = hitList->GetEntries();
for(Int_t iHit=0; iHit<nh;iHit++){
AliITSMFTHit *pHit = (AliITSMFTHit*)hitList->At(iHit);
int mcID = pHit->GetTrack();
//printf("MCid: %d %d %d Ch %d\n",iEnt,iHit, mcID, pHit->GetChip());
TClonesArray* harr = arrMCTracks.GetEntriesFast()>mcID ? (TClonesArray*)arrMCTracks.At(mcID) : 0;
if (!harr) {
harr = new TClonesArray("AliITSMFTHit"); // 1st encounter of the MC track
arrMCTracks.AddAtAndExpand(harr,mcID);
}
//
new ( (*harr)[harr->GetEntriesFast()] ) AliITSMFTHit(*pHit);
}
}
// return;
//
// compare clusters and hits
//
printf(" tree entries: %lld\n",cluTree->GetEntries());
//
for (int ilr=0;ilr<nlr;ilr++) {
AliITSURecoLayer* lr = its->GetLayerActive(ilr);
TClonesArray* clr = lr->GetClusters();
int nClu = clr->GetEntries();
//printf("Layer %d : %d clusters\n",ilr,nClu);
//
for (int icl=0;icl<nClu;icl++) {
AliITSMFTClusterPix *cl = (AliITSMFTClusterPix*)clr->At(icl);
int modID = cl->GetVolumeId();
//------------ check if this is a split cluster
int sInL = modID - gm->GetFirstChipIndex(ilr);
if (!cl->TestBit(kSplCheck)) {
cl->SetBit(kSplCheck);
// check if there is no other cluster with same label on this module
AliITSURecoSens* sens = lr->GetSensor(sInL);
int nclSn = sens->GetNClusters();
int offs = sens->GetFirstClusterId();
// printf("To check for %d (mod:%d) N=%d from %d\n",icl,modID,nclSn,offs);
for (int ics=0;ics<nclSn;ics++) {
AliITSMFTClusterPix* clusT = (AliITSMFTClusterPix*)lr->GetCluster(offs+ics); // access to clusters
if (clusT==cl) continue;
for (int ilb0=0;ilb0<3;ilb0++) {
int lb0 = cl->GetLabel(ilb0); if (lb0<=-1) break;
for (int ilb1=0;ilb1<3;ilb1++) {
int lb1 = clusT->GetLabel(ilb1); if (lb1<=-1) break;
if (lb1==lb0) {
cl->SetBit(kSplit);
clusT->SetBit(kSplit);
/*
printf("Discard clusters of module %d:\n",modID);
cl->Print();
clusT->Print();
*/
break;
}
}
}
}
}
//------------
const AliITSMFTSegmentationPix* segm = gm->GetSegmentation(ilr);
//
cl->GetGlobalXYZ(xyzClGloF);
int clsize = cl->GetNPix();
for (int i=3;i--;) xyzClGlo[i] = xyzClGloF[i];
const TGeoHMatrix* mat = gm->GetMatrixSens(modID);
if (!mat) {printf("failed to get matrix for module %d\n",cl->GetVolumeId());}
mat->MasterToLocal(xyzClGlo,xyzClTr);
//
int col,row;
segm->LocalToDet(xyzClTr[0],xyzClTr[2],row,col); // effective col/row
nLab = 0;
for (int il=0;il<3;il++) {
if (cl->GetLabel(il)>=0) labels[nLab++] = cl->GetLabel(il);
else break;
}
// find hit info
for (int il=0;il<nLab;il++) {
TClonesArray* htArr = (TClonesArray*)arrMCTracks.At(labels[il]);
//printf("check %d/%d LB %d %p\n",il,nLab,labels[il],htArr);
if (!htArr) {printf("did not find MChits for label %d ",labels[il]); cl->Print(); continue;}
//
int nh = htArr->GetEntriesFast();
AliITSMFTHit *pHit=0;
for (int ih=nh;ih--;) {
AliITSMFTHit* tHit = (AliITSMFTHit*)htArr->At(ih);
if (tHit->GetChip()!=modID) continue;
pHit = tHit;
break;
}
if (!pHit) {
printf("did not find MChit for label %d on module %d ",il,modID);
cl->Print();
htArr->Print();
continue;
}
//
pHit->GetPositionG(xg1,yg1,zg1);
pHit->GetPositionG0(xg0,yg0,zg0,tg0);
//
double txyzH[3],gxyzH[3] = { (xg1+xg0)/2, (yg1+yg0)/2, (zg1+zg0)/2 };
mat->MasterToLocal(gxyzH,txyzH);
double rcl = TMath::Sqrt(xyzClTr[0]*xyzClTr[0]+xyzClTr[1]*xyzClTr[1]);
double rht = TMath::Sqrt(txyzH[0]*txyzH[0]+txyzH[1]*txyzH[1]);
//
//Angles determination
pHit->GetPositionL(xExit,yExit,zExit,gm);
pHit->GetPositionL0(xEnt,yEnt,zEnt,tof1,gm);
Double_t dirHit[3]={(xExit-xEnt),(yExit-yEnt),(zExit-zEnt)};
/*double PG[3] = {(double)pHit->GetPXG(), (double)pHit->GetPYG(), (double)pHit->GetPZG()}; //Momentum at hit-point in Global Frame
double PL[3];
if (TMath::Abs(PG[0])<10e-7 && TMath::Abs(PG[1])<10e-7) {
pHit->Dump();
int lb = pHit->GetTrack();
stack->Particle(lb)->Print();
continue;
}
mat->MasterToLocalVect(PG,PL); //Momentum in local Frame
//printf(">> %e %e %e %e %e %e\n",PG[0],PL[0],PG[1],PL[1],PG[2],PL[2]);*/
Double_t alpha1 = TMath::ACos(TMath::Abs(dirHit[1])/TMath::Sqrt(dirHit[0]*dirHit[0]+dirHit[1]*dirHit[1]+dirHit[2]*dirHit[2])); //Polar Angle
Float_t alpha2 = (Float_t) alpha1; //convert to float
cSum.alpha = alpha2;
Double_t beta1;
beta1 = TMath::ATan2(dirHit[0],dirHit[2]); //Azimuthal angle, values from -Pi to Pi
Float_t beta2 = (Float_t) beta1;
cSum.beta = beta2;
if(ilr==0){
hL0A->Fill(alpha2);
hL0B->Fill(beta2);
}
if(ilr==1){
hL1A->Fill(alpha2);
hL1B->Fill(beta2);
}
if(ilr==2){
hL2A->Fill(alpha2);
hL2B->Fill(beta2);
}
if(ilr==3){
hL3A->Fill(alpha2);
hL3B->Fill(beta2);
}
if(ilr==4){
hL4A->Fill(alpha2);
hL4B->Fill(beta2);
}
if(ilr==5){
hL5A->Fill(alpha2);
hL5B->Fill(beta2);
}
if(ilr==6){
hL6A->Fill(alpha2);
hL6B->Fill(beta2);
}
GetHistoClSize(clsize,kDR,&histoArr)->Fill((rht-rcl)*1e4);
if (cl->TestBit(kSplit)) {
if (col%2) GetHistoClSize(clsize,kDTXoddSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXevenSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZSPL,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixSPL,&histoArr)->Fill(clsize);
}
if (col%2) GetHistoClSize(clsize,kDTXodd,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXeven,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZ,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixAll,&histoArr)->Fill(clsize);
//
cSum.evID = iEvent;
cSum.volID = cl->GetVolumeId();
cSum.lrID = ilr;
cSum.clID = icl;
cSum.nPix = cl->GetNPix();
cSum.nX = cl->GetNx();
cSum.nZ = cl->GetNz();
cSum.q = cl->GetQ();
cSum.split = cl->TestBit(kSplit);
cSum.dX = (txyzH[0]-xyzClTr[0])*1e4;
cSum.dY = (txyzH[1]-xyzClTr[1])*1e4;
cSum.dZ = (txyzH[2]-xyzClTr[2])*1e4;
cSum.nRowPatt = cl-> GetPatternRowSpan();
cSum.nColPatt = cl-> GetPatternColSpan();
DB.AccountTopology(*cl, cSum.dX, cSum.dZ, cSum.alpha, cSum.beta);
GetHistoClSize(clsize,kDR,&histoArr)->Fill((rht-rcl)*1e4);
if (cl->TestBit(kSplit)) {
if (col%2) GetHistoClSize(clsize,kDTXoddSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXevenSPL,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZSPL,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixSPL,&histoArr)->Fill(clsize);
}
if (col%2) GetHistoClSize(clsize,kDTXodd,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
else GetHistoClSize(clsize,kDTXeven,&histoArr)->Fill((txyzH[0]-xyzClTr[0])*1e4);
GetHistoClSize(clsize,kDTZ,&histoArr)->Fill((txyzH[2]-xyzClTr[2])*1e4);
GetHistoClSize(0,kNPixAll,&histoArr)->Fill(clsize);
//
cSum.evID = iEvent;
cSum.volID = cl->GetVolumeId();
cSum.lrID = ilr;
cSum.clID = icl;
cSum.nPix = cl->GetNPix();
cSum.nX = cl->GetNx();
cSum.nZ = cl->GetNz();
cSum.q = cl->GetQ();
cSum.split = cl->TestBit(kSplit);
cSum.dX = (txyzH[0]-xyzClTr[0])*1e4;
cSum.dY = (txyzH[1]-xyzClTr[1])*1e4;
cSum.dZ = (txyzH[2]-xyzClTr[2])*1e4;
cSum.nRowPatt = cl-> GetPatternRowSpan();
cSum.nColPatt = cl-> GetPatternColSpan();
int label = cl->GetLabel(0);
TParticle* part = 0;
if (label>=0 && (part=stack->Particle(label)) ) {
cSum.pdg = part->GetPdgCode();
cSum.eta = part->Eta();
cSum.pt = part->Pt();
cSum.phi = part->Phi();
cSum.prim = stack->IsPhysicalPrimary(label);
}
cSum.ntr = 0;
for (int ilb=0;ilb<3;ilb++) if (cl->GetLabel(ilb)>=0) cSum.ntr++;
for (int i=0;i<3;i++) cSum.xyz[i] = xyzClGloF[i];
//
trOut->Fill();
/*
if (clsize==5) {
printf("\nL%d(%c) Mod%d, Cl:%d | %+5.1f %+5.1f (%d/%d)|H:%e %e %e | C:%e %e %e\n",ilr,cl->TestBit(kSplit) ? 'S':'N',
modID,icl,(txyzH[0]-xyzClTr[0])*1e4,(txyzH[2]-xyzClTr[2])*1e4, row,col,
gxyzH[0],gxyzH[1],gxyzH[2],xyzClGlo[0],xyzClGlo[1],xyzClGlo[2]);
cl->Print();
pHit->Print();
//
double a0,b0,c0,a1,b1,c1,e0;
pHit->GetPositionL0(a0,b0,c0,e0);
pHit->GetPositionL(a1,b1,c1);
float cloc[3];
cl->GetLocalXYZ(cloc);
printf("LocH: %e %e %e | %e %e %e\n",a0,b0,c0,a1,b1,c1);
printf("LocC: %e %e %e | %e %e %e\n",cloc[0],cloc[1],cloc[2],xyzClTr[0],xyzClTr[1],xyzClTr[2]);
}
*/
//
}
}
}
// layerClus.Clear();
//
arrMCTracks.Delete();
}//event loop
//
DB.EndAndSort();
DB.SetThresholdCumulative(0.95);
cout << "Over threshold: : "<< DB.GetOverThr()<<endl;
DB.Grouping(10,10);
DB.PrintDB("Database1.txt");
flOut->cd();
trOut->Write();
delete trOut;
flOut->Close();
flOut->Delete();
DrawReport("clinfo.ps",&histoArr);
TFile* flDB = TFile::Open("TopologyDatabase.root", "recreate");
flDB->WriteObject(&DB,"DB","kSingleKey");
flDB->Close();
delete flDB;
TCanvas* cnv123 = new TCanvas("cnv123","cnv123");
cnv123->Divide(1,2);
cnv123->Print("anglesdistr.pdf[");
cnv123->cd(1);
hL0A->Draw();
cnv123->cd(2);
hL0B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL1A->Draw();
cnv123->cd(2);
hL1B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL2A->Draw();
cnv123->cd(2);
hL2B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL3A->Draw();
cnv123->cd(2);
hL3B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL4A->Draw();
cnv123->cd(2);
hL4B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL5A->Draw();
cnv123->cd(2);
hL5B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->cd(1);
hL6A->Draw();
cnv123->cd(2);
hL6B->Draw();
cnv123->Print("anglesdistr.pdf");
cnv123->Print("anglesdistr.pdf]");
//
}
Int_t TOFquickanal(Int_t eventNumber = 0)
{
/////////////////////////////////////////////////////////////////////////
// This macro is a small example of a ROOT macro
// illustrating how to read the output of GALICE
// and fill some histograms concerning the TOF Hit Tree.
//
// Root > .L TOFquickanal.C //this loads the macro in memory
// Root > TOFquickanal(); //by default process first event
// Root > TOFquickanal(2); //process third event
//Begin_Html
/*
<img src="picts/TOFquickanal.gif">
*/
//End_Html
//
// Author: F. Pierella , Bologna University 12-04-2001
// Updated to the new I/O by: A. De Caro, C. Zampolli
/////////////////////////////////////////////////////////////////////////
// Dynamically link some shared libs
if (gClassTable->GetID("AliRun") < 0) {
gROOT->LoadMacro("loadlibs.C");
loadlibs();
}
Int_t rc = 0;
AliRunLoader *rl =AliRunLoader::Open("galice.root",AliConfig::GetDefaultEventFolderName(),"update");
if (!rl)
{
cerr << "Can't load RunLoader from file!\n";
rc = 1;
return rc;
}
rl->LoadgAlice();
gAlice=rl->GetAliRun();
if (!gAlice)
{
cerr << "<TOFquickanal> AliRun object not found on file \n";
rc = 2;
return rc;
}
// Get the pointer to the TOF detector
AliLoader *tofl = rl->GetLoader("TOFLoader");
AliTOF * tof = (AliTOF*) gAlice->GetDetector("TOF");
if (tof == 0x0 || tofl == 0x0) {
cerr << "<TOFquickanal> Can not find TOF or TOFLoader\n";
rc = 3;
return rc;
}
//=======> Create histograms
//---> Time of Flight for Primary Particles (ns)
TH1F *htofprim = new TH1F("htofprim","Time of Flight for Primary Particles",100,0.,100.);
//--->Time of Flight for Secondary Particles (ns)
TH1F *htofsec = new TH1F("htofsec","Time of Flight for Secondary Particles",100,0.,100.);
//---> r (radius) coordinate of production in the ALICE frame for secondary particles that produce at
// least one TOF-hit (cm) - cylindrical coordinate system assumed, primary plus secondary-
TH1F *hradius = new TH1F("hradius","r (radius) coordinate at the production vertex for secondary particles with at least one TOF-Hit",50,0.,500.);
//---> Momentum of primary particles that produce (at least) one TOF-hit when the hit
// is produced (Gev/c)
TH1F *htofmom = new TH1F("htofmom","Momentum of primary particles when the Hit is produced",50,0.,5.);
//---> Momentum of primary particles that produce (at least) one TOF-hit at the production vertex
// (Gev/c)
TH1F *hprodmom = new TH1F("hprodmom","Momentum of primary particles (with at least one TOF hit) at the production ",50,0.,5.);
//---> Theta of production for primary particles that produce (at least) one TOF-hit (deg)
TH1F *hprodthe = new TH1F("hprodthe","Theta of primary particles (with at least one TOF hit) at the production ",90,0.,180.);
//---> Phi of production for primary particles that produce (at least) one TOF-hit (deg)
TH1F *hprodphi = new TH1F("hprodphi","Phi of primary particles (with at least one TOF hit) at the production ",180,-180.,180.);
//---> z Coordinate of the TOF Hit (z beam axis) - primary plus secondary - (cm)
TH1F *hzcoor = new TH1F("hzcoor","z Coordinate of the TOF Hit",800,-400.,400.);
//---> Incidence Angle of the particle on the pad (or strip) (deg) - primary plus secondary -
TH1F *hincangle = new TH1F("hincangle","Incidence Angle of the particle on the strip",90,0.,180.);
printf ("Processing event %d \n", eventNumber);
rl->GetEvent(eventNumber);
// Get pointers to Alice detectors and Hits containers
tofl->LoadHits();
TTree *TH = tofl->TreeH();
tof->SetTreeAddress();
if (!TH) {
cout << "<TOFquickanal> No hit tree found" << endl;
rc = 4;
return rc;
}
// Import the Kine Tree for the event eventNumber in the file
rl->LoadHeader();
rl->LoadKinematics();
//AliStack * stack = rl->Stack();
Int_t ntracks = TH->GetEntries();
cout<<" ntracks = "<<ntracks<<endl;
AliTOFhitT0 *tofHit;
// Start loop on tracks in the hits containers
for (Int_t track=0; track<ntracks;track++) {
tof->ResetHits();
TH->GetEvent(track);
for(tofHit=(AliTOFhitT0*)tof->FirstHit(track); tofHit; tofHit=(AliTOFhitT0*)tof->NextHit()) {
Float_t toflight = tofHit->GetTof();
toflight *= 1.E+09; // conversion from s to ns
Double_t tofmom = tofHit->GetMom();
Int_t ipart = tofHit->Track();
TParticle *particle = gAlice->Particle(ipart);
if (particle->GetFirstMother() < 0) {
htofprim->Fill(toflight);
htofmom->Fill(tofmom);
} else {
htofsec->Fill(toflight);
}
Double_t zcoor = tofHit->Z();
hzcoor->Fill(zcoor);
Double_t incangle = tofHit->GetIncA();
hincangle->Fill(incangle);
Double_t xcoor = particle->Vx();
Double_t ycoor = particle->Vy();
Double_t radius = TMath::Sqrt(xcoor*xcoor+ycoor*ycoor);
if (particle->GetFirstMother() >= 0) hradius->Fill(radius);
Double_t prodmom = particle->P();
if (prodmom!=0.) {
Double_t dummy = (particle->Pz())/prodmom;
Double_t prodthe = TMath::ACos(dummy);
prodthe *= 57.29578; // conversion from rad to deg
if (particle->GetFirstMother() < 0) hprodthe->Fill(prodthe);
} // theta at production vertex
if (particle->GetFirstMother() < 0) {
hprodmom->Fill(prodmom);
Double_t dummypx = particle->Px();
Double_t dummypy = particle->Py();
Double_t prodphi = TMath::ATan2(dummypy,dummypx);
prodphi *= 57.29578; // conversion from rad to deg
hprodphi->Fill(prodphi);
} // phi at production vertex
} // close loop on TOF-hits
} // close loop on tracks in the hits containers
//Create canvas, set the view range, show histograms
TCanvas *c1 = new TCanvas("c1","Alice TOF hits quick analysis",400,10,600,700);
c1->cd();
hprodmom->Draw();
TCanvas *c2 = new TCanvas("c2","Alice TOF hits quick analysis",400,10,600,700);
c2->cd();
hprodthe->Draw();
TCanvas *c3 = new TCanvas("c3","Alice TOF hits quick analysis",400,10,600,700);
c3->cd();
hprodphi->Draw();
TCanvas *c4 = new TCanvas("c4","Alice TOF hits quick analysis",400,10,600,700);
c4->cd();
hzcoor->Draw();
TCanvas *c5 = new TCanvas("c5","Alice TOF hits quick analysis",400,10,600,700);
c5->cd();
hradius->Draw();
TCanvas *c6 = new TCanvas("c6","Alice TOF hits quick analysis",400,10,600,700);
c6->cd();
htofprim->Draw();
TCanvas *c7 = new TCanvas("c7","Alice TOF hits quick analysis",400,10,600,700);
c7->cd();
htofsec->Draw();
TCanvas *c8 = new TCanvas("c8","Alice TOF hits quick analysis",400,10,600,700);
c8->cd();
htofmom->Draw();
TCanvas *c9 = new TCanvas("c9","Alice TOF hits quick analysis",400,10,600,700);
c9->cd();
hincangle->Draw();
//tofl->UnloadHits();
//rl->UnloadHeader();
//rl->UnloadgAlice();
//rl->UnloadKinematics();
return rc;
}
Int_t AliITSHits2SDigits(TString filename = "galice.root")
{
// Standard ITS Hits to SDigits.
// Dynamically link some shared libs
if (gClassTable->GetID("AliRun") < 0) {
gROOT->ProcessLine(".x $(ALICE_ROOT)/macros/loadlibs.C");
}else if (gAlice){
delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
}
// Connect the Root Galice file containing Geometry, Kine and Hits
AliRunLoader* rl = AliRunLoader::Open(filename);
if (rl == 0x0)
{
cerr<<"AliITSHits2SDigits.C : Can not open session RL=NULL"
<< endl;
return 3;
}
Int_t retval = rl->LoadgAlice();
if (retval)
{
cerr<<"AliITSHits2SDigits.C : LoadgAlice returned error"
<< endl;
return 3;
}
gAlice=rl->GetAliRun();
AliITSLoader* gime = (AliITSLoader*) rl->GetLoader("ITSLoader");
if (gime == 0x0)
{
cerr<<"AliITSHits2SDigits.C : can not get ITS loader"
<< endl;
}
AliITS *ITS = (AliITS*)gAlice->GetDetector("ITS");
if (!ITS) {
cerr<<"AliITSHits2SDigits.C : AliITS object not found on file"
<< endl;
return 3;
} // end if !ITS
if(!(ITS->GetITSgeom())){
cerr << " AliITSgeom not found. Can't digitize without it." << endl;
return 4;
} // end if
TStopwatch timer;
Int_t evNumber1 = 0;
Int_t evNumber2 = AliRunLoader::GetNumberOfEvents();
timer.Start();
retval = gime->LoadHits();
if (retval)
{
cerr<<"AliITSHits2SDigits.C : ITSLoader::LoadHits returned error"
<< endl;
return 3;
}
retval = gime->LoadSDigits("recreate");
if (retval)
{
cerr<<"AliITSHits2SDigits.C : ITSLoader::LoadSDigits returned error"
<< endl;
return 3;
}
for(Int_t event = evNumber1; event < evNumber2; event++){
rl->GetEvent(event);
if(!gime->TreeS()){
cout << "Having to create the SDigits Tree." << endl;
gime->MakeTree("S");
} // end
ITS->MakeBranch("S");
ITS->SetTreeAddress();
cout<<"Making ITS SDigits for event "<<event<<endl;
ITS->Hits2SDigits();
} // end for event
timer.Stop();
timer.Print();
delete rl; // sdigfile is closed by deleting gAlice if != hitfile.
return 0;
}
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 MatchComparison()
{
//
// Initialize AliRun manager
//
//
// Initialize run loader and load Kinematics
//
AliRunLoader *runLoader = AliRunLoader::Open("galice.root");
if (!runLoader) return;
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
runLoader->LoadKinematics();
//
// Initialize histograms with their error computation
//
TH1D *hgood = new TH1D("hgood", "Well matched tracks", 40, 0.0, 40.0);
TH1D *hfake = new TH1D("hfake", "Fake matched tracks", 40, 0.0, 40.0);
TH1D *htrue = new TH1D("htrue", "True matches" , 40, 0.0, 40.0);
TH1D *hfound = new TH1D("hfound","Found matches" , 40, 0.0, 40.0);
hgood->Sumw2();
hfake->Sumw2();
htrue->Sumw2();
hfound->Sumw2();
//
// Open file containing true matches,
// retrieve the Tree and link to a cursor.
//
TFile *fileTrue = TFile::Open("true-matches.root");
match_t trueMatch;
//
// Open file of found matches,
// link the modified ESD container.
//
TFile *fileFound = TFile::Open("matchESD.root");
TTree *treeFound = (TTree*)fileFound->Get("esdTree");
AliESDEvent* esd = new AliESDEvent();
esd->ReadFromTree(treeFound);
Long64_t nEvents = treeFound->GetEntries();
//
// Loop on all events
//
Int_t im, it, ic, nTrueMatches, nTracks;
Int_t label, trkLabel, cluLabel;
for (Long64_t iev = 0; iev < nEvents; iev++) {
// get true matches tree of given event
TTree *treeTrue = (TTree*)fileTrue->Get(Form("tm_%d", iev));
treeTrue->SetBranchAddress("matches", &trueMatch);
nTrueMatches = treeTrue->GetEntries();
// set TTree pointers to selected event
runLoader->GetEvent(iev);
treeFound->GetEntry(iev);
AliStack *stack = runLoader->Stack();
nTracks = esd->GetNumberOfTracks();
// read all true pairs
for (im = 0; im < nTrueMatches; im++) {
treeTrue->GetEntry(im);
AliESDtrack *track = esd->GetTrack(trueMatch.indexT);
if (!track) continue;
label = TMath::Abs(track->GetLabel());
TParticle *p = stack->Particle(label);
htrue->Fill(p->Pt());
cout <<"filling true"<< endl;
}
// compare found matches
for (Int_t it = 0; it < nTracks; it++) {
AliESDtrack *track = esd->GetTrack(it);
ic = track->GetEMCALcluster();
if (ic == AliEMCALTracker::kUnmatched) continue;
ic = TMath::Abs(ic);
AliESDCaloCluster *cl = esd->GetCaloCluster(ic);
if (!cl) continue;
if (!cl->IsEMCAL()) continue ;
trkLabel = TMath::Abs(track->GetLabel());
cluLabel = cl->GetLabel();
if (trkLabel == cluLabel && trkLabel >= 0) {
TParticle *p = stack->Particle(TMath::Abs(trkLabel));
hgood->Fill(p->Pt());
hfound->Fill(p->Pt());
cout <<"filling GOOD, pt:" << p->Pt()<< endl;
}
else {
TParticle *p = stack->Particle(TMath::Abs(trkLabel));
hfake->Fill(p->Pt());
hfound->Fill(p->Pt());
cout <<"filling FAKE" << endl;
}
}
}
cout << "True matches : " << htrue->GetEntries() << endl;
cout << "Found matches: " << hfound->GetEntries() << endl;
cout << "Good matches : " << hgood->GetEntries() << endl;
cout << "Fake matches : " << hfake->GetEntries() << endl;
TFile *fout = TFile::Open("match-comparison.root", "RECREATE");
hgood->Write();
hfake->Write();
htrue->Write();
hfound->Write();
fout->Close();
}
void MUONTrigger(const char* filename)
{
// Creating Run Loader and openning file containing Digits
AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONLoader","UPDATE");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",filename);
return;
}
// Loading AliRun master
if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
gAlice = RunLoader->GetAliRun();
// Loading MUON subsystem
AliLoader* MUONLoader = RunLoader->GetDetectorLoader("MUON");
MUONLoader->LoadDigits("READ");
MUONLoader->LoadRecPoints("UPDATE"); // absolutely essential !!!
// Creating MUONTriggerDecision
AliCDBManager* cdbManager = AliCDBManager::Instance();
cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
Int_t runnumber = 0;
cdbManager->SetRun(runnumber);
AliMpCDB::LoadDDLStore();
AliMUONCalibrationData *CalibrationData = new AliMUONCalibrationData(runnumber);
AliMUONTriggerElectronics *TriggerProcessor = new AliMUONTriggerElectronics(CalibrationData);
Int_t nevents = RunLoader->GetNumberOfEvents();
AliMUONVDigitStore* digitStore=0x0;
AliMUONVTriggerStore* triggerStore=0x0;
for(Int_t ievent = 0; ievent < nevents; ievent++) {
printf(">>> Event %i out of %i \n",ievent,nevents);
RunLoader->GetEvent(ievent);
MUONLoader->LoadRecPoints("update");
MUONLoader->CleanRecPoints();
MUONLoader->MakeRecPointsContainer();
TTree* clustersTree = MUONLoader->TreeR();
TFile* cfile = clustersTree->GetCurrentFile();
if ( !cfile )
{
cout << " could not find Cluster file " << endl;
return;
}
MUONLoader->LoadDigits("read");
TTree* digitsTree = MUONLoader->TreeD();
TFile* dfile = digitsTree->GetCurrentFile();
if ( !dfile )
{
cout << " could not find Digit file " << endl;
return;
}
// here start reconstruction
if (!digitStore) digitStore = AliMUONVDigitStore::Create(*digitsTree);
if (!triggerStore) triggerStore = AliMUONVTriggerStore::Create(*digitsTree);
// insure we start with empty stores
if ( digitStore )
{
digitStore->Clear();
Bool_t alone = ( triggerStore ? kFALSE : kTRUE );
Bool_t ok = digitStore->Connect(*digitsTree,alone);
if (!ok)
{
cerr << "Could not connect digitStore to digitsTree \n";
return;
}
} else {
cerr << "digitStore does not exist " << "\n";
return;
}
digitsTree->GetEvent(0);
// process trigger response
TriggerProcessor->Digits2Trigger(*digitStore,*triggerStore);
//triggerStore->Print();
Bool_t ok(kFALSE);
if ( triggerStore ) {
ok = triggerStore->Connect(*clustersTree,kTRUE);
if (!ok)
{
cerr << "Could not create triggerStore branches in TreeR " << "\n";
return;
}
} else {
cerr << "triggerStore does not exist " << "\n";
return;
}
// fill TreeR
clustersTree->Fill();
MUONLoader->UnloadDigits();
MUONLoader->WriteRecPoints("OVERWRITE");
MUONLoader->UnloadRecPoints();
} // loop on events
}
Bool_t CheckESD(const char* gAliceFileName = "galice.root",
const char* esdFileName = "AliESDs.root")
{
// open run loader and load gAlice, kinematics and header
AliRunLoader* runLoader = AliRunLoader::Open(gAliceFileName);
if (!runLoader) {
Error("CheckESD", "getting run loader from file %s failed",
gAliceFileName);
return kFALSE;
}
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
Error("CheckESD", "no galice object found");
return kFALSE;
}
runLoader->LoadKinematics();
runLoader->LoadHeader();
// open the ESD file
TFile* esdFile = TFile::Open(esdFileName);
if (!esdFile || !esdFile->IsOpen()) {
Error("CheckESD", "opening ESD file %s failed", esdFileName);
return kFALSE;
}
AliESDEvent * esd = new AliESDEvent;
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree) {
Error("CheckESD", "no ESD tree found");
return kFALSE;
}
esd->ReadFromTree(tree);
// loop over events
for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
runLoader->GetEvent(iEvent);
// get the event summary data
tree->GetEvent(iEvent);
if (!esd) {
Error("CheckESD", "no ESD object found for event %d", iEvent);
return kFALSE;
}
}
// write the output histograms to a file
TFile* outputFile = TFile::Open("check.root", "recreate");
if (!outputFile || !outputFile->IsOpen()) {
Error("CheckESD", "opening output file check.root failed");
return kFALSE;
}
outputFile->Close();
delete outputFile;
delete esd;
esdFile->Close();
delete esdFile;
runLoader->UnloadHeader();
runLoader->UnloadKinematics();
delete runLoader;
// result of check
Info("CheckESD", "check of ESD was successfull");
return kTRUE;
}
Bool_t CheckESD(const char* gAliceFileName = "galice.root",
const char* esdFileName = "AliESDs.root")
{
// check the content of the ESD
// check values
Int_t checkNGenLow = 1;
Double_t checkEffLow = 0.5;
Double_t checkEffSigma = 3;
Double_t checkFakeHigh = 0.5;
Double_t checkFakeSigma = 3;
Double_t checkResPtInvHigh = 5;
Double_t checkResPtInvSigma = 3;
Double_t checkResPhiHigh = 10;
Double_t checkResPhiSigma = 3;
Double_t checkResThetaHigh = 10;
Double_t checkResThetaSigma = 3;
Double_t checkPIDEffLow = 0.5;
Double_t checkPIDEffSigma = 3;
Double_t checkResTOFHigh = 500;
Double_t checkResTOFSigma = 3;
Double_t checkPHOSNLow = 5;
Double_t checkPHOSEnergyLow = 0.3;
Double_t checkPHOSEnergyHigh = 1.0;
Double_t checkEMCALNLow = 50;
Double_t checkEMCALEnergyLow = 0.05;
Double_t checkEMCALEnergyHigh = 1.0;
Double_t checkMUONNLow = 1;
Double_t checkMUONPtLow = 0.5;
Double_t checkMUONPtHigh = 10.;
Double_t cutPtV0 = 0.3;
Double_t checkV0EffLow = 0.02;
Double_t checkV0EffSigma = 3;
Double_t cutPtCascade = 0.5;
Double_t checkCascadeEffLow = 0.01;
Double_t checkCascadeEffSigma = 3;
// open run loader and load gAlice, kinematics and header
AliRunLoader* runLoader = AliRunLoader::Open(gAliceFileName);
if (!runLoader) {
Error("CheckESD", "getting run loader from file %s failed",
gAliceFileName);
return kFALSE;
}
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
if (!gAlice) {
Error("CheckESD", "no galice object found");
return kFALSE;
}
runLoader->LoadKinematics();
runLoader->LoadHeader();
// open the ESD file
TFile* esdFile = TFile::Open(esdFileName);
if (!esdFile || !esdFile->IsOpen()) {
Error("CheckESD", "opening ESD file %s failed", esdFileName);
return kFALSE;
}
AliESDEvent * esd = new AliESDEvent;
TTree* tree = (TTree*) esdFile->Get("esdTree");
if (!tree) {
Error("CheckESD", "no ESD tree found");
return kFALSE;
}
esd->ReadFromTree(tree);
// efficiency and resolution histograms
Int_t nBinsPt = 15;
Float_t minPt = 0.1;
Float_t maxPt = 3.1;
TH1F* hGen = CreateHisto("hGen", "generated tracks",
nBinsPt, minPt, maxPt, "p_{t} [GeV/c]", "N");
TH1F* hRec = CreateHisto("hRec", "reconstructed tracks",
nBinsPt, minPt, maxPt, "p_{t} [GeV/c]", "N");
Int_t nGen = 0;
Int_t nRec = 0;
Int_t nFake = 0;
TH1F* hResPtInv = CreateHisto("hResPtInv", "", 100, -10, 10,
"(p_{t,rec}^{-1}-p_{t,sim}^{-1}) / p_{t,sim}^{-1} [%]", "N");
TH1F* hResPhi = CreateHisto("hResPhi", "", 100, -20, 20,
"#phi_{rec}-#phi_{sim} [mrad]", "N");
TH1F* hResTheta = CreateHisto("hResTheta", "", 100, -20, 20,
"#theta_{rec}-#theta_{sim} [mrad]", "N");
// PID
Int_t partCode[AliPID::kSPECIES] =
{kElectron, kMuonMinus, kPiPlus, kKPlus, kProton};
const char* partName[AliPID::kSPECIES+1] =
{"electron", "muon", "pion", "kaon", "proton", "other"};
Double_t partFrac[AliPID::kSPECIES] =
{0.01, 0.01, 0.85, 0.10, 0.05};
Int_t identified[AliPID::kSPECIES+1][AliPID::kSPECIES];
for (Int_t iGen = 0; iGen < AliPID::kSPECIES+1; iGen++) {
for (Int_t iRec = 0; iRec < AliPID::kSPECIES; iRec++) {
identified[iGen][iRec] = 0;
}
}
Int_t nIdentified = 0;
// dE/dx and TOF
TH2F* hDEdxRight = new TH2F("hDEdxRight", "", 300, 0, 3, 100, 0, 400);
hDEdxRight->SetStats(kFALSE);
hDEdxRight->GetXaxis()->SetTitle("p [GeV/c]");
hDEdxRight->GetYaxis()->SetTitle("dE/dx_{TPC}");
hDEdxRight->SetMarkerStyle(kFullCircle);
hDEdxRight->SetMarkerSize(0.4);
TH2F* hDEdxWrong = new TH2F("hDEdxWrong", "", 300, 0, 3, 100, 0, 400);
hDEdxWrong->SetStats(kFALSE);
hDEdxWrong->GetXaxis()->SetTitle("p [GeV/c]");
hDEdxWrong->GetYaxis()->SetTitle("dE/dx_{TPC}");
hDEdxWrong->SetMarkerStyle(kFullCircle);
hDEdxWrong->SetMarkerSize(0.4);
hDEdxWrong->SetMarkerColor(kRed);
TH1F* hResTOFRight = CreateHisto("hResTOFRight", "", 100, -1000, 1000,
"t_{TOF}-t_{track} [ps]", "N");
TH1F* hResTOFWrong = CreateHisto("hResTOFWrong", "", 100, -1000, 1000,
"t_{TOF}-t_{track} [ps]", "N");
hResTOFWrong->SetLineColor(kRed);
// calorimeters
TH1F* hEPHOS = CreateHisto("hEPHOS", "PHOS", 100, 0, 50, "E [GeV]", "N");
TH1F* hEEMCAL = CreateHisto("hEEMCAL", "EMCAL", 100, 0, 50, "E [GeV]", "N");
// muons
TH1F* hPtMUON = CreateHisto("hPtMUON", "MUON", 100, 0, 20,
"p_{t} [GeV/c]", "N");
// V0s and cascades
TH1F* hMassK0 = CreateHisto("hMassK0", "K^{0}", 100, 0.4, 0.6,
"M(#pi^{+}#pi^{-}) [GeV/c^{2}]", "N");
TH1F* hMassLambda = CreateHisto("hMassLambda", "#Lambda", 100, 1.0, 1.2,
"M(p#pi^{-}) [GeV/c^{2}]", "N");
TH1F* hMassLambdaBar = CreateHisto("hMassLambdaBar", "#bar{#Lambda}",
100, 1.0, 1.2,
"M(#bar{p}#pi^{+}) [GeV/c^{2}]", "N");
Int_t nGenV0s = 0;
Int_t nRecV0s = 0;
TH1F* hMassXi = CreateHisto("hMassXi", "#Xi", 100, 1.2, 1.5,
"M(#Lambda#pi) [GeV/c^{2}]", "N");
TH1F* hMassOmega = CreateHisto("hMassOmega", "#Omega", 100, 1.5, 1.8,
"M(#LambdaK) [GeV/c^{2}]", "N");
Int_t nGenCascades = 0;
Int_t nRecCascades = 0;
// loop over events
for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
runLoader->GetEvent(iEvent);
// select simulated primary particles, V0s and cascades
AliStack* stack = runLoader->Stack();
Int_t nParticles = stack->GetNtrack();
TArrayF vertex(3);
runLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vertex);
TObjArray selParticles;
TObjArray selV0s;
TObjArray selCascades;
for (Int_t iParticle = 0; iParticle < nParticles; iParticle++) {
TParticle* particle = stack->Particle(iParticle);
if (!particle) continue;
if (particle->Pt() < 0.001) continue;
if (TMath::Abs(particle->Eta()) > 0.9) continue;
TVector3 dVertex(particle->Vx() - vertex[0],
particle->Vy() - vertex[1],
particle->Vz() - vertex[2]);
if (dVertex.Mag() > 0.0001) continue;
switch (TMath::Abs(particle->GetPdgCode())) {
case kElectron:
case kMuonMinus:
case kPiPlus:
case kKPlus:
case kProton: {
if (particle->Pt() > minPt) {
selParticles.Add(particle);
nGen++;
hGen->Fill(particle->Pt());
}
break;
}
case kK0Short:
case kLambda0: {
if (particle->Pt() > cutPtV0) {
nGenV0s++;
selV0s.Add(particle);
}
break;
}
case kXiMinus:
case kOmegaMinus: {
if (particle->Pt() > cutPtCascade) {
nGenCascades++;
selCascades.Add(particle);
}
break;
}
default: break;
}
}
// get the event summary data
tree->GetEvent(iEvent);
if (!esd) {
Error("CheckESD", "no ESD object found for event %d", iEvent);
return kFALSE;
}
// loop over tracks
for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
AliESDtrack* track = esd->GetTrack(iTrack);
// select tracks of selected particles
Int_t label = TMath::Abs(track->GetLabel());
if (label > stack->GetNtrack()) continue; // background
TParticle* particle = stack->Particle(label);
if (!selParticles.Contains(particle)) continue;
if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) continue;
if (track->GetConstrainedChi2() > 1e9) continue;
selParticles.Remove(particle); // don't count multiple tracks
nRec++;
hRec->Fill(particle->Pt());
if (track->GetLabel() < 0) nFake++;
// resolutions
hResPtInv->Fill(100. * (TMath::Abs(track->GetSigned1Pt()) - 1./particle->Pt()) *
particle->Pt());
hResPhi->Fill(1000. * (track->Phi() - particle->Phi()));
hResTheta->Fill(1000. * (track->Theta() - particle->Theta()));
// PID
if ((track->GetStatus() & AliESDtrack::kESDpid) == 0) continue;
Int_t iGen = 5;
for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
if (TMath::Abs(particle->GetPdgCode()) == partCode[i]) iGen = i;
}
Double_t probability[AliPID::kSPECIES];
track->GetESDpid(probability);
Double_t pMax = 0;
Int_t iRec = 0;
for (Int_t i = 0; i < AliPID::kSPECIES; i++) {
probability[i] *= partFrac[i];
if (probability[i] > pMax) {
pMax = probability[i];
iRec = i;
}
}
identified[iGen][iRec]++;
if (iGen == iRec) nIdentified++;
// dE/dx and TOF
Double_t time[AliPID::kSPECIES];
track->GetIntegratedTimes(time);
if (iGen == iRec) {
hDEdxRight->Fill(particle->P(), track->GetTPCsignal());
if ((track->GetStatus() & AliESDtrack::kTOFpid) != 0) {
hResTOFRight->Fill(track->GetTOFsignal() - time[iRec]);
}
} else {
hDEdxWrong->Fill(particle->P(), track->GetTPCsignal());
if ((track->GetStatus() & AliESDtrack::kTOFpid) != 0) {
hResTOFWrong->Fill(track->GetTOFsignal() - time[iRec]);
}
}
}
// loop over muon tracks
{
for (Int_t iTrack = 0; iTrack < esd->GetNumberOfMuonTracks(); iTrack++) {
AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
Double_t ptInv = TMath::Abs(muonTrack->GetInverseBendingMomentum());
if (ptInv > 0.001) {
hPtMUON->Fill(1./ptInv);
}
}
}
// loop over V0s
for (Int_t iV0 = 0; iV0 < esd->GetNumberOfV0s(); iV0++) {
AliESDv0* v0 = esd->GetV0(iV0);
if (v0->GetOnFlyStatus()) continue;
v0->ChangeMassHypothesis(kK0Short);
hMassK0->Fill(v0->GetEffMass());
v0->ChangeMassHypothesis(kLambda0);
hMassLambda->Fill(v0->GetEffMass());
v0->ChangeMassHypothesis(kLambda0Bar);
hMassLambdaBar->Fill(v0->GetEffMass());
Int_t negLabel = TMath::Abs(esd->GetTrack(v0->GetNindex())->GetLabel());
if (negLabel > stack->GetNtrack()) continue; // background
Int_t negMother = stack->Particle(negLabel)->GetMother(0);
if (negMother < 0) continue;
Int_t posLabel = TMath::Abs(esd->GetTrack(v0->GetPindex())->GetLabel());
if (posLabel > stack->GetNtrack()) continue; // background
Int_t posMother = stack->Particle(posLabel)->GetMother(0);
if (negMother != posMother) continue;
TParticle* particle = stack->Particle(negMother);
if (!selV0s.Contains(particle)) continue;
selV0s.Remove(particle);
nRecV0s++;
}
// loop over Cascades
for (Int_t iCascade = 0; iCascade < esd->GetNumberOfCascades();
iCascade++) {
AliESDcascade* cascade = esd->GetCascade(iCascade);
Double_t v0q;
cascade->ChangeMassHypothesis(v0q,kXiMinus);
hMassXi->Fill(cascade->GetEffMassXi());
cascade->ChangeMassHypothesis(v0q,kOmegaMinus);
hMassOmega->Fill(cascade->GetEffMassXi());
Int_t negLabel = TMath::Abs(esd->GetTrack(cascade->GetNindex())
->GetLabel());
if (negLabel > stack->GetNtrack()) continue; // background
Int_t negMother = stack->Particle(negLabel)->GetMother(0);
if (negMother < 0) continue;
Int_t posLabel = TMath::Abs(esd->GetTrack(cascade->GetPindex())
->GetLabel());
if (posLabel > stack->GetNtrack()) continue; // background
Int_t posMother = stack->Particle(posLabel)->GetMother(0);
if (negMother != posMother) continue;
Int_t v0Mother = stack->Particle(negMother)->GetMother(0);
if (v0Mother < 0) continue;
Int_t bacLabel = TMath::Abs(esd->GetTrack(cascade->GetBindex())
->GetLabel());
if (bacLabel > stack->GetNtrack()) continue; // background
Int_t bacMother = stack->Particle(bacLabel)->GetMother(0);
if (v0Mother != bacMother) continue;
TParticle* particle = stack->Particle(v0Mother);
if (!selCascades.Contains(particle)) continue;
selCascades.Remove(particle);
nRecCascades++;
}
// loop over the clusters
{
for (Int_t iCluster=0; iCluster<esd->GetNumberOfCaloClusters(); iCluster++) {
AliESDCaloCluster * clust = esd->GetCaloCluster(iCluster);
if (clust->IsPHOS()) hEPHOS->Fill(clust->E());
if (clust->IsEMCAL()) hEEMCAL->Fill(clust->E());
}
}
}
// perform checks
if (nGen < checkNGenLow) {
Warning("CheckESD", "low number of generated particles: %d", Int_t(nGen));
}
TH1F* hEff = CreateEffHisto(hGen, hRec);
Info("CheckESD", "%d out of %d tracks reconstructed including %d "
"fake tracks", nRec, nGen, nFake);
if (nGen > 0) {
// efficiency
Double_t eff = nRec*1./nGen;
Double_t effError = TMath::Sqrt(eff*(1.-eff) / nGen);
Double_t fake = nFake*1./nGen;
Double_t fakeError = TMath::Sqrt(fake*(1.-fake) / nGen);
Info("CheckESD", "eff = (%.1f +- %.1f) %% fake = (%.1f +- %.1f) %%",
100.*eff, 100.*effError, 100.*fake, 100.*fakeError);
if (eff < checkEffLow - checkEffSigma*effError) {
Warning("CheckESD", "low efficiency: (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
}
if (fake > checkFakeHigh + checkFakeSigma*fakeError) {
Warning("CheckESD", "high fake: (%.1f +- %.1f) %%",
100.*fake, 100.*fakeError);
}
// resolutions
Double_t res, resError;
if (FitHisto(hResPtInv, res, resError)) {
Info("CheckESD", "relative inverse pt resolution = (%.1f +- %.1f) %%",
res, resError);
if (res > checkResPtInvHigh + checkResPtInvSigma*resError) {
Warning("CheckESD", "bad pt resolution: (%.1f +- %.1f) %%",
res, resError);
}
}
if (FitHisto(hResPhi, res, resError)) {
Info("CheckESD", "phi resolution = (%.1f +- %.1f) mrad", res, resError);
if (res > checkResPhiHigh + checkResPhiSigma*resError) {
Warning("CheckESD", "bad phi resolution: (%.1f +- %.1f) mrad",
res, resError);
}
}
if (FitHisto(hResTheta, res, resError)) {
Info("CheckESD", "theta resolution = (%.1f +- %.1f) mrad",
res, resError);
if (res > checkResThetaHigh + checkResThetaSigma*resError) {
Warning("CheckESD", "bad theta resolution: (%.1f +- %.1f) mrad",
res, resError);
}
}
// PID
if (nRec > 0) {
Double_t eff = nIdentified*1./nRec;
Double_t effError = TMath::Sqrt(eff*(1.-eff) / nRec);
Info("CheckESD", "PID eff = (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
if (eff < checkPIDEffLow - checkPIDEffSigma*effError) {
Warning("CheckESD", "low PID efficiency: (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
}
}
printf("%9s:", "gen\\rec");
for (Int_t iRec = 0; iRec < AliPID::kSPECIES; iRec++) {
printf("%9s", partName[iRec]);
}
printf("\n");
for (Int_t iGen = 0; iGen < AliPID::kSPECIES+1; iGen++) {
printf("%9s:", partName[iGen]);
for (Int_t iRec = 0; iRec < AliPID::kSPECIES; iRec++) {
printf("%9d", identified[iGen][iRec]);
}
printf("\n");
}
if (FitHisto(hResTOFRight, res, resError)) {
Info("CheckESD", "TOF resolution = (%.1f +- %.1f) ps", res, resError);
if (res > checkResTOFHigh + checkResTOFSigma*resError) {
Warning("CheckESD", "bad TOF resolution: (%.1f +- %.1f) ps",
res, resError);
}
}
// calorimeters
if (hEPHOS->Integral() < checkPHOSNLow) {
Warning("CheckESD", "low number of PHOS particles: %d",
Int_t(hEPHOS->Integral()));
} else {
Double_t mean = hEPHOS->GetMean();
if (mean < checkPHOSEnergyLow) {
Warning("CheckESD", "low mean PHOS energy: %.1f GeV", mean);
} else if (mean > checkPHOSEnergyHigh) {
Warning("CheckESD", "high mean PHOS energy: %.1f GeV", mean);
}
}
if (hEEMCAL->Integral() < checkEMCALNLow) {
Warning("CheckESD", "low number of EMCAL particles: %d",
Int_t(hEEMCAL->Integral()));
} else {
Double_t mean = hEEMCAL->GetMean();
if (mean < checkEMCALEnergyLow) {
Warning("CheckESD", "low mean EMCAL energy: %.1f GeV", mean);
} else if (mean > checkEMCALEnergyHigh) {
Warning("CheckESD", "high mean EMCAL energy: %.1f GeV", mean);
}
}
// muons
if (hPtMUON->Integral() < checkMUONNLow) {
Warning("CheckESD", "low number of MUON particles: %d",
Int_t(hPtMUON->Integral()));
} else {
Double_t mean = hPtMUON->GetMean();
if (mean < checkMUONPtLow) {
Warning("CheckESD", "low mean MUON pt: %.1f GeV/c", mean);
} else if (mean > checkMUONPtHigh) {
Warning("CheckESD", "high mean MUON pt: %.1f GeV/c", mean);
}
}
// V0s
if (nGenV0s > 0) {
Double_t eff = nRecV0s*1./nGenV0s;
Double_t effError = TMath::Sqrt(eff*(1.-eff) / nGenV0s);
if (effError == 0) effError = checkV0EffLow / TMath::Sqrt(1.*nGenV0s);
Info("CheckESD", "V0 eff = (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
if (eff < checkV0EffLow - checkV0EffSigma*effError) {
Warning("CheckESD", "low V0 efficiency: (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
}
}
// Cascades
if (nGenCascades > 0) {
Double_t eff = nRecCascades*1./nGenCascades;
Double_t effError = TMath::Sqrt(eff*(1.-eff) / nGenCascades);
if (effError == 0) effError = checkV0EffLow /
TMath::Sqrt(1.*nGenCascades);
Info("CheckESD", "Cascade eff = (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
if (eff < checkCascadeEffLow - checkCascadeEffSigma*effError) {
Warning("CheckESD", "low Cascade efficiency: (%.1f +- %.1f) %%",
100.*eff, 100.*effError);
}
}
}
// draw the histograms if not in batch mode
if (!gROOT->IsBatch()) {
new TCanvas;
hEff->DrawCopy();
new TCanvas;
hResPtInv->DrawCopy("E");
new TCanvas;
hResPhi->DrawCopy("E");
new TCanvas;
hResTheta->DrawCopy("E");
new TCanvas;
hDEdxRight->DrawCopy();
hDEdxWrong->DrawCopy("SAME");
new TCanvas;
hResTOFRight->DrawCopy("E");
hResTOFWrong->DrawCopy("SAME");
new TCanvas;
hEPHOS->DrawCopy("E");
new TCanvas;
hEEMCAL->DrawCopy("E");
new TCanvas;
hPtMUON->DrawCopy("E");
new TCanvas;
hMassK0->DrawCopy("E");
new TCanvas;
hMassLambda->DrawCopy("E");
new TCanvas;
hMassLambdaBar->DrawCopy("E");
new TCanvas;
hMassXi->DrawCopy("E");
new TCanvas;
hMassOmega->DrawCopy("E");
}
// write the output histograms to a file
TFile* outputFile = TFile::Open("check.root", "recreate");
if (!outputFile || !outputFile->IsOpen()) {
Error("CheckESD", "opening output file check.root failed");
return kFALSE;
}
hEff->Write();
hResPtInv->Write();
hResPhi->Write();
hResTheta->Write();
hDEdxRight->Write();
hDEdxWrong->Write();
hResTOFRight->Write();
hResTOFWrong->Write();
hEPHOS->Write();
hEEMCAL->Write();
hPtMUON->Write();
hMassK0->Write();
hMassLambda->Write();
hMassLambdaBar->Write();
hMassXi->Write();
hMassOmega->Write();
outputFile->Close();
delete outputFile;
// clean up
delete hGen;
delete hRec;
delete hEff;
delete hResPtInv;
delete hResPhi;
delete hResTheta;
delete hDEdxRight;
delete hDEdxWrong;
delete hResTOFRight;
delete hResTOFWrong;
delete hEPHOS;
delete hEEMCAL;
delete hPtMUON;
delete hMassK0;
delete hMassLambda;
delete hMassLambdaBar;
delete hMassXi;
delete hMassOmega;
delete esd;
esdFile->Close();
delete esdFile;
runLoader->UnloadHeader();
runLoader->UnloadKinematics();
delete runLoader;
// result of check
Info("CheckESD", "check of ESD was successfull");
return kTRUE;
}
void digitsSPD(Int_t nevents, Int_t nfiles)
{
TH1F * hadc = new TH1F ("hadc", "hadc",100, 0, 2);
TH1F * hadclog = new TH1F ("hadclog", "hadclog",100, -1, 1);
TDirectoryFile *tdf[100];
TDirectoryFile *tdfKine[100] ;
TTree *ttree[100];
TTree *ttreeKine[100];
TClonesArray *arr= NULL; //
//Run loader------------
TString name;
name = "galice.root";
AliRunLoader* rlSig = AliRunLoader::Open(name.Data());
// gAlice
rlSig->LoadgAlice();
gAlice = rlSig->GetAliRun();
// Now load kinematics and event header
rlSig->LoadKinematics();
rlSig->LoadHeader();
cout << rlSig->GetNumberOfEvents()<< endl;
//----------------------
//loop over events in the files
for(Int_t event=0; event<nevents; event++){
//printf("###event= %d\n", event + file*100);
printf("###event= %d\n", event);
tdf[event] = GetDirectory(event, "ITS", nfiles);
if ( ! tdf[event] ) {
cerr << "Event directory not found in " << nfiles << " files" << endl;
exit(1);
}
ttree[event] = (TTree*)tdf[event]->Get("TreeD");
arr = NULL;
ttree[event]->SetBranchAddress("ITSDigitsSPD", &arr);
// Runloader -> gives particle Stack
rlSig->GetEvent(event);
AliStack * stack = rlSig->Stack();
//stack->DumpPStack();
// loop over tracks
Int_t NumberPrim=0;
for(Int_t iev=0; iev<ttree[event]->GetEntries(); iev++){
ttree[event]->GetEntry(iev);
for (Int_t j = 0; j < arr->GetEntries(); j++) {
AliITSdigit* digit = dynamic_cast<AliITSdigit*> (arr->At(j));
if (digit){
hadc->Fill(digit->GetSignal());
hadclog->Fill(TMath::Log10(digit->GetSignal()));
}
}
}
}
TFile fc("digits.ITS.SPD.root","RECREATE");
fc.cd();
hadc->Write();
hadclog->Write();
fc.Close();
}
// 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();
}
int mergeDigits(TString digitdir, Int_t /*simEvOffset*/)
{
AliRunLoader *rl = AliRunLoader::Open(digitdir+TString("/galice.root"));
AliPHOSLoader *prl = (AliPHOSLoader*)rl->GetDetectorLoader("PHOS");
prl->LoadDigits("UPDATE");
//prl->LoadDigits();
Int_t nEvents = rl->GetNumberOfEvents();
TClonesArray *mydigits = 0;
simTree->SetBranchAddress("Digits", &mydigits);
Int_t nDigits = 0;
Int_t nEmbedDigits = 0;
Int_t nOverlappingDigits = 0;
Int_t nNewDigits = 0;
Int_t nPhosDigits = prl->Digits()->GetEntries();
Int_t nMyEvents = simTree->GetEntries();
std::cout << "Number of real events: " << nEvents << std::endl;
std::cout << "Number of sim events: " << nMyEvents << std::endl;
nEvents = TMath::Min(nEvents, nMyEvents);
std::cout << "Looping over: " << nEvents << std::endl;
for (Int_t ev = 0; ev < nEvents; ev++)
{
rl->GetEvent(ev);
simTree->GetEntry(ev);
Int_t nMyDigits = mydigits->GetEntries();
//Int_t nDigsFound = 0;
nEmbedDigits += nMyDigits;
TClonesArray *phosDigits = prl->Digits();
nPhosDigits = prl->Digits()->GetEntries();
for (Int_t iDig = 0; iDig < nPhosDigits; iDig++)
{
//const AliPHOSDigit *digit = prl->Digit(iDig);
AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(iDig);
nDigits++;
for (Int_t n = 0; n < nMyDigits; n++)
{
AliPHOSDigit *myDigit = (AliPHOSDigit*)mydigits->At(n);
if (digit->GetId() == myDigit->GetId())
{
nOverlappingDigits++;
break;
}
}
}
if(nOverlappingDigits == nMyDigits)
{
std::cout << "Digits alredy embedded!" << std::endl;
continue;
}
for (Int_t iDig = 0; iDig < nMyDigits; iDig++)
{
AliPHOSDigit *myDigit = (AliPHOSDigit*)mydigits->At(iDig);
if (myDigit)
{
for (Int_t n = 0; n < nPhosDigits; n++)
{
//const AliPHOSDigit *digit = prl->Digit(n);
AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(n);
if (digit->GetId() == myDigit->GetId())
{
digit->SetALTROSamplesHG(0, 0);
digit->SetALTROSamplesLG(0, 0);
*digit += *myDigit;
myDigit = 0;
break;
}
}
if (myDigit)
{
TClonesArray *digArray = prl->Digits();
AliPHOSDigit *newDig = new((*digArray)[nPhosDigits+nNewDigits]) AliPHOSDigit(*myDigit);
newDig->SetALTROSamplesHG(0, 0);
newDig->SetALTROSamplesLG(0, 0);
nNewDigits++;
}
}
}
phosDigits->Compress();
Int_t ndigits = phosDigits->GetEntries() ;
phosDigits->Sort();
// Remove digits that are flagged bad in BCM. Then remove digits that are below threshold
for (Int_t i = 0 ; i < ndigits ; i++)
{
AliPHOSDigit *digit = static_cast<AliPHOSDigit*>( phosDigits->At(i) ) ;
//std::cout << digit->GetId() << std::endl;
if(digit->GetId())
{
vector<Int_t>::iterator it;
it = std::find (badChannels.begin(), badChannels.end(), digit->GetId() );
if(*it)
{
digit->SetEnergy(0.0);
}
}
if(digit->GetEnergy() <= recoParam->GetGlobalAltroThreshold())
{
phosDigits->RemoveAt(i);
}
}
//Set indexes in list of digits and make true digitization of the energy
phosDigits->Compress();
phosDigits->Sort();
ndigits = phosDigits->GetEntries();
for (Int_t i = 0 ; i < ndigits ; i++)
{
AliPHOSDigit *digit = static_cast<AliPHOSDigit*>( phosDigits->At(i) ) ;
digit->SetIndexInList(i) ;
}
// -- create Digits branch
Int_t bufferSize = 32000 ;
TObjArray *branchList = prl->TreeD()->GetListOfBranches();
branchList->RemoveAt(0);
TBranch * digitsBranch = prl->TreeD()->Branch("PHOS","TClonesArray",&phosDigits,bufferSize);
digitsBranch->Fill() ;
prl->WriteDigits("OVERWRITE");
}
prl->WriteDigits("OVERWRITE");
std::cout << "# Digits: " << nDigits << std::endl;
std::cout << "# Embedded digits: " << nEmbedDigits << std::endl;
std::cout << "# Overlapping digits: " << nOverlappingDigits << std::endl;
std::cout << "# New digits: " << nNewDigits << std::endl;
return 0;
}
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 AliITSDigitPlot(Int_t istart=0,Int_t iend=-1,
const char *filename="galice.root"){
// Macro to plot digits from many events
// Inputs:
// Int_t istart Starting event number
// Int_t iend Last event number, =-1 all
// Outputs:
// none.
// Return:
// none.
if (gClassTable->GetID("AliRun") < 0) {
gROOT->ProcessLine(".x $(ALICE_ROOT)/macros/loadlibs.C");
}
if(gAlice){
delete AliRunLoader::Instance();
delete gAlice;
gAlice=0;
} // end if gAlice
Int_t nevents=0,nmodules=0,retval=0;
Int_t i,j,module,dig,ndig,row,column,signal,det;
AliITS *its = 0;
AliITSgeom *gm = 0;
AliRunLoader *rl = 0;
AliITSLoader *ld = 0;
TTree *treeD = 0;
TBranch *br = 0;
TClonesArray *digits = 0;
AliITSdigit *d = 0;
TObjArray *digDet = 0;
Char_t *branchname[3] = {"ITSDigitsSPD","ITSDigitsSDD","ITSDigitsSSD"};
//
rl = AliRunLoader::Open(filename);
if(!rl){
cerr<<"Error, can not open file "<<filename<<endl;
return;
} // end if !rl
retval = rl->LoadgAlice();
if (retval){
cerr<<"Error, LoadgAlice returned error"<<endl;
return;
}
gAlice = rl->GetAliRun();
retval = rl->LoadHeader();
if (retval){
cerr<<"Error, LoadHeader returned error"<<endl;
return;
} // end if
ld = (AliITSLoader*) rl->GetLoader("ITSLoader");
if(!ld){
cerr<<"Error, ITS loader not found"<<endl;
return;
} // end if
its = (AliITS*) gAlice->GetModule("ITS");
if(!its){
cerr <<"Error, No AliDetector ITS found on file"<<endl;
return;
} // end if
gm = its->GetITSgeom();
if(!gm){
cerr <<"Error, AliITSgeom not initilized in module ITS"<<endl;
return;
} // end if
nevents = rl->GetNumberOfEvents();
if(iend>nevents) iend = nevents;
if(iend<0) iend = nevents;
if(iend<=istart){delete rl; return;}
nmodules = gm->GetIndexMax();
ld->GetDigitsDataLoader()->Load("read");
treeD = ld->TreeD();
if(!treeD){
cerr <<"Error, could not get TreeD="<<treeD << endl;
return;
} // end if !treeD
digDet = new TObjArray(3);
its->SetDefaults();
for(det=0;det<3;det++){
digDet->AddAt(new TClonesArray(its->GetDetTypeSim()->
GetDigitClassName(det),1000),det);
br = treeD->GetBranch(branchname[det]);
br->SetAddress(&((*digDet)[det]));
} // end for det
//
SetUPHistograms();
//
for(i=istart;i<iend;i++){
rl->GetEvent(i);
treeD = ld->TreeD();
for(det=0;det<3;det++){
((TClonesArray*)(digDet->At(det)))->Clear();
br = treeD->GetBranch(branchname[det]);
br->SetAddress(&((*digDet)[det]));
} // end for det
for(module=0;module<nmodules;module++){
for(j=0;j<3;j++) ((TClonesArray*)(digDet->At(j)))->Clear();
treeD->GetEvent(module);
digits = (TClonesArray*) (digDet->At(0)); // SPD only.
ndig = digits->GetEntriesFast();
for(dig=0;dig<ndig;dig++){
d = (AliITSdigit*) digits->At(dig);
row = d->GetCoord1();
column = d->GetCoord1();
signal = d->GetSignal();
//cout <<"event="<<i<< " ndig="<< ndig<< " mod="
//<<module<<" row="<<row<<" col="<<column<< " sig="
//<<signal<<endl;
FillHistograms(module,row,column,signal);
} // end for mod
} // end for module
} // end for i
DisplayHistograms();
delete digits;
return;
}