1 /**************************************************************************
2 * Author: Panos Christakoglou. *
3 * Contributors are mentioned in the code where appropriate. *
5 * Permission to use, copy, modify and distribute this software and its *
6 * documentation strictly for non-commercial purposes is hereby granted *
7 * without fee, provided that the above copyright notice appears in all *
8 * copies and that both the copyright notice and this permission notice *
9 * appear in the supporting documentation. The authors make no claims *
10 * about the suitability of this software for any purpose. It is *
11 * provided "as is" without express or implied warranty. *
12 **************************************************************************/
16 //-----------------------------------------------------------------
17 // AliESDTagCreator class
18 // This is the class to deal with the tag creation (post process)
19 // Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
20 //-----------------------------------------------------------------
23 #include <Riostream.h>
30 #include <TObjString.h>
31 #include <TLorentzVector.h>
33 #include <TTimeStamp.h>
34 #include <TRefArray.h>
38 #include <TGridResult.h>
41 #include "AliRunTag.h"
42 #include "AliEventTag.h"
44 #include "AliESDEvent.h"
45 #include "AliESDVertex.h"
47 #include "AliGRPObject.h"
49 #include "AliESDTagCreator.h"
52 ClassImp(AliESDTagCreator)
55 //______________________________________________________________________________
56 AliESDTagCreator::AliESDTagCreator() :
58 fChain(new TChain("esdTree")), fGUIDList(new TList()),
59 fMD5List(new TList()), fTURLList(new TList()), fBranches(""),
60 meminfo(new MemInfo_t) {
61 //==============Default constructor for a AliESDTagCreator================
64 //______________________________________________________________________________
65 AliESDTagCreator::~AliESDTagCreator() {
66 //================Default destructor for a AliESDTagCreator===================
74 //______________________________________________________________________________
75 Bool_t AliESDTagCreator::ReadGridCollection(TGridResult *fresult) {
76 // Reads the entry of the TGridResult and creates the tags
77 Int_t nEntries = fresult->GetEntries();
86 for(Int_t i = 0; i < nEntries; i++) {
87 alienUrl = fresult->GetKey(i,"turl");
88 guid = fresult->GetKey(i,"guid");
89 if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
90 md5 = fresult->GetKey(i,"md5");
91 turl = fresult->GetKey(i,"turl");
92 if(md5 && !strlen(guid)) md5 = 0;
93 if(guid && !strlen(guid)) guid = 0;
95 fChain->Add(alienUrl);
96 //fGUIDList->Add(new TObjString(guid));
97 //fMD5List->Add(new TObjString(md5));
98 //fTURLList->Add(new TObjString(turl));
100 //TFile *f = TFile::Open(alienUrl,"READ");
101 //CreateTag(f,guid,md5,turl,size,counter);
107 AliInfo(Form("ESD chain created......."));
108 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
109 // Switch of branches on user request
111 CreateTag(fChain,"grid");
116 //______________________________________________________________________________
117 Bool_t AliESDTagCreator::ReadLocalCollection(const char *localpath) {
118 // Checks the different subdirs of the given local path and in the
119 // case where it finds an AliESDs.root file it creates the tags
121 void *dira = gSystem->OpenDirectory(localpath);
123 const char * dirname = 0x0;
124 const char * filename = 0x0;
125 const char * pattern = "AliESDs.root";
128 while((dirname = gSystem->GetDirEntry(dira))) {
129 sprintf(fPath,"%s/%s",localpath,dirname);
130 void *dirb = gSystem->OpenDirectory(fPath);
131 while((filename = gSystem->GetDirEntry(dirb))) {
132 if(strstr(filename,pattern)) {
133 TString fESDFileName;
134 fESDFileName = fPath;
136 fESDFileName += pattern;
138 fChain->Add(fESDFileName);
140 //TFile *f = TFile::Open(fESDFileName,"READ");
141 //CreateTag(f,fESDFileName,counter);
147 }//child directory's entry loop
148 }//parent directory's entry loop
150 AliInfo(Form("ESD chain created......."));
151 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
152 // Switch of branches on user request
154 CreateTag(fChain,"local");
159 //______________________________________________________________________________
160 Bool_t AliESDTagCreator::ReadCAFCollection(const char *filename) {
161 // Temporary solution for CAF: Takes as an input the ascii file that
162 // lists the ESDs stored in the SE of the CAF and creates the tags.
164 // Open the input stream
170 // Read the input list of files and add them to the chain
173 if (!esdfile.Contains("root")) continue; // protection
175 fChain->Add(esdfile);
177 //TFile *f = TFile::Open(esdfile,"READ");
178 //CreateTag(f,esdfile,counter);
185 AliInfo(Form("ESD chain created......."));
186 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
187 // Switch of branches on user request
189 CreateTag(fChain,"proof");
194 //_____________________________________________________________________________
195 void AliESDTagCreator::CreateTag(TChain* chain, const char *type) {
196 //private method that creates tag files
197 TString fSession = type;
198 TString fguid, fmd5, fturl;
199 TString fTempGuid = 0;
204 Double_t fMUONMASS = 0.105658369;
207 Double_t fThetaX, fThetaY, fPyz, fChisquare;
208 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
210 TLorentzVector fEPvector;
212 Float_t fZVertexCut = 10.0;
213 Float_t fRhoVertexCut = 2.0;
215 Float_t fLowPtCut = 1.0;
216 Float_t fHighPtCut = 3.0;
217 Float_t fVeryHighPtCut = 10.0;
220 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
222 // Creates the tags for all the events in a given ESD file
223 Bool_t fIsSim = kTRUE;
225 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
226 Int_t nPos, nNeg, nNeutr;
227 Int_t nK0s, nNeutrons, nPi0s, nGamas;
228 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
229 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
230 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
231 Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
233 Int_t iRunNumber = 0;
236 //gSystem->GetMemInfo(meminfo);
237 //AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
238 //Int_t tempmem = meminfo->fMemUsed;
240 AliInfo(Form("Creating the ESD tags......."));
242 Int_t firstEvent = 0,lastEvent = 0;
243 AliESDEvent *esd = new AliESDEvent();
244 esd->ReadFromTree(chain);
245 AliESD *esdold = 0x0;
247 //gSystem->GetMemInfo(meminfo);
248 //AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
249 //tempmem = meminfo->fMemUsed;
251 Int_t iInitRunNumber = -1;
253 TFile *f = chain->GetFile();
254 fTempGuid = f->GetUUID().AsString();
256 TString localFileName = "Run"; localFileName += esd->GetRunNumber();
257 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
258 localFileName += ".ESD.tag.root";
264 fileName = localFileName.Data();
265 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
267 else if(fStorage == 1) {
268 TString alienLocation = "/alien";
269 alienLocation += gGrid->Pwd();
270 alienLocation += fgridpath.Data();
271 alienLocation += "/";
272 alienLocation += localFileName;
273 alienLocation += "?se=";
274 alienLocation += fSE.Data();
275 fileName = alienLocation.Data();
276 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
279 TFile* ftag = TFile::Open(fileName, "recreate");
281 AliRunTag *tag = new AliRunTag();
282 AliEventTag *evTag = new AliEventTag();
283 TTree ttag("T","A Tree with event tags");
284 TBranch * btag = ttag.Branch("AliTAG", &tag);
285 btag->SetCompressionLevel(9);
287 for(Int_t iEventNumber = 0; iEventNumber < chain->GetEntries(); iEventNumber++) {
288 ntrack = 0; nPos = 0; nNeg = 0; nNeutr =0;
289 nK0s = 0; nNeutrons = 0; nPi0s = 0;
290 nGamas = 0; nProtons = 0; nKaons = 0;
291 nPions = 0; nMuons = 0; nElectrons = 0; nFWMuons = 0;
292 nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
293 nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
294 nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
295 maxPt = .0; etamaxPt = -999.; phimaxPt = -999.; meanPt = .0; totalP = .0;
298 chain->GetEntry(iEventNumber);
299 esdold = esd->GetAliESDOld();
300 if(esdold) esd->CopyFromOldESD();
302 TFile *file = chain->GetFile();
303 const TUrl *url = file->GetEndpointUrl();
304 fguid = file->GetUUID().AsString();
305 if(fSession == "grid") {
306 TString fturltemp = "alien://"; fturltemp += url->GetFile();
307 fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
309 else fturl = url->GetFile();
311 if(iEventNumber == 0) iInitRunNumber = esd->GetRunNumber();
312 iRunNumber = esd->GetRunNumber();
313 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD - You are trying to merge different runs!!!");
315 const AliESDVertex * vertexIn = esd->GetVertex();
316 fVertexName = vertexIn->GetName();
317 if(fVertexName == "default") fVertexflag = 0;
319 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
320 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
321 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
322 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
323 UInt_t status = esdTrack->GetStatus();
325 //select only tracks with ITS refit
326 if ((status&AliESDtrack::kITSrefit)==0) continue;
327 //select only tracks with TPC refit
328 if ((status&AliESDtrack::kTPCrefit)==0) continue;
330 //select only tracks with the "combined PID"
331 if ((status&AliESDtrack::kESDpid)==0) continue;
333 esdTrack->GetPxPyPz(p);
334 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
335 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
336 Double_t fPt = TMath::Sqrt(pt2);
341 phimaxPt = esdTrack->Phi();
342 etamaxPt = esdTrack->Eta();
345 if(esdTrack->GetSign() > 0) {
347 if(fPt > fLowPtCut) nCh1GeV++;
348 if(fPt > fHighPtCut) nCh3GeV++;
349 if(fPt > fVeryHighPtCut) nCh10GeV++;
351 if(esdTrack->GetSign() < 0) {
353 if(fPt > fLowPtCut) nCh1GeV++;
354 if(fPt > fHighPtCut) nCh3GeV++;
355 if(fPt > fVeryHighPtCut) nCh10GeV++;
357 if(esdTrack->GetSign() == 0) nNeutr++;
361 esdTrack->GetESDpid(prob);
364 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
365 if(rcc == 0.0) continue;
368 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
371 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
373 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
375 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
377 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
379 if(fPt > fLowPtCut) nEl1GeV++;
380 if(fPt > fHighPtCut) nEl3GeV++;
381 if(fPt > fVeryHighPtCut) nEl10GeV++;
389 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
390 // loop over all reconstructed tracks (also first track of combination)
391 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
392 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
393 if (muonTrack == 0x0) continue;
395 // Coordinates at vertex
396 fZ = muonTrack->GetZ();
397 fY = muonTrack->GetBendingCoor();
398 fX = muonTrack->GetNonBendingCoor();
400 fThetaX = muonTrack->GetThetaX();
401 fThetaY = muonTrack->GetThetaY();
403 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
404 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
405 fPxRec = fPzRec * TMath::Tan(fThetaX);
406 fPyRec = fPzRec * TMath::Tan(fThetaY);
407 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
409 //ChiSquare of the track if needed
410 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
411 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
412 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
414 // total number of muons inside a vertex cut
415 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
418 if(fEPvector.Pt() > fLowPtCut) {
420 if(fEPvector.Pt() > fHighPtCut) {
422 if (fEPvector.Pt() > fVeryHighPtCut) {
430 // Fill the event tags
431 if(ntrack != 0) meanPt = meanPt/ntrack;
433 //AliInfo(Form("====================================="));
434 //AliInfo(Form("URL: %s - GUID: %s",fturl.Data(),fguid.Data()));
435 //AliInfo(Form("====================================="));
438 const AliMultiplicity *spdMult = esd->GetMultiplicity();
439 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
440 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
441 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
443 AliESDVZERO *vzeroData = esd->GetVZEROData();
444 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
445 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
446 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
447 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
449 //evTag->SetEventId(iEventNumber+1);
450 evTag->SetPeriodNumber(esd->GetPeriodNumber());
451 evTag->SetOrbitNumber(esd->GetOrbitNumber());
452 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
453 evTag->SetGUID(fguid);
454 if(fSession == "grid") {
456 evTag->SetTURL(fturl);
459 else evTag->SetPath(fturl);
461 evTag->SetVertexX(vertexIn->GetXv());
462 evTag->SetVertexY(vertexIn->GetYv());
463 evTag->SetVertexZ(vertexIn->GetZv());
464 evTag->SetVertexZError(vertexIn->GetZRes());
465 evTag->SetVertexFlag(fVertexflag);
467 evTag->SetT0VertexZ(esd->GetT0zVertex());
469 evTag->SetTriggerMask(esd->GetTriggerMask());
470 evTag->SetTriggerCluster(esd->GetTriggerCluster());
472 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
473 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
474 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
475 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
476 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
477 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
478 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
479 evTag->SetNumOfParticipants2(esd->GetZDCParticipants2());
482 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
483 evTag->SetNumOfPosTracks(nPos);
484 evTag->SetNumOfNegTracks(nNeg);
485 evTag->SetNumOfNeutrTracks(nNeutr);
487 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
488 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
489 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
490 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
492 evTag->SetNumOfProtons(nProtons);
493 evTag->SetNumOfKaons(nKaons);
494 evTag->SetNumOfPions(nPions);
495 evTag->SetNumOfMuons(nMuons);
496 evTag->SetNumOfFWMuons(nFWMuons);
497 evTag->SetNumOfElectrons(nElectrons);
498 evTag->SetNumOfPhotons(nGamas);
499 evTag->SetNumOfPi0s(nPi0s);
500 evTag->SetNumOfNeutrons(nNeutrons);
501 evTag->SetNumOfKaon0s(nK0s);
503 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
504 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
505 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
506 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
507 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
508 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
509 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
510 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
511 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
514 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
516 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
518 evTag->SetTotalMomentum(totalP);
519 evTag->SetMeanPt(meanPt);
520 evTag->SetMaxPt(maxPt);
521 evTag->SetEtaMaxPt(etamaxPt);
522 evTag->SetPhiMaxPt(phimaxPt);
524 tag->SetRunId(iInitRunNumber);
525 if(fIsSim) tag->SetDataType(0);
526 else tag->SetDataType(1);
528 if(fguid != fTempGuid) {
533 tag->AddEventTag(*evTag);
534 if(iEventNumber+1 == chain->GetEntries()) {
535 //AliInfo(Form("File: %s",fturl.Data()));
540 lastEvent = chain->GetEntries();
542 //gSystem->GetMemInfo(meminfo);
543 //AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
544 //tempmem = meminfo->fMemUsed;
548 //gSystem->GetMemInfo(meminfo);
549 //AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
550 //tempmem = meminfo->fMemUsed;
557 //gSystem->GetMemInfo(meminfo);
558 //AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
559 //tempmem = meminfo->fMemUsed;
564 //gSystem->GetMemInfo(meminfo);
565 //AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
568 //_____________________________________________________________________________
569 void AliESDTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
570 //private method that creates tag files
571 TString fguid = guid;
573 TString fturl = turl;
577 Double_t fMUONMASS = 0.105658369;
580 Double_t fThetaX, fThetaY, fPyz, fChisquare;
581 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
583 TLorentzVector fEPvector;
585 Float_t fZVertexCut = 10.0;
586 Float_t fRhoVertexCut = 2.0;
588 Float_t fLowPtCut = 1.0;
589 Float_t fHighPtCut = 3.0;
590 Float_t fVeryHighPtCut = 10.0;
593 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
595 // Creates the tags for all the events in a given ESD file
596 Bool_t fIsSim = kTRUE;
598 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
599 Int_t nPos, nNeg, nNeutr;
600 Int_t nK0s, nNeutrons, nPi0s, nGamas;
601 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
602 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
603 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
604 Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
606 Int_t iRunNumber = 0;
610 AliRunTag *tag = new AliRunTag();
611 AliEventTag *evTag = new AliEventTag();
612 TTree ttag("T","A Tree with event tags");
613 TBranch * btag = ttag.Branch("AliTAG", &tag);
614 btag->SetCompressionLevel(9);
615 gSystem->GetMemInfo(meminfo);
616 AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
617 Int_t tempmem = meminfo->fMemUsed;
619 AliInfo(Form("Creating the ESD tags......."));
621 Int_t firstEvent = 0,lastEvent = 0;
622 TTree *t = (TTree*) file->Get("esdTree");
623 AliESDEvent *esd = new AliESDEvent();
624 esd->ReadFromTree(t);
626 gSystem->GetMemInfo(meminfo);
627 AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
628 tempmem = meminfo->fMemUsed;
631 Int_t iInitRunNumber = esd->GetRunNumber();
633 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
634 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
665 t->GetEntry(iEventNumber);
666 iRunNumber = esd->GetRunNumber();
667 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
668 const AliESDVertex * vertexIn = esd->GetVertex();
669 fVertexName = vertexIn->GetName();
670 if(fVertexName == "default") fVertexflag = 0;
672 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
673 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
674 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
675 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
676 UInt_t status = esdTrack->GetStatus();
678 //select only tracks with ITS refit
679 if ((status&AliESDtrack::kITSrefit)==0) continue;
680 //select only tracks with TPC refit
681 if ((status&AliESDtrack::kTPCrefit)==0) continue;
683 //select only tracks with the "combined PID"
684 if ((status&AliESDtrack::kESDpid)==0) continue;
686 esdTrack->GetPxPyPz(p);
687 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
688 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
689 Double_t fPt = TMath::Sqrt(pt2);
694 etamaxPt = esdTrack->Eta();
695 phimaxPt = esdTrack->Phi();
699 if(esdTrack->GetSign() > 0) {
701 if(fPt > fLowPtCut) nCh1GeV++;
702 if(fPt > fHighPtCut) nCh3GeV++;
703 if(fPt > fVeryHighPtCut) nCh10GeV++;
705 if(esdTrack->GetSign() < 0) {
707 if(fPt > fLowPtCut) nCh1GeV++;
708 if(fPt > fHighPtCut) nCh3GeV++;
709 if(fPt > fVeryHighPtCut) nCh10GeV++;
711 if(esdTrack->GetSign() == 0) nNeutr++;
715 esdTrack->GetESDpid(prob);
718 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
719 if(rcc == 0.0) continue;
722 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
725 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
727 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
729 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
731 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
733 if(fPt > fLowPtCut) nEl1GeV++;
734 if(fPt > fHighPtCut) nEl3GeV++;
735 if(fPt > fVeryHighPtCut) nEl10GeV++;
743 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
744 // loop over all reconstructed tracks (also first track of combination)
745 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
746 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
747 if (muonTrack == 0x0) continue;
749 // Coordinates at vertex
750 fZ = muonTrack->GetZ();
751 fY = muonTrack->GetBendingCoor();
752 fX = muonTrack->GetNonBendingCoor();
754 fThetaX = muonTrack->GetThetaX();
755 fThetaY = muonTrack->GetThetaY();
757 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
758 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
759 fPxRec = fPzRec * TMath::Tan(fThetaX);
760 fPyRec = fPzRec * TMath::Tan(fThetaY);
761 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
763 //ChiSquare of the track if needed
764 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
765 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
766 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
768 // total number of muons inside a vertex cut
769 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
772 if(fEPvector.Pt() > fLowPtCut) {
774 if(fEPvector.Pt() > fHighPtCut) {
776 if (fEPvector.Pt() > fVeryHighPtCut) {
784 // Fill the event tags
785 if(ntrack != 0) meanPt = meanPt/ntrack;
788 const AliMultiplicity *spdMult = esd->GetMultiplicity();
789 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
790 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
791 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
793 AliESDVZERO *vzeroData = esd->GetVZEROData();
794 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
795 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
796 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
797 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
799 //evTag->SetEventId(iEventNumber+1);
800 evTag->SetPeriodNumber(esd->GetPeriodNumber());
801 evTag->SetOrbitNumber(esd->GetOrbitNumber());
802 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
804 evTag->SetGUID(fguid);
806 evTag->SetTURL(fturl);
807 evTag->SetSize(size);
808 evTag->SetVertexX(vertexIn->GetXv());
809 evTag->SetVertexY(vertexIn->GetYv());
810 evTag->SetVertexZ(vertexIn->GetZv());
811 evTag->SetVertexZError(vertexIn->GetZRes());
812 evTag->SetVertexFlag(fVertexflag);
814 evTag->SetT0VertexZ(esd->GetT0zVertex());
816 evTag->SetTriggerMask(esd->GetTriggerMask());
817 evTag->SetTriggerCluster(esd->GetTriggerCluster());
819 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
820 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
821 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
822 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
823 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
824 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
827 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
828 evTag->SetNumOfPosTracks(nPos);
829 evTag->SetNumOfNegTracks(nNeg);
830 evTag->SetNumOfNeutrTracks(nNeutr);
832 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
833 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
834 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
835 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
837 evTag->SetNumOfProtons(nProtons);
838 evTag->SetNumOfKaons(nKaons);
839 evTag->SetNumOfPions(nPions);
840 evTag->SetNumOfMuons(nMuons);
841 evTag->SetNumOfFWMuons(nFWMuons);
842 evTag->SetNumOfElectrons(nElectrons);
843 evTag->SetNumOfPhotons(nGamas);
844 evTag->SetNumOfPi0s(nPi0s);
845 evTag->SetNumOfNeutrons(nNeutrons);
846 evTag->SetNumOfKaon0s(nK0s);
848 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
849 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
850 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
851 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
852 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
853 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
854 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
855 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
856 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
859 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
861 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
863 evTag->SetTotalMomentum(totalP);
864 evTag->SetMeanPt(meanPt);
865 evTag->SetMaxPt(maxPt);
866 evTag->SetEtaMaxPt(etamaxPt);
867 evTag->SetPhiMaxPt(phimaxPt);
869 tag->SetRunId(iInitRunNumber);
870 if(fIsSim) tag->SetDataType(0);
871 else tag->SetDataType(1);
872 tag->AddEventTag(*evTag);
874 lastEvent = iNumberOfEvents;
876 gSystem->GetMemInfo(meminfo);
877 AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
878 tempmem = meminfo->fMemUsed;
881 gSystem->GetMemInfo(meminfo);
882 AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
883 tempmem = meminfo->fMemUsed;
885 TString localFileName = "Run"; localFileName += tag->GetRunId();
886 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
887 localFileName += ".ESD.tag.root";
892 fileName = localFileName.Data();
893 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
895 else if(fStorage == 1) {
896 TString alienLocation = "/alien";
897 alienLocation += gGrid->Pwd();
898 alienLocation += fgridpath.Data();
899 alienLocation += "/";
900 alienLocation += localFileName;
901 alienLocation += "?se=";
902 alienLocation += fSE.Data();
903 fileName = alienLocation.Data();
904 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
907 TFile* ftag = TFile::Open(fileName, "recreate");
914 gSystem->GetMemInfo(meminfo);
915 AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
916 tempmem = meminfo->fMemUsed;
922 gSystem->GetMemInfo(meminfo);
923 AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
926 //_____________________________________________________________________________
927 void AliESDTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
928 //private method that creates tag files
932 Double_t fMUONMASS = 0.105658369;
935 Double_t fThetaX, fThetaY, fPyz, fChisquare;
936 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
938 TLorentzVector fEPvector;
940 Float_t fZVertexCut = 10.0;
941 Float_t fRhoVertexCut = 2.0;
943 Float_t fLowPtCut = 1.0;
944 Float_t fHighPtCut = 3.0;
945 Float_t fVeryHighPtCut = 10.0;
948 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
950 // Creates the tags for all the events in a given ESD file
951 Bool_t fIsSim = kTRUE;
953 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
954 Int_t nPos, nNeg, nNeutr;
955 Int_t nK0s, nNeutrons, nPi0s, nGamas;
956 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
957 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
958 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
959 Float_t maxPt = .0, etamaxPt = -999, phimaxPt = -999., meanPt = .0, totalP = .0;
961 Int_t iRunNumber = 0;
965 AliRunTag *tag = new AliRunTag();
966 AliEventTag *evTag = new AliEventTag();
967 TTree ttag("T","A Tree with event tags");
968 TBranch * btag = ttag.Branch("AliTAG", &tag);
969 btag->SetCompressionLevel(9);
971 AliInfo(Form("Creating the ESD tags......."));
973 Int_t firstEvent = 0,lastEvent = 0;
975 TTree *t = (TTree*) file->Get("esdTree");
976 AliESDEvent *esd = new AliESDEvent();
977 esd->ReadFromTree(t);
980 Int_t iInitRunNumber = esd->GetRunNumber();
982 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
983 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
1014 t->GetEntry(iEventNumber);
1015 iRunNumber = esd->GetRunNumber();
1016 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
1017 const AliESDVertex * vertexIn = esd->GetVertex();
1018 fVertexName = vertexIn->GetName();
1019 if(fVertexName == "default") fVertexflag = 0;
1021 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
1022 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
1023 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
1024 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
1025 UInt_t status = esdTrack->GetStatus();
1027 //select only tracks with ITS refit
1028 if ((status&AliESDtrack::kITSrefit)==0) continue;
1029 //select only tracks with TPC refit
1030 if ((status&AliESDtrack::kTPCrefit)==0) continue;
1032 //select only tracks with the "combined PID"
1033 if ((status&AliESDtrack::kESDpid)==0) continue;
1035 esdTrack->GetPxPyPz(p);
1036 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
1037 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
1038 Double_t fPt = TMath::Sqrt(pt2);
1043 etamaxPt = esdTrack->Eta();
1044 phimaxPt = esdTrack->Phi();
1048 if(esdTrack->GetSign() > 0) {
1050 if(fPt > fLowPtCut) nCh1GeV++;
1051 if(fPt > fHighPtCut) nCh3GeV++;
1052 if(fPt > fVeryHighPtCut) nCh10GeV++;
1054 if(esdTrack->GetSign() < 0) {
1056 if(fPt > fLowPtCut) nCh1GeV++;
1057 if(fPt > fHighPtCut) nCh3GeV++;
1058 if(fPt > fVeryHighPtCut) nCh10GeV++;
1060 if(esdTrack->GetSign() == 0) nNeutr++;
1064 esdTrack->GetESDpid(prob);
1067 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1068 if(rcc == 0.0) continue;
1071 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1074 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1076 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1078 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1080 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1082 if(fPt > fLowPtCut) nEl1GeV++;
1083 if(fPt > fHighPtCut) nEl3GeV++;
1084 if(fPt > fVeryHighPtCut) nEl10GeV++;
1092 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1093 // loop over all reconstructed tracks (also first track of combination)
1094 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1095 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1096 if (muonTrack == 0x0) continue;
1098 // Coordinates at vertex
1099 fZ = muonTrack->GetZ();
1100 fY = muonTrack->GetBendingCoor();
1101 fX = muonTrack->GetNonBendingCoor();
1103 fThetaX = muonTrack->GetThetaX();
1104 fThetaY = muonTrack->GetThetaY();
1106 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1107 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1108 fPxRec = fPzRec * TMath::Tan(fThetaX);
1109 fPyRec = fPzRec * TMath::Tan(fThetaY);
1110 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1112 //ChiSquare of the track if needed
1113 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1114 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1115 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1117 // total number of muons inside a vertex cut
1118 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1121 if(fEPvector.Pt() > fLowPtCut) {
1123 if(fEPvector.Pt() > fHighPtCut) {
1125 if (fEPvector.Pt() > fVeryHighPtCut) {
1133 // Fill the event tags
1134 if(ntrack != 0) meanPt = meanPt/ntrack;
1136 //First physics data
1137 const AliMultiplicity *spdMult = esd->GetMultiplicity();
1138 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
1139 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
1140 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
1142 AliESDVZERO *vzeroData = esd->GetVZEROData();
1143 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
1144 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
1145 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
1146 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
1148 //evTag->SetEventId(iEventNumber+1);
1149 evTag->SetPeriodNumber(esd->GetPeriodNumber());
1150 evTag->SetOrbitNumber(esd->GetOrbitNumber());
1151 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
1152 evTag->SetPath(filepath);
1154 evTag->SetVertexX(vertexIn->GetXv());
1155 evTag->SetVertexY(vertexIn->GetYv());
1156 evTag->SetVertexZ(vertexIn->GetZv());
1157 evTag->SetVertexZError(vertexIn->GetZRes());
1158 evTag->SetVertexFlag(fVertexflag);
1160 evTag->SetT0VertexZ(esd->GetT0zVertex());
1162 evTag->SetTriggerMask(esd->GetTriggerMask());
1163 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1165 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1166 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1167 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
1168 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
1169 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
1170 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1173 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1174 evTag->SetNumOfPosTracks(nPos);
1175 evTag->SetNumOfNegTracks(nNeg);
1176 evTag->SetNumOfNeutrTracks(nNeutr);
1178 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1179 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1180 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1181 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1183 evTag->SetNumOfProtons(nProtons);
1184 evTag->SetNumOfKaons(nKaons);
1185 evTag->SetNumOfPions(nPions);
1186 evTag->SetNumOfMuons(nMuons);
1187 evTag->SetNumOfFWMuons(nFWMuons);
1188 evTag->SetNumOfElectrons(nElectrons);
1189 evTag->SetNumOfPhotons(nGamas);
1190 evTag->SetNumOfPi0s(nPi0s);
1191 evTag->SetNumOfNeutrons(nNeutrons);
1192 evTag->SetNumOfKaon0s(nK0s);
1194 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1195 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1196 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1197 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1198 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1199 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1200 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1201 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1202 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1205 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
1207 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
1209 evTag->SetTotalMomentum(totalP);
1210 evTag->SetMeanPt(meanPt);
1211 evTag->SetMaxPt(maxPt);
1212 evTag->SetEtaMaxPt(etamaxPt);
1213 evTag->SetPhiMaxPt(phimaxPt);
1215 tag->SetRunId(iInitRunNumber);
1216 if(fIsSim) tag->SetDataType(0);
1217 else tag->SetDataType(1);
1218 tag->AddEventTag(*evTag);
1220 lastEvent = iNumberOfEvents;
1224 TString localFileName = "Run"; localFileName += tag->GetRunId();
1225 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
1226 localFileName += ".ESD.tag.root";
1231 fileName = localFileName.Data();
1232 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
1234 else if(fStorage == 1) {
1235 TString alienLocation = "/alien";
1236 alienLocation += gGrid->Pwd();
1237 alienLocation += fgridpath.Data();
1238 alienLocation += "/";
1239 alienLocation += localFileName;
1240 alienLocation += "?se=";
1241 alienLocation += fSE.Data();
1242 fileName = alienLocation.Data();
1243 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
1246 TFile* ftag = TFile::Open(fileName, "recreate");
1259 //_____________________________________________________________________________
1260 void AliESDTagCreator::CreateESDTags(Int_t fFirstEvent, Int_t fLastEvent, AliGRPObject *grpData, ULong_t * qa, Bool_t * es, Int_t qalength, Int_t eslength) {
1262 Float_t lhcLuminosity = 0.0;
1263 TString lhcState = "test";
1264 //UInt_t detectorMask = 0;
1265 Int_t detectorMask = 0;
1267 detectorMask = grpData->GetDetectorMask();
1268 time_t startTime = grpData->GetTimeStart();
1269 TTimeStamp *t1 = new TTimeStamp(startTime);
1270 time_t endTime = grpData->GetTimeEnd();
1271 TTimeStamp *t2 = new TTimeStamp(endTime);
1272 const char* beamtype = grpData->GetBeamType();
1273 Float_t beamenergy = grpData->GetBeamEnergy();
1279 Double_t fMUONMASS = 0.105658369;
1282 Double_t fThetaX, fThetaY, fPyz, fChisquare;
1283 Double_t fPxRec,fPyRec, fPzRec, fEnergy;
1285 TLorentzVector fEPvector;
1287 Float_t fZVertexCut = 10.0;
1288 Float_t fRhoVertexCut = 2.0;
1290 Float_t fLowPtCut = 1.0;
1291 Float_t fHighPtCut = 3.0;
1292 Float_t fVeryHighPtCut = 10.0;
1295 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
1297 // Creates the tags for all the events in a given ESD file
1299 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
1300 Int_t nPos, nNeg, nNeutr;
1301 Int_t nK0s, nNeutrons, nPi0s, nGamas;
1302 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
1303 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
1304 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
1305 Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
1307 Int_t iRunNumber = 0;
1308 TString fVertexName("default");
1311 AliInfo(Form("Creating the ESD tags......."));
1313 TFile *file = TFile::Open("AliESDs.root");
1314 if (!file || !file->IsOpen()) {
1315 AliError(Form("opening failed"));
1319 Int_t lastEvent = 0;
1320 TTree *b = (TTree*) file->Get("esdTree");
1321 AliESDEvent *esd = new AliESDEvent();
1322 esd->ReadFromTree(b);
1324 b->GetEntry(fFirstEvent);
1325 Int_t iInitRunNumber = esd->GetRunNumber();
1327 Int_t iNumberOfEvents = (Int_t)b->GetEntries();
1328 if(fLastEvent == -1) lastEvent = (Int_t)b->GetEntries();
1329 else lastEvent = fLastEvent;
1332 sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root",
1333 iInitRunNumber,fFirstEvent,lastEvent);
1334 AliInfo(Form("writing tags to file %s", fileName));
1335 AliDebug(1, Form("writing tags to file %s", fileName));
1337 TFile* ftag = TFile::Open(fileName, "recreate");
1339 AliRunTag *tag = new AliRunTag();
1340 AliEventTag *evTag = new AliEventTag();
1341 TTree ttag("T","A Tree with event tags");
1342 TBranch * btag = ttag.Branch("AliTAG", &tag);
1343 btag->SetCompressionLevel(9);
1345 if(fLastEvent != -1) iNumberOfEvents = fLastEvent + 1;
1346 for (Int_t iEventNumber = fFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) {
1377 b->GetEntry(iEventNumber);
1378 iRunNumber = esd->GetRunNumber();
1379 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
1380 const AliESDVertex * vertexIn = esd->GetVertex();
1381 if (!vertexIn) AliError("ESD has not defined vertex.");
1382 if (vertexIn) fVertexName = vertexIn->GetName();
1383 if(fVertexName != "default") fVertexflag = 1;
1384 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
1385 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
1386 UInt_t status = esdTrack->GetStatus();
1388 //select only tracks with ITS refit
1389 if ((status&AliESDtrack::kITSrefit)==0) continue;
1390 //select only tracks with TPC refit
1391 if ((status&AliESDtrack::kTPCrefit)==0) continue;
1393 //select only tracks with the "combined PID"
1394 if ((status&AliESDtrack::kESDpid)==0) continue;
1396 esdTrack->GetPxPyPz(p);
1397 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
1398 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
1399 Double_t fPt = TMath::Sqrt(pt2);
1404 phimaxPt = esdTrack->Eta();
1405 etamaxPt = esdTrack->Phi();
1408 if(esdTrack->GetSign() > 0) {
1410 if(fPt > fLowPtCut) nCh1GeV++;
1411 if(fPt > fHighPtCut) nCh3GeV++;
1412 if(fPt > fVeryHighPtCut) nCh10GeV++;
1414 if(esdTrack->GetSign() < 0) {
1416 if(fPt > fLowPtCut) nCh1GeV++;
1417 if(fPt > fHighPtCut) nCh3GeV++;
1418 if(fPt > fVeryHighPtCut) nCh10GeV++;
1420 if(esdTrack->GetSign() == 0) nNeutr++;
1424 esdTrack->GetESDpid(prob);
1427 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1428 if(rcc == 0.0) continue;
1431 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1434 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1436 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1438 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1440 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1442 if(fPt > fLowPtCut) nEl1GeV++;
1443 if(fPt > fHighPtCut) nEl3GeV++;
1444 if(fPt > fVeryHighPtCut) nEl10GeV++;
1452 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1453 // loop over all reconstructed tracks (also first track of combination)
1454 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1455 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1456 if (muonTrack == 0x0) continue;
1458 // Coordinates at vertex
1459 fZ = muonTrack->GetZ();
1460 fY = muonTrack->GetBendingCoor();
1461 fX = muonTrack->GetNonBendingCoor();
1463 fThetaX = muonTrack->GetThetaX();
1464 fThetaY = muonTrack->GetThetaY();
1466 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1467 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1468 fPxRec = fPzRec * TMath::Tan(fThetaX);
1469 fPyRec = fPzRec * TMath::Tan(fThetaY);
1470 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1472 //ChiSquare of the track if needed
1473 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1474 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1475 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1477 // total number of muons inside a vertex cut
1478 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1481 if(fEPvector.Pt() > fLowPtCut) {
1483 if(fEPvector.Pt() > fHighPtCut) {
1485 if (fEPvector.Pt() > fVeryHighPtCut) {
1494 // Fill the event tags
1496 meanPt = meanPt/ntrack;
1498 //First physics data
1499 const AliMultiplicity *spdMult = esd->GetMultiplicity();
1500 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
1501 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
1502 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
1504 AliESDVZERO *vzeroData = esd->GetVZEROData();
1505 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
1506 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
1507 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
1508 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
1510 //evTag->SetEventId(iEventNumber+1);
1511 evTag->SetPeriodNumber(esd->GetPeriodNumber());
1512 evTag->SetOrbitNumber(esd->GetOrbitNumber());
1513 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
1515 evTag->SetVertexX(vertexIn->GetXv());
1516 evTag->SetVertexY(vertexIn->GetYv());
1517 evTag->SetVertexZ(vertexIn->GetZv());
1518 evTag->SetVertexZError(vertexIn->GetZRes());
1520 evTag->SetVertexFlag(fVertexflag);
1522 evTag->SetT0VertexZ(esd->GetT0zVertex());
1524 evTag->SetTriggerMask(esd->GetTriggerMask());
1525 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1527 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1528 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1529 evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
1530 evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
1531 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
1532 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1535 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1536 evTag->SetNumOfPosTracks(nPos);
1537 evTag->SetNumOfNegTracks(nNeg);
1538 evTag->SetNumOfNeutrTracks(nNeutr);
1540 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1541 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1542 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1543 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1545 evTag->SetNumOfProtons(nProtons);
1546 evTag->SetNumOfKaons(nKaons);
1547 evTag->SetNumOfPions(nPions);
1548 evTag->SetNumOfMuons(nMuons);
1549 evTag->SetNumOfFWMuons(nFWMuons);
1550 evTag->SetNumOfElectrons(nElectrons);
1551 evTag->SetNumOfPhotons(nGamas);
1552 evTag->SetNumOfPi0s(nPi0s);
1553 evTag->SetNumOfNeutrons(nNeutrons);
1554 evTag->SetNumOfKaon0s(nK0s);
1556 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1557 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1558 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1559 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1560 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1561 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1562 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1563 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1564 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1567 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
1569 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
1571 evTag->SetTotalMomentum(totalP);
1572 evTag->SetMeanPt(meanPt);
1573 evTag->SetMaxPt(maxPt);
1574 evTag->SetEtaMaxPt(etamaxPt);
1575 evTag->SetPhiMaxPt(phimaxPt);
1577 tag->SetLHCTag(lhcLuminosity,lhcState);
1578 tag->SetDetectorTag(detectorMask);
1580 tag->SetRunId(iInitRunNumber);
1581 tag->SetRunStartTime(t1->GetDate());
1582 tag->SetRunStopTime(t2->GetDate());
1583 tag->SetBeamEnergy(beamenergy);
1584 tag->SetBeamType(beamtype);
1587 tag->SetQAArray(qa, qalength) ;
1588 tag->SetEventSpecies(es, eslength) ;
1590 tag->AddEventTag(*evTag);
1603 //_____________________________________________________________________________
1604 void AliESDTagCreator::SwitchOffBranches() const {
1606 // Switch of branches on user request
1607 TObjArray * tokens = fBranches.Tokenize(" ");
1608 Int_t ntok = tokens->GetEntries();
1609 for (Int_t i = 0; i < ntok; i++) {
1610 TString str = ((TObjString*) tokens->At(i))->GetString();
1611 fChain->SetBranchStatus(Form("%s%s%s","*", str.Data(), "*"), 0);
1612 AliInfo(Form("Branch %s switched off \n", str.Data()));