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>
37 #include <TGridResult.h>
40 #include "AliRunTag.h"
41 #include "AliEventTag.h"
43 #include "AliESDEvent.h"
44 #include "AliESDVertex.h"
46 #include "AliGRPObject.h"
48 #include "AliESDTagCreator.h"
51 ClassImp(AliESDTagCreator)
54 //______________________________________________________________________________
55 AliESDTagCreator::AliESDTagCreator() :
57 fChain(new TChain("esdTree")), fGUIDList(new TList()),
58 fMD5List(new TList()), fTURLList(new TList()), fBranches(""),
59 meminfo(new MemInfo_t) {
60 //==============Default constructor for a AliESDTagCreator================
63 //______________________________________________________________________________
64 AliESDTagCreator::~AliESDTagCreator() {
65 //================Default destructor for a AliESDTagCreator===================
73 //______________________________________________________________________________
74 Bool_t AliESDTagCreator::ReadGridCollection(TGridResult *fresult) {
75 // Reads the entry of the TGridResult and creates the tags
76 Int_t nEntries = fresult->GetEntries();
85 for(Int_t i = 0; i < nEntries; i++) {
86 alienUrl = fresult->GetKey(i,"turl");
87 guid = fresult->GetKey(i,"guid");
88 if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
89 md5 = fresult->GetKey(i,"md5");
90 turl = fresult->GetKey(i,"turl");
91 if(md5 && !strlen(guid)) md5 = 0;
92 if(guid && !strlen(guid)) guid = 0;
94 fChain->Add(alienUrl);
95 //fGUIDList->Add(new TObjString(guid));
96 //fMD5List->Add(new TObjString(md5));
97 //fTURLList->Add(new TObjString(turl));
99 //TFile *f = TFile::Open(alienUrl,"READ");
100 //CreateTag(f,guid,md5,turl,size,counter);
106 AliInfo(Form("ESD chain created......."));
107 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
108 // Switch of branches on user request
110 CreateTag(fChain,"grid");
115 //______________________________________________________________________________
116 Bool_t AliESDTagCreator::ReadLocalCollection(const char *localpath) {
117 // Checks the different subdirs of the given local path and in the
118 // case where it finds an AliESDs.root file it creates the tags
120 void *dira = gSystem->OpenDirectory(localpath);
122 const char * dirname = 0x0;
123 const char * filename = 0x0;
124 const char * pattern = "AliESDs.root";
127 while((dirname = gSystem->GetDirEntry(dira))) {
128 sprintf(fPath,"%s/%s",localpath,dirname);
129 void *dirb = gSystem->OpenDirectory(fPath);
130 while((filename = gSystem->GetDirEntry(dirb))) {
131 if(strstr(filename,pattern)) {
132 TString fESDFileName;
133 fESDFileName = fPath;
135 fESDFileName += pattern;
137 fChain->Add(fESDFileName);
139 //TFile *f = TFile::Open(fESDFileName,"READ");
140 //CreateTag(f,fESDFileName,counter);
146 }//child directory's entry loop
147 }//parent directory's entry loop
149 AliInfo(Form("ESD chain created......."));
150 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
151 // Switch of branches on user request
153 CreateTag(fChain,"local");
158 //______________________________________________________________________________
159 Bool_t AliESDTagCreator::ReadCAFCollection(const char *filename) {
160 // Temporary solution for CAF: Takes as an input the ascii file that
161 // lists the ESDs stored in the SE of the CAF and creates the tags.
163 // Open the input stream
169 // Read the input list of files and add them to the chain
172 if (!esdfile.Contains("root")) continue; // protection
174 fChain->Add(esdfile);
176 //TFile *f = TFile::Open(esdfile,"READ");
177 //CreateTag(f,esdfile,counter);
184 AliInfo(Form("ESD chain created......."));
185 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
186 // Switch of branches on user request
188 CreateTag(fChain,"proof");
193 //_____________________________________________________________________________
194 void AliESDTagCreator::CreateTag(TChain* chain, const char *type) {
195 //private method that creates tag files
196 TString fSession = type;
197 TString fguid, fmd5, fturl;
198 TString fTempGuid = 0;
203 Double_t fMUONMASS = 0.105658369;
206 Double_t fThetaX, fThetaY, fPyz, fChisquare;
207 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
209 TLorentzVector fEPvector;
211 Float_t fZVertexCut = 10.0;
212 Float_t fRhoVertexCut = 2.0;
214 Float_t fLowPtCut = 1.0;
215 Float_t fHighPtCut = 3.0;
216 Float_t fVeryHighPtCut = 10.0;
219 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
221 // Creates the tags for all the events in a given ESD file
222 Bool_t fIsSim = kTRUE;
224 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
225 Int_t nPos, nNeg, nNeutr;
226 Int_t nK0s, nNeutrons, nPi0s, nGamas;
227 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
228 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
229 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
230 Float_t maxPt = .0, meanPt = .0, totalP = .0;
232 Int_t iRunNumber = 0;
235 //gSystem->GetMemInfo(meminfo);
236 //AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
237 //Int_t tempmem = meminfo->fMemUsed;
239 AliInfo(Form("Creating the ESD tags......."));
241 Int_t firstEvent = 0,lastEvent = 0;
242 AliESDEvent *esd = new AliESDEvent();
243 esd->ReadFromTree(chain);
244 AliESD *esdold = 0x0;
246 //gSystem->GetMemInfo(meminfo);
247 //AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
248 //tempmem = meminfo->fMemUsed;
250 Int_t iInitRunNumber = -1;
252 TFile *f = chain->GetFile();
253 fTempGuid = f->GetUUID().AsString();
255 TString localFileName = "Run"; localFileName += esd->GetRunNumber();
256 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
257 localFileName += ".ESD.tag.root";
262 fileName = localFileName.Data();
263 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
265 else if(fStorage == 1) {
266 TString alienLocation = "/alien";
267 alienLocation += gGrid->Pwd();
268 alienLocation += fgridpath.Data();
269 alienLocation += "/";
270 alienLocation += localFileName;
271 alienLocation += "?se=";
272 alienLocation += fSE.Data();
273 fileName = alienLocation.Data();
274 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
277 TFile* ftag = TFile::Open(fileName, "recreate");
279 AliRunTag *tag = new AliRunTag();
280 AliEventTag *evTag = new AliEventTag();
281 TTree ttag("T","A Tree with event tags");
282 TBranch * btag = ttag.Branch("AliTAG", &tag);
283 btag->SetCompressionLevel(9);
285 for(Int_t iEventNumber = 0; iEventNumber < chain->GetEntries(); iEventNumber++) {
286 ntrack = 0; nPos = 0; nNeg = 0; nNeutr =0;
287 nK0s = 0; nNeutrons = 0; nPi0s = 0;
288 nGamas = 0; nProtons = 0; nKaons = 0;
289 nPions = 0; nMuons = 0; nElectrons = 0; nFWMuons = 0;
290 nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
291 nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
292 nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
293 maxPt = .0; meanPt = .0; totalP = .0;
296 chain->GetEntry(iEventNumber);
297 esdold = esd->GetAliESDOld();
298 if(esdold) esd->CopyFromOldESD();
300 TFile *file = chain->GetFile();
301 const TUrl *url = file->GetEndpointUrl();
302 fguid = file->GetUUID().AsString();
303 if(fSession == "grid") {
304 TString fturltemp = "alien://"; fturltemp += url->GetFile();
305 fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
307 else fturl = url->GetFile();
309 if(iEventNumber == 0) iInitRunNumber = esd->GetRunNumber();
310 iRunNumber = esd->GetRunNumber();
311 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD - You are trying to merge different runs!!!");
313 const AliESDVertex * vertexIn = esd->GetVertex();
314 fVertexName = vertexIn->GetName();
315 if(fVertexName == "default") fVertexflag = 0;
317 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
318 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
319 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
320 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
321 UInt_t status = esdTrack->GetStatus();
323 //select only tracks with ITS refit
324 if ((status&AliESDtrack::kITSrefit)==0) continue;
325 //select only tracks with TPC refit
326 if ((status&AliESDtrack::kTPCrefit)==0) continue;
328 //select only tracks with the "combined PID"
329 if ((status&AliESDtrack::kESDpid)==0) continue;
331 esdTrack->GetPxPyPz(p);
332 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
333 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
336 if(fPt > maxPt) maxPt = fPt;
338 if(esdTrack->GetSign() > 0) {
340 if(fPt > fLowPtCut) nCh1GeV++;
341 if(fPt > fHighPtCut) nCh3GeV++;
342 if(fPt > fVeryHighPtCut) nCh10GeV++;
344 if(esdTrack->GetSign() < 0) {
346 if(fPt > fLowPtCut) nCh1GeV++;
347 if(fPt > fHighPtCut) nCh3GeV++;
348 if(fPt > fVeryHighPtCut) nCh10GeV++;
350 if(esdTrack->GetSign() == 0) nNeutr++;
354 esdTrack->GetESDpid(prob);
357 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
358 if(rcc == 0.0) continue;
361 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
364 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
366 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
368 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
370 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
372 if(fPt > fLowPtCut) nEl1GeV++;
373 if(fPt > fHighPtCut) nEl3GeV++;
374 if(fPt > fVeryHighPtCut) nEl10GeV++;
382 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
383 // loop over all reconstructed tracks (also first track of combination)
384 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
385 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
386 if (muonTrack == 0x0) continue;
388 // Coordinates at vertex
389 fZ = muonTrack->GetZ();
390 fY = muonTrack->GetBendingCoor();
391 fX = muonTrack->GetNonBendingCoor();
393 fThetaX = muonTrack->GetThetaX();
394 fThetaY = muonTrack->GetThetaY();
396 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
397 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
398 fPxRec = fPzRec * TMath::Tan(fThetaX);
399 fPyRec = fPzRec * TMath::Tan(fThetaY);
400 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
402 //ChiSquare of the track if needed
403 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
404 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
405 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
407 // total number of muons inside a vertex cut
408 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
411 if(fEPvector.Pt() > fLowPtCut) {
413 if(fEPvector.Pt() > fHighPtCut) {
415 if (fEPvector.Pt() > fVeryHighPtCut) {
423 // Fill the event tags
424 if(ntrack != 0) meanPt = meanPt/ntrack;
426 //AliInfo(Form("====================================="));
427 //AliInfo(Form("URL: %s - GUID: %s",fturl.Data(),fguid.Data()));
428 //AliInfo(Form("====================================="));
430 evTag->SetEventId(iEventNumber+1);
431 evTag->SetGUID(fguid);
432 if(fSession == "grid") {
434 evTag->SetTURL(fturl);
437 else evTag->SetPath(fturl);
439 evTag->SetVertexX(vertexIn->GetXv());
440 evTag->SetVertexY(vertexIn->GetYv());
441 evTag->SetVertexZ(vertexIn->GetZv());
442 evTag->SetVertexZError(vertexIn->GetZRes());
443 evTag->SetVertexFlag(fVertexflag);
445 evTag->SetT0VertexZ(esd->GetT0zVertex());
447 evTag->SetTriggerMask(esd->GetTriggerMask());
448 evTag->SetTriggerCluster(esd->GetTriggerCluster());
450 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
451 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
452 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
453 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
454 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
455 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
456 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
457 evTag->SetNumOfParticipants2(esd->GetZDCParticipants2());
460 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
461 evTag->SetNumOfPosTracks(nPos);
462 evTag->SetNumOfNegTracks(nNeg);
463 evTag->SetNumOfNeutrTracks(nNeutr);
465 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
466 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
467 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
468 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
470 evTag->SetNumOfProtons(nProtons);
471 evTag->SetNumOfKaons(nKaons);
472 evTag->SetNumOfPions(nPions);
473 evTag->SetNumOfMuons(nMuons);
474 evTag->SetNumOfFWMuons(nFWMuons);
475 evTag->SetNumOfElectrons(nElectrons);
476 evTag->SetNumOfPhotons(nGamas);
477 evTag->SetNumOfPi0s(nPi0s);
478 evTag->SetNumOfNeutrons(nNeutrons);
479 evTag->SetNumOfKaon0s(nK0s);
481 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
482 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
483 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
484 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
485 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
486 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
487 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
488 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
489 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
491 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
492 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
494 evTag->SetTotalMomentum(totalP);
495 evTag->SetMeanPt(meanPt);
496 evTag->SetMaxPt(maxPt);
498 tag->SetRunId(iInitRunNumber);
499 if(fIsSim) tag->SetDataType(0);
500 else tag->SetDataType(1);
502 if(fguid != fTempGuid) {
507 tag->AddEventTag(*evTag);
508 if(iEventNumber+1 == chain->GetEntries()) {
509 //AliInfo(Form("File: %s",fturl.Data()));
514 lastEvent = chain->GetEntries();
516 //gSystem->GetMemInfo(meminfo);
517 //AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
518 //tempmem = meminfo->fMemUsed;
522 //gSystem->GetMemInfo(meminfo);
523 //AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
524 //tempmem = meminfo->fMemUsed;
531 //gSystem->GetMemInfo(meminfo);
532 //AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
533 //tempmem = meminfo->fMemUsed;
538 //gSystem->GetMemInfo(meminfo);
539 //AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
542 //_____________________________________________________________________________
543 void AliESDTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
544 //private method that creates tag files
545 TString fguid = guid;
547 TString fturl = turl;
551 Double_t fMUONMASS = 0.105658369;
554 Double_t fThetaX, fThetaY, fPyz, fChisquare;
555 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
557 TLorentzVector fEPvector;
559 Float_t fZVertexCut = 10.0;
560 Float_t fRhoVertexCut = 2.0;
562 Float_t fLowPtCut = 1.0;
563 Float_t fHighPtCut = 3.0;
564 Float_t fVeryHighPtCut = 10.0;
567 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
569 // Creates the tags for all the events in a given ESD file
570 Bool_t fIsSim = kTRUE;
572 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
573 Int_t nPos, nNeg, nNeutr;
574 Int_t nK0s, nNeutrons, nPi0s, nGamas;
575 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
576 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
577 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
578 Float_t maxPt = .0, meanPt = .0, totalP = .0;
580 Int_t iRunNumber = 0;
583 AliRunTag *tag = new AliRunTag();
584 AliEventTag *evTag = new AliEventTag();
585 TTree ttag("T","A Tree with event tags");
586 TBranch * btag = ttag.Branch("AliTAG", &tag);
587 btag->SetCompressionLevel(9);
588 gSystem->GetMemInfo(meminfo);
589 AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
590 Int_t tempmem = meminfo->fMemUsed;
592 AliInfo(Form("Creating the ESD tags......."));
594 Int_t firstEvent = 0,lastEvent = 0;
595 TTree *t = (TTree*) file->Get("esdTree");
596 AliESDEvent *esd = new AliESDEvent();
597 esd->ReadFromTree(t);
599 gSystem->GetMemInfo(meminfo);
600 AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
601 tempmem = meminfo->fMemUsed;
604 Int_t iInitRunNumber = esd->GetRunNumber();
606 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
607 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
636 t->GetEntry(iEventNumber);
637 iRunNumber = esd->GetRunNumber();
638 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
639 const AliESDVertex * vertexIn = esd->GetVertex();
640 fVertexName = vertexIn->GetName();
641 if(fVertexName == "default") fVertexflag = 0;
643 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
644 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
645 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
646 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
647 UInt_t status = esdTrack->GetStatus();
649 //select only tracks with ITS refit
650 if ((status&AliESDtrack::kITSrefit)==0) continue;
651 //select only tracks with TPC refit
652 if ((status&AliESDtrack::kTPCrefit)==0) continue;
654 //select only tracks with the "combined PID"
655 if ((status&AliESDtrack::kESDpid)==0) continue;
657 esdTrack->GetPxPyPz(p);
658 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
659 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
662 if(fPt > maxPt) maxPt = fPt;
664 if(esdTrack->GetSign() > 0) {
666 if(fPt > fLowPtCut) nCh1GeV++;
667 if(fPt > fHighPtCut) nCh3GeV++;
668 if(fPt > fVeryHighPtCut) nCh10GeV++;
670 if(esdTrack->GetSign() < 0) {
672 if(fPt > fLowPtCut) nCh1GeV++;
673 if(fPt > fHighPtCut) nCh3GeV++;
674 if(fPt > fVeryHighPtCut) nCh10GeV++;
676 if(esdTrack->GetSign() == 0) nNeutr++;
680 esdTrack->GetESDpid(prob);
683 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
684 if(rcc == 0.0) continue;
687 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
690 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
692 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
694 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
696 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
698 if(fPt > fLowPtCut) nEl1GeV++;
699 if(fPt > fHighPtCut) nEl3GeV++;
700 if(fPt > fVeryHighPtCut) nEl10GeV++;
708 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
709 // loop over all reconstructed tracks (also first track of combination)
710 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
711 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
712 if (muonTrack == 0x0) continue;
714 // Coordinates at vertex
715 fZ = muonTrack->GetZ();
716 fY = muonTrack->GetBendingCoor();
717 fX = muonTrack->GetNonBendingCoor();
719 fThetaX = muonTrack->GetThetaX();
720 fThetaY = muonTrack->GetThetaY();
722 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
723 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
724 fPxRec = fPzRec * TMath::Tan(fThetaX);
725 fPyRec = fPzRec * TMath::Tan(fThetaY);
726 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
728 //ChiSquare of the track if needed
729 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
730 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
731 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
733 // total number of muons inside a vertex cut
734 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
737 if(fEPvector.Pt() > fLowPtCut) {
739 if(fEPvector.Pt() > fHighPtCut) {
741 if (fEPvector.Pt() > fVeryHighPtCut) {
749 // Fill the event tags
750 if(ntrack != 0) meanPt = meanPt/ntrack;
752 evTag->SetEventId(iEventNumber+1);
753 evTag->SetGUID(fguid);
755 evTag->SetTURL(fturl);
756 evTag->SetSize(size);
757 evTag->SetVertexX(vertexIn->GetXv());
758 evTag->SetVertexY(vertexIn->GetYv());
759 evTag->SetVertexZ(vertexIn->GetZv());
760 evTag->SetVertexZError(vertexIn->GetZRes());
761 evTag->SetVertexFlag(fVertexflag);
763 evTag->SetT0VertexZ(esd->GetT0zVertex());
765 evTag->SetTriggerMask(esd->GetTriggerMask());
766 evTag->SetTriggerCluster(esd->GetTriggerCluster());
768 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
769 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
770 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
771 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
772 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
773 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
776 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
777 evTag->SetNumOfPosTracks(nPos);
778 evTag->SetNumOfNegTracks(nNeg);
779 evTag->SetNumOfNeutrTracks(nNeutr);
781 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
782 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
783 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
784 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
786 evTag->SetNumOfProtons(nProtons);
787 evTag->SetNumOfKaons(nKaons);
788 evTag->SetNumOfPions(nPions);
789 evTag->SetNumOfMuons(nMuons);
790 evTag->SetNumOfFWMuons(nFWMuons);
791 evTag->SetNumOfElectrons(nElectrons);
792 evTag->SetNumOfPhotons(nGamas);
793 evTag->SetNumOfPi0s(nPi0s);
794 evTag->SetNumOfNeutrons(nNeutrons);
795 evTag->SetNumOfKaon0s(nK0s);
797 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
798 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
799 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
800 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
801 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
802 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
803 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
804 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
805 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
807 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
808 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
810 evTag->SetTotalMomentum(totalP);
811 evTag->SetMeanPt(meanPt);
812 evTag->SetMaxPt(maxPt);
814 tag->SetRunId(iInitRunNumber);
815 if(fIsSim) tag->SetDataType(0);
816 else tag->SetDataType(1);
817 tag->AddEventTag(*evTag);
819 lastEvent = iNumberOfEvents;
821 gSystem->GetMemInfo(meminfo);
822 AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
823 tempmem = meminfo->fMemUsed;
826 gSystem->GetMemInfo(meminfo);
827 AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
828 tempmem = meminfo->fMemUsed;
830 TString localFileName = "Run"; localFileName += tag->GetRunId();
831 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
832 localFileName += ".ESD.tag.root";
837 fileName = localFileName.Data();
838 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
840 else if(fStorage == 1) {
841 TString alienLocation = "/alien";
842 alienLocation += gGrid->Pwd();
843 alienLocation += fgridpath.Data();
844 alienLocation += "/";
845 alienLocation += localFileName;
846 alienLocation += "?se=";
847 alienLocation += fSE.Data();
848 fileName = alienLocation.Data();
849 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
852 TFile* ftag = TFile::Open(fileName, "recreate");
859 gSystem->GetMemInfo(meminfo);
860 AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
861 tempmem = meminfo->fMemUsed;
867 gSystem->GetMemInfo(meminfo);
868 AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
871 //_____________________________________________________________________________
872 void AliESDTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
873 //private method that creates tag files
877 Double_t fMUONMASS = 0.105658369;
880 Double_t fThetaX, fThetaY, fPyz, fChisquare;
881 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
883 TLorentzVector fEPvector;
885 Float_t fZVertexCut = 10.0;
886 Float_t fRhoVertexCut = 2.0;
888 Float_t fLowPtCut = 1.0;
889 Float_t fHighPtCut = 3.0;
890 Float_t fVeryHighPtCut = 10.0;
893 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
895 // Creates the tags for all the events in a given ESD file
896 Bool_t fIsSim = kTRUE;
898 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
899 Int_t nPos, nNeg, nNeutr;
900 Int_t nK0s, nNeutrons, nPi0s, nGamas;
901 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
902 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
903 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
904 Float_t maxPt = .0, meanPt = .0, totalP = .0;
906 Int_t iRunNumber = 0;
909 AliRunTag *tag = new AliRunTag();
910 AliEventTag *evTag = new AliEventTag();
911 TTree ttag("T","A Tree with event tags");
912 TBranch * btag = ttag.Branch("AliTAG", &tag);
913 btag->SetCompressionLevel(9);
915 AliInfo(Form("Creating the ESD tags......."));
917 Int_t firstEvent = 0,lastEvent = 0;
919 TTree *t = (TTree*) file->Get("esdTree");
920 AliESDEvent *esd = new AliESDEvent();
921 esd->ReadFromTree(t);
924 Int_t iInitRunNumber = esd->GetRunNumber();
926 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
927 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
956 t->GetEntry(iEventNumber);
957 iRunNumber = esd->GetRunNumber();
958 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
959 const AliESDVertex * vertexIn = esd->GetVertex();
960 fVertexName = vertexIn->GetName();
961 if(fVertexName == "default") fVertexflag = 0;
963 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
964 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
965 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
966 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
967 UInt_t status = esdTrack->GetStatus();
969 //select only tracks with ITS refit
970 if ((status&AliESDtrack::kITSrefit)==0) continue;
971 //select only tracks with TPC refit
972 if ((status&AliESDtrack::kTPCrefit)==0) continue;
974 //select only tracks with the "combined PID"
975 if ((status&AliESDtrack::kESDpid)==0) continue;
977 esdTrack->GetPxPyPz(p);
978 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
979 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
982 if(fPt > maxPt) maxPt = fPt;
984 if(esdTrack->GetSign() > 0) {
986 if(fPt > fLowPtCut) nCh1GeV++;
987 if(fPt > fHighPtCut) nCh3GeV++;
988 if(fPt > fVeryHighPtCut) nCh10GeV++;
990 if(esdTrack->GetSign() < 0) {
992 if(fPt > fLowPtCut) nCh1GeV++;
993 if(fPt > fHighPtCut) nCh3GeV++;
994 if(fPt > fVeryHighPtCut) nCh10GeV++;
996 if(esdTrack->GetSign() == 0) nNeutr++;
1000 esdTrack->GetESDpid(prob);
1003 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1004 if(rcc == 0.0) continue;
1007 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1010 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1012 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1014 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1016 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1018 if(fPt > fLowPtCut) nEl1GeV++;
1019 if(fPt > fHighPtCut) nEl3GeV++;
1020 if(fPt > fVeryHighPtCut) nEl10GeV++;
1028 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1029 // loop over all reconstructed tracks (also first track of combination)
1030 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1031 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1032 if (muonTrack == 0x0) continue;
1034 // Coordinates at vertex
1035 fZ = muonTrack->GetZ();
1036 fY = muonTrack->GetBendingCoor();
1037 fX = muonTrack->GetNonBendingCoor();
1039 fThetaX = muonTrack->GetThetaX();
1040 fThetaY = muonTrack->GetThetaY();
1042 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1043 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1044 fPxRec = fPzRec * TMath::Tan(fThetaX);
1045 fPyRec = fPzRec * TMath::Tan(fThetaY);
1046 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1048 //ChiSquare of the track if needed
1049 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1050 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1051 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1053 // total number of muons inside a vertex cut
1054 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1057 if(fEPvector.Pt() > fLowPtCut) {
1059 if(fEPvector.Pt() > fHighPtCut) {
1061 if (fEPvector.Pt() > fVeryHighPtCut) {
1069 // Fill the event tags
1070 if(ntrack != 0) meanPt = meanPt/ntrack;
1072 evTag->SetEventId(iEventNumber+1);
1073 evTag->SetPath(filepath);
1075 evTag->SetVertexX(vertexIn->GetXv());
1076 evTag->SetVertexY(vertexIn->GetYv());
1077 evTag->SetVertexZ(vertexIn->GetZv());
1078 evTag->SetVertexZError(vertexIn->GetZRes());
1079 evTag->SetVertexFlag(fVertexflag);
1081 evTag->SetT0VertexZ(esd->GetT0zVertex());
1083 evTag->SetTriggerMask(esd->GetTriggerMask());
1084 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1086 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1087 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1088 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
1089 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
1090 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
1091 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1094 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1095 evTag->SetNumOfPosTracks(nPos);
1096 evTag->SetNumOfNegTracks(nNeg);
1097 evTag->SetNumOfNeutrTracks(nNeutr);
1099 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1100 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1101 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1102 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1104 evTag->SetNumOfProtons(nProtons);
1105 evTag->SetNumOfKaons(nKaons);
1106 evTag->SetNumOfPions(nPions);
1107 evTag->SetNumOfMuons(nMuons);
1108 evTag->SetNumOfFWMuons(nFWMuons);
1109 evTag->SetNumOfElectrons(nElectrons);
1110 evTag->SetNumOfPhotons(nGamas);
1111 evTag->SetNumOfPi0s(nPi0s);
1112 evTag->SetNumOfNeutrons(nNeutrons);
1113 evTag->SetNumOfKaon0s(nK0s);
1115 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1116 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1117 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1118 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1119 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1120 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1121 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1122 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1123 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1125 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
1126 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
1128 evTag->SetTotalMomentum(totalP);
1129 evTag->SetMeanPt(meanPt);
1130 evTag->SetMaxPt(maxPt);
1132 tag->SetRunId(iInitRunNumber);
1133 if(fIsSim) tag->SetDataType(0);
1134 else tag->SetDataType(1);
1135 tag->AddEventTag(*evTag);
1137 lastEvent = iNumberOfEvents;
1141 TString localFileName = "Run"; localFileName += tag->GetRunId();
1142 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
1143 localFileName += ".ESD.tag.root";
1148 fileName = localFileName.Data();
1149 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
1151 else if(fStorage == 1) {
1152 TString alienLocation = "/alien";
1153 alienLocation += gGrid->Pwd();
1154 alienLocation += fgridpath.Data();
1155 alienLocation += "/";
1156 alienLocation += localFileName;
1157 alienLocation += "?se=";
1158 alienLocation += fSE.Data();
1159 fileName = alienLocation.Data();
1160 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
1163 TFile* ftag = TFile::Open(fileName, "recreate");
1176 //_____________________________________________________________________________
1177 void AliESDTagCreator::CreateESDTags(Int_t fFirstEvent, Int_t fLastEvent, AliGRPObject *grpData) {
1179 Float_t lhcLuminosity = 0.0;
1180 TString lhcState = "test";
1181 //UInt_t detectorMask = 0;
1182 Int_t detectorMask = 0;
1184 detectorMask = grpData->GetDetectorMask();
1185 time_t startTime = grpData->GetTimeStart();
1186 TTimeStamp *t1 = new TTimeStamp(startTime);
1187 time_t endTime = grpData->GetTimeEnd();
1188 TTimeStamp *t2 = new TTimeStamp(endTime);
1189 const char* beamtype = grpData->GetBeamType();
1190 Float_t beamenergy = grpData->GetBeamEnergy();
1196 Double_t fMUONMASS = 0.105658369;
1199 Double_t fThetaX, fThetaY, fPyz, fChisquare;
1200 Double_t fPxRec,fPyRec, fPzRec, fEnergy;
1202 TLorentzVector fEPvector;
1204 Float_t fZVertexCut = 10.0;
1205 Float_t fRhoVertexCut = 2.0;
1207 Float_t fLowPtCut = 1.0;
1208 Float_t fHighPtCut = 3.0;
1209 Float_t fVeryHighPtCut = 10.0;
1212 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
1214 // Creates the tags for all the events in a given ESD file
1216 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
1217 Int_t nPos, nNeg, nNeutr;
1218 Int_t nK0s, nNeutrons, nPi0s, nGamas;
1219 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
1220 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
1221 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
1222 Float_t maxPt = .0, meanPt = .0, totalP = .0;
1224 Int_t iRunNumber = 0;
1225 TString fVertexName("default");
1227 AliInfo(Form("Creating the ESD tags......."));
1229 TFile *file = TFile::Open("AliESDs.root");
1230 if (!file || !file->IsOpen()) {
1231 AliError(Form("opening failed"));
1235 Int_t lastEvent = 0;
1236 TTree *b = (TTree*) file->Get("esdTree");
1237 AliESDEvent *esd = new AliESDEvent();
1238 esd->ReadFromTree(b);
1240 b->GetEntry(fFirstEvent);
1241 Int_t iInitRunNumber = esd->GetRunNumber();
1243 Int_t iNumberOfEvents = (Int_t)b->GetEntries();
1244 if(fLastEvent == -1) lastEvent = (Int_t)b->GetEntries();
1245 else lastEvent = fLastEvent;
1248 sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root",
1249 iInitRunNumber,fFirstEvent,lastEvent);
1250 AliInfo(Form("writing tags to file %s", fileName));
1251 AliDebug(1, Form("writing tags to file %s", fileName));
1253 TFile* ftag = TFile::Open(fileName, "recreate");
1255 AliRunTag *tag = new AliRunTag();
1256 AliEventTag *evTag = new AliEventTag();
1257 TTree ttag("T","A Tree with event tags");
1258 TBranch * btag = ttag.Branch("AliTAG", &tag);
1259 btag->SetCompressionLevel(9);
1261 if(fLastEvent != -1) iNumberOfEvents = fLastEvent + 1;
1262 for (Int_t iEventNumber = fFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) {
1291 b->GetEntry(iEventNumber);
1292 iRunNumber = esd->GetRunNumber();
1293 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
1294 const AliESDVertex * vertexIn = esd->GetVertex();
1295 if (!vertexIn) AliError("ESD has not defined vertex.");
1296 if (vertexIn) fVertexName = vertexIn->GetName();
1297 if(fVertexName != "default") fVertexflag = 1;
1298 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
1299 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
1300 UInt_t status = esdTrack->GetStatus();
1302 //select only tracks with ITS refit
1303 if ((status&AliESDtrack::kITSrefit)==0) continue;
1304 //select only tracks with TPC refit
1305 if ((status&AliESDtrack::kTPCrefit)==0) continue;
1307 //select only tracks with the "combined PID"
1308 if ((status&AliESDtrack::kESDpid)==0) continue;
1310 esdTrack->GetPxPyPz(p);
1311 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
1312 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
1315 if(fPt > maxPt) maxPt = fPt;
1317 if(esdTrack->GetSign() > 0) {
1319 if(fPt > fLowPtCut) nCh1GeV++;
1320 if(fPt > fHighPtCut) nCh3GeV++;
1321 if(fPt > fVeryHighPtCut) nCh10GeV++;
1323 if(esdTrack->GetSign() < 0) {
1325 if(fPt > fLowPtCut) nCh1GeV++;
1326 if(fPt > fHighPtCut) nCh3GeV++;
1327 if(fPt > fVeryHighPtCut) nCh10GeV++;
1329 if(esdTrack->GetSign() == 0) nNeutr++;
1333 esdTrack->GetESDpid(prob);
1336 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1337 if(rcc == 0.0) continue;
1340 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1343 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1345 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1347 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1349 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1351 if(fPt > fLowPtCut) nEl1GeV++;
1352 if(fPt > fHighPtCut) nEl3GeV++;
1353 if(fPt > fVeryHighPtCut) nEl10GeV++;
1361 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1362 // loop over all reconstructed tracks (also first track of combination)
1363 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1364 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1365 if (muonTrack == 0x0) continue;
1367 // Coordinates at vertex
1368 fZ = muonTrack->GetZ();
1369 fY = muonTrack->GetBendingCoor();
1370 fX = muonTrack->GetNonBendingCoor();
1372 fThetaX = muonTrack->GetThetaX();
1373 fThetaY = muonTrack->GetThetaY();
1375 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1376 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1377 fPxRec = fPzRec * TMath::Tan(fThetaX);
1378 fPyRec = fPzRec * TMath::Tan(fThetaY);
1379 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1381 //ChiSquare of the track if needed
1382 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1383 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1384 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1386 // total number of muons inside a vertex cut
1387 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1390 if(fEPvector.Pt() > fLowPtCut) {
1392 if(fEPvector.Pt() > fHighPtCut) {
1394 if (fEPvector.Pt() > fVeryHighPtCut) {
1402 // Fill the event tags
1404 meanPt = meanPt/ntrack;
1406 evTag->SetEventId(iEventNumber+1);
1408 evTag->SetVertexX(vertexIn->GetXv());
1409 evTag->SetVertexY(vertexIn->GetYv());
1410 evTag->SetVertexZ(vertexIn->GetZv());
1411 evTag->SetVertexZError(vertexIn->GetZRes());
1413 evTag->SetVertexFlag(fVertexflag);
1415 evTag->SetT0VertexZ(esd->GetT0zVertex());
1417 evTag->SetTriggerMask(esd->GetTriggerMask());
1418 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1420 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1421 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1422 evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
1423 evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
1424 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
1425 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1428 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1429 evTag->SetNumOfPosTracks(nPos);
1430 evTag->SetNumOfNegTracks(nNeg);
1431 evTag->SetNumOfNeutrTracks(nNeutr);
1433 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1434 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1435 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1436 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1438 evTag->SetNumOfProtons(nProtons);
1439 evTag->SetNumOfKaons(nKaons);
1440 evTag->SetNumOfPions(nPions);
1441 evTag->SetNumOfMuons(nMuons);
1442 evTag->SetNumOfFWMuons(nFWMuons);
1443 evTag->SetNumOfElectrons(nElectrons);
1444 evTag->SetNumOfPhotons(nGamas);
1445 evTag->SetNumOfPi0s(nPi0s);
1446 evTag->SetNumOfNeutrons(nNeutrons);
1447 evTag->SetNumOfKaon0s(nK0s);
1449 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1450 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1451 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1452 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1453 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1454 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1455 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1456 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1457 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1459 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
1460 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
1462 evTag->SetTotalMomentum(totalP);
1463 evTag->SetMeanPt(meanPt);
1464 evTag->SetMaxPt(maxPt);
1466 tag->SetLHCTag(lhcLuminosity,lhcState);
1467 tag->SetDetectorTag(detectorMask);
1469 tag->SetRunId(iInitRunNumber);
1470 tag->SetRunStartTime(t1->GetDate());
1471 tag->SetRunStopTime(t2->GetDate());
1472 tag->SetBeamEnergy(beamenergy);
1473 tag->SetBeamType(beamtype);
1475 tag->AddEventTag(*evTag);
1488 //_____________________________________________________________________________
1489 void AliESDTagCreator::SwitchOffBranches() const {
1491 // Switch of branches on user request
1492 TObjArray * tokens = fBranches.Tokenize(" ");
1493 Int_t ntok = tokens->GetEntries();
1494 for (Int_t i = 0; i < ntok; i++) {
1495 TString str = ((TObjString*) tokens->At(i))->GetString();
1496 fChain->SetBranchStatus(Form("%s%s%s","*", str.Data(), "*"), 0);
1497 AliInfo(Form("Branch %s switched off \n", str.Data()));