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;
}
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 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 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 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;
}
}
}
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;
}
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;
}
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 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 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();
}
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 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 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
}
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;
}
//----------------------------------------------------------------------
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;
}