]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliESDTagCreator.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
increasing the number of TRU channels in the maps
[u/mrichter/AliRoot.git] / STEER / AliESDTagCreator.cxx
CommitLineData
08e1a23e 1/**************************************************************************
2 * Author: Panos Christakoglou. *
3 * Contributors are mentioned in the code where appropriate. *
4 * *
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 **************************************************************************/
13
14/* $Id$ */
15
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//-----------------------------------------------------------------
21
22//ROOT
23#include <Riostream.h>
24#include <TFile.h>
25#include <TString.h>
26#include <TTree.h>
27#include <TSystem.h>
28#include <TChain.h>
103d3fba 29#include <TList.h>
30#include <TObjString.h>
08e1a23e 31#include <TLorentzVector.h>
6b6e4472 32#include <TMap.h>
126f4d0c 33#include <TTimeStamp.h>
a69c1246 34#include <TRefArray.h>
08e1a23e 35
36//ROOT-AliEn
37#include <TGrid.h>
38#include <TGridResult.h>
39
40//AliRoot
41#include "AliRunTag.h"
42#include "AliEventTag.h"
43#include "AliESD.h"
44#include "AliESDEvent.h"
45#include "AliESDVertex.h"
46#include "AliLog.h"
44e45fac 47#include "AliGRPObject.h"
08e1a23e 48
49#include "AliESDTagCreator.h"
50
51
52ClassImp(AliESDTagCreator)
53
54
55//______________________________________________________________________________
56 AliESDTagCreator::AliESDTagCreator() :
103d3fba 57 AliTagCreator(),
58 fChain(new TChain("esdTree")), fGUIDList(new TList()),
517aef4e 59 fMD5List(new TList()), fTURLList(new TList()), fBranches(""),
103d3fba 60 meminfo(new MemInfo_t) {
08e1a23e 61 //==============Default constructor for a AliESDTagCreator================
62}
63
64//______________________________________________________________________________
65AliESDTagCreator::~AliESDTagCreator() {
66//================Default destructor for a AliESDTagCreator===================
103d3fba 67 delete fChain;
68 delete fGUIDList;
69 delete fMD5List;
70 delete fTURLList;
71 delete meminfo;
08e1a23e 72}
73
74//______________________________________________________________________________
75Bool_t AliESDTagCreator::ReadGridCollection(TGridResult *fresult) {
76 // Reads the entry of the TGridResult and creates the tags
77 Int_t nEntries = fresult->GetEntries();
78
79 TString alienUrl;
103d3fba 80 const char* guid;
81 const char* md5;
82 const char* turl;
08e1a23e 83 Long64_t size = -1;
84
85 Int_t counter = 0;
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;
103d3fba 94
95 fChain->Add(alienUrl);
96 //fGUIDList->Add(new TObjString(guid));
97 //fMD5List->Add(new TObjString(md5));
98 //fTURLList->Add(new TObjString(turl));
99
100 //TFile *f = TFile::Open(alienUrl,"READ");
101 //CreateTag(f,guid,md5,turl,size,counter);
102 //f->Close();
103 //delete f;
08e1a23e 104 counter += 1;
105 }//grid result loop
103d3fba 106
107 AliInfo(Form("ESD chain created......."));
108 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
2856e38b 109 // Switch of branches on user request
110 SwitchOffBranches();
103d3fba 111 CreateTag(fChain,"grid");
112
08e1a23e 113 return kTRUE;
114}
115
116//______________________________________________________________________________
117Bool_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
120
121 void *dira = gSystem->OpenDirectory(localpath);
122 Char_t fPath[256];
123 const char * dirname = 0x0;
124 const char * filename = 0x0;
125 const char * pattern = "AliESDs.root";
126
127 Int_t counter = 0;
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;
135 fESDFileName += "/";
136 fESDFileName += pattern;
103d3fba 137
138 fChain->Add(fESDFileName);
139
140 //TFile *f = TFile::Open(fESDFileName,"READ");
141 //CreateTag(f,fESDFileName,counter);
142 //f->Close();
143 //delete f;
08e1a23e 144
145 counter += 1;
146 }//pattern check
147 }//child directory's entry loop
148 }//parent directory's entry loop
149
103d3fba 150 AliInfo(Form("ESD chain created......."));
151 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
2856e38b 152 // Switch of branches on user request
153 SwitchOffBranches();
103d3fba 154 CreateTag(fChain,"local");
155
08e1a23e 156 return kTRUE;
157}
158
159//______________________________________________________________________________
160Bool_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.
163
164 // Open the input stream
165 ifstream in;
166 in.open(filename);
167
168 Int_t counter = 0;
169 TString esdfile;
170 // Read the input list of files and add them to the chain
171 while(in.good()) {
172 in >> esdfile;
173 if (!esdfile.Contains("root")) continue; // protection
103d3fba 174
175 fChain->Add(esdfile);
176
177 //TFile *f = TFile::Open(esdfile,"READ");
178 //CreateTag(f,esdfile,counter);
179 //f->Close();
180 //delete f;
08e1a23e 181
182 counter += 1;
183 }
184
103d3fba 185 AliInfo(Form("ESD chain created......."));
186 AliInfo(Form("Chain entries: %d",fChain->GetEntries()));
2856e38b 187 // Switch of branches on user request
188 SwitchOffBranches();
103d3fba 189 CreateTag(fChain,"proof");
190
08e1a23e 191 return kTRUE;
192}
193
103d3fba 194//_____________________________________________________________________________
97721f42 195void AliESDTagCreator::CreateTag(TChain* chain, const char *type) {
103d3fba 196 //private method that creates tag files
197 TString fSession = type;
103d3fba 198 TString fguid, fmd5, fturl;
199 TString fTempGuid = 0;
200
201 /////////////
202 //muon code//
203 ////////////
204 Double_t fMUONMASS = 0.105658369;
205 //Variables
206 Double_t fX,fY,fZ ;
207 Double_t fThetaX, fThetaY, fPyz, fChisquare;
208 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
209 Int_t fCharge;
210 TLorentzVector fEPvector;
211
212 Float_t fZVertexCut = 10.0;
213 Float_t fRhoVertexCut = 2.0;
214
215 Float_t fLowPtCut = 1.0;
216 Float_t fHighPtCut = 3.0;
217 Float_t fVeryHighPtCut = 10.0;
218 ////////////
219
220 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
221
222 // Creates the tags for all the events in a given ESD file
223 Bool_t fIsSim = kTRUE;
224 Int_t ntrack;
ba4804f9 225 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
103d3fba 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, meanPt = .0, totalP = .0;
232 Int_t fVertexflag;
233 Int_t iRunNumber = 0;
234 TString fVertexName;
235
103d3fba 236 //gSystem->GetMemInfo(meminfo);
237 //AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
238 //Int_t tempmem = meminfo->fMemUsed;
239
240 AliInfo(Form("Creating the ESD tags......."));
241
242 Int_t firstEvent = 0,lastEvent = 0;
243 AliESDEvent *esd = new AliESDEvent();
97721f42 244 esd->ReadFromTree(chain);
fcc6b05f 245 AliESD *esdold = 0x0;
103d3fba 246
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;
250
251 Int_t iInitRunNumber = -1;
97721f42 252 chain->GetEntry(0);
253 TFile *f = chain->GetFile();
fcc6b05f 254 fTempGuid = f->GetUUID().AsString();
255
256 TString localFileName = "Run"; localFileName += esd->GetRunNumber();
97721f42 257 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
fcc6b05f 258 localFileName += ".ESD.tag.root";
259
260 TString fileName;
a69c1246 261 TRefArray tmp;
262
fcc6b05f 263 if(fStorage == 0) {
264 fileName = localFileName.Data();
265 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
266 }
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()));
277 }
278
279 TFile* ftag = TFile::Open(fileName, "recreate");
280
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);
286
97721f42 287 for(Int_t iEventNumber = 0; iEventNumber < chain->GetEntries(); iEventNumber++) {
103d3fba 288 ntrack = 0; nPos = 0; nNeg = 0; nNeutr =0;
289 nK0s = 0; nNeutrons = 0; nPi0s = 0;
290 nGamas = 0; nProtons = 0; nKaons = 0;
ba4804f9 291 nPions = 0; nMuons = 0; nElectrons = 0; nFWMuons = 0;
103d3fba 292 nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
293 nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
294 nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
295 maxPt = .0; meanPt = .0; totalP = .0;
296 fVertexflag = 1;
297
97721f42 298 chain->GetEntry(iEventNumber);
fcc6b05f 299 esdold = esd->GetAliESDOld();
300 if(esdold) esd->CopyFromOldESD();
301
97721f42 302 TFile *file = chain->GetFile();
303 const TUrl *url = file->GetEndpointUrl();
304 fguid = file->GetUUID().AsString();
103d3fba 305 if(fSession == "grid") {
306 TString fturltemp = "alien://"; fturltemp += url->GetFile();
307 fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
308 }
309 else fturl = url->GetFile();
310
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!!!");
314
315 const AliESDVertex * vertexIn = esd->GetVertex();
316 fVertexName = vertexIn->GetName();
317 if(fVertexName == "default") fVertexflag = 0;
318
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();
324
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;
329
330 //select only tracks with the "combined PID"
331 if ((status&AliESDtrack::kESDpid)==0) continue;
332 Double_t p[3];
333 esdTrack->GetPxPyPz(p);
60e55aee 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);
103d3fba 337 totalP += momentum;
338 meanPt += fPt;
339 if(fPt > maxPt) maxPt = fPt;
340
341 if(esdTrack->GetSign() > 0) {
342 nPos++;
343 if(fPt > fLowPtCut) nCh1GeV++;
344 if(fPt > fHighPtCut) nCh3GeV++;
345 if(fPt > fVeryHighPtCut) nCh10GeV++;
346 }
347 if(esdTrack->GetSign() < 0) {
348 nNeg++;
349 if(fPt > fLowPtCut) nCh1GeV++;
350 if(fPt > fHighPtCut) nCh3GeV++;
351 if(fPt > fVeryHighPtCut) nCh10GeV++;
352 }
353 if(esdTrack->GetSign() == 0) nNeutr++;
354
355 //PID
356 Double_t prob[5];
357 esdTrack->GetESDpid(prob);
358
359 Double_t rcc = 0.0;
360 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
361 if(rcc == 0.0) continue;
362 //Bayes' formula
363 Double_t w[5];
364 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
365
366 //protons
367 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
368 //kaons
369 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
370 //pions
371 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
372 //electrons
373 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
374 nElectrons++;
375 if(fPt > fLowPtCut) nEl1GeV++;
376 if(fPt > fHighPtCut) nEl3GeV++;
377 if(fPt > fVeryHighPtCut) nEl10GeV++;
378 }
379 ntrack++;
380 }//esd track loop
381
382 /////////////
383 //muon code//
384 ////////////
385 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
386 // loop over all reconstructed tracks (also first track of combination)
387 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
388 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
389 if (muonTrack == 0x0) continue;
390
391 // Coordinates at vertex
392 fZ = muonTrack->GetZ();
393 fY = muonTrack->GetBendingCoor();
394 fX = muonTrack->GetNonBendingCoor();
395
396 fThetaX = muonTrack->GetThetaX();
397 fThetaY = muonTrack->GetThetaY();
398
399 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
400 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
401 fPxRec = fPzRec * TMath::Tan(fThetaX);
402 fPyRec = fPzRec * TMath::Tan(fThetaY);
403 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
404
405 //ChiSquare of the track if needed
406 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
407 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
408 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
409
410 // total number of muons inside a vertex cut
411 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
412 nMuons++;
ba4804f9 413 nFWMuons++;
103d3fba 414 if(fEPvector.Pt() > fLowPtCut) {
415 nMu1GeV++;
416 if(fEPvector.Pt() > fHighPtCut) {
417 nMu3GeV++;
418 if (fEPvector.Pt() > fVeryHighPtCut) {
419 nMu10GeV++;
420 }
421 }
422 }
423 }
424 }//muon track loop
425
426 // Fill the event tags
427 if(ntrack != 0) meanPt = meanPt/ntrack;
428
fcc6b05f 429 //AliInfo(Form("====================================="));
430 //AliInfo(Form("URL: %s - GUID: %s",fturl.Data(),fguid.Data()));
431 //AliInfo(Form("====================================="));
103d3fba 432
7e3c2e04 433 //First physics data
434 const AliMultiplicity *spdMult = esd->GetMultiplicity();
435 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
436 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
437 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
438
4c454ade 439 AliESDVZERO *vzeroData = esd->GetVZEROData();
440 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
441 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
442 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
443 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
444
7e3c2e04 445 //evTag->SetEventId(iEventNumber+1);
446 evTag->SetPeriodNumber(esd->GetPeriodNumber());
447 evTag->SetOrbitNumber(esd->GetOrbitNumber());
448 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
103d3fba 449 evTag->SetGUID(fguid);
450 if(fSession == "grid") {
451 evTag->SetMD5(0);
452 evTag->SetTURL(fturl);
453 evTag->SetSize(0);
454 }
455 else evTag->SetPath(fturl);
456
457 evTag->SetVertexX(vertexIn->GetXv());
458 evTag->SetVertexY(vertexIn->GetYv());
459 evTag->SetVertexZ(vertexIn->GetZv());
460 evTag->SetVertexZError(vertexIn->GetZRes());
461 evTag->SetVertexFlag(fVertexflag);
462
463 evTag->SetT0VertexZ(esd->GetT0zVertex());
464
465 evTag->SetTriggerMask(esd->GetTriggerMask());
466 evTag->SetTriggerCluster(esd->GetTriggerCluster());
467
468 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
469 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
a85132e7 470 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
103d3fba 471 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
472 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
473 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
2b6cdc43 474 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
475 evTag->SetNumOfParticipants2(esd->GetZDCParticipants2());
103d3fba 476
477
478 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
479 evTag->SetNumOfPosTracks(nPos);
480 evTag->SetNumOfNegTracks(nNeg);
481 evTag->SetNumOfNeutrTracks(nNeutr);
482
483 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
484 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
485 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
486 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
487
488 evTag->SetNumOfProtons(nProtons);
489 evTag->SetNumOfKaons(nKaons);
490 evTag->SetNumOfPions(nPions);
491 evTag->SetNumOfMuons(nMuons);
ba4804f9 492 evTag->SetNumOfFWMuons(nFWMuons);
103d3fba 493 evTag->SetNumOfElectrons(nElectrons);
494 evTag->SetNumOfPhotons(nGamas);
495 evTag->SetNumOfPi0s(nPi0s);
496 evTag->SetNumOfNeutrons(nNeutrons);
497 evTag->SetNumOfKaon0s(nK0s);
498
499 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
500 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
501 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
502 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
503 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
504 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
505 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
506 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
507 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
508
a69c1246 509 tmp.Clear();
510 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
511 tmp.Clear();
512 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
103d3fba 513
514 evTag->SetTotalMomentum(totalP);
515 evTag->SetMeanPt(meanPt);
516 evTag->SetMaxPt(maxPt);
517
518 tag->SetRunId(iInitRunNumber);
519 if(fIsSim) tag->SetDataType(0);
520 else tag->SetDataType(1);
103d3fba 521
522 if(fguid != fTempGuid) {
523 fTempGuid = fguid;
524 ttag.Fill();
525 tag->Clear("");
526 }
fcc6b05f 527 tag->AddEventTag(*evTag);
97721f42 528 if(iEventNumber+1 == chain->GetEntries()) {
fcc6b05f 529 //AliInfo(Form("File: %s",fturl.Data()));
530 ttag.Fill();
531 tag->Clear("");
532 }
103d3fba 533 }//event loop
97721f42 534 lastEvent = chain->GetEntries();
103d3fba 535
536 //gSystem->GetMemInfo(meminfo);
537 //AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
538 //tempmem = meminfo->fMemUsed;
539
97721f42 540 //chain->Delete("");
103d3fba 541
542 //gSystem->GetMemInfo(meminfo);
543 //AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
544 //tempmem = meminfo->fMemUsed;
545
103d3fba 546 ftag->cd();
103d3fba 547 tag->Clear();
548 ttag.Write();
549 ftag->Close();
550
551 //gSystem->GetMemInfo(meminfo);
552 //AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
553 //tempmem = meminfo->fMemUsed;
554
103d3fba 555 delete esd;
103d3fba 556 delete tag;
fcc6b05f 557
103d3fba 558 //gSystem->GetMemInfo(meminfo);
559 //AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
560}
561
08e1a23e 562//_____________________________________________________________________________
563void AliESDTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
564 //private method that creates tag files
565 TString fguid = guid;
566 TString fmd5 = md5;
567 TString fturl = turl;
568 /////////////
569 //muon code//
570 ////////////
571 Double_t fMUONMASS = 0.105658369;
572 //Variables
573 Double_t fX,fY,fZ ;
574 Double_t fThetaX, fThetaY, fPyz, fChisquare;
575 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
576 Int_t fCharge;
577 TLorentzVector fEPvector;
578
579 Float_t fZVertexCut = 10.0;
580 Float_t fRhoVertexCut = 2.0;
581
582 Float_t fLowPtCut = 1.0;
583 Float_t fHighPtCut = 3.0;
584 Float_t fVeryHighPtCut = 10.0;
585 ////////////
586
587 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
588
589 // Creates the tags for all the events in a given ESD file
590 Bool_t fIsSim = kTRUE;
591 Int_t ntrack;
ba4804f9 592 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
08e1a23e 593 Int_t nPos, nNeg, nNeutr;
594 Int_t nK0s, nNeutrons, nPi0s, nGamas;
595 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
596 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
597 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
598 Float_t maxPt = .0, meanPt = .0, totalP = .0;
599 Int_t fVertexflag;
600 Int_t iRunNumber = 0;
601 TString fVertexName;
a69c1246 602 TRefArray tmp;
08e1a23e 603
604 AliRunTag *tag = new AliRunTag();
605 AliEventTag *evTag = new AliEventTag();
606 TTree ttag("T","A Tree with event tags");
607 TBranch * btag = ttag.Branch("AliTAG", &tag);
608 btag->SetCompressionLevel(9);
103d3fba 609 gSystem->GetMemInfo(meminfo);
610 AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
611 Int_t tempmem = meminfo->fMemUsed;
08e1a23e 612
a1069ee1 613 AliInfo(Form("Creating the ESD tags......."));
08e1a23e 614
615 Int_t firstEvent = 0,lastEvent = 0;
616 TTree *t = (TTree*) file->Get("esdTree");
617 AliESDEvent *esd = new AliESDEvent();
618 esd->ReadFromTree(t);
619
103d3fba 620 gSystem->GetMemInfo(meminfo);
621 AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
622 tempmem = meminfo->fMemUsed;
623
08e1a23e 624 t->GetEntry(0);
625 Int_t iInitRunNumber = esd->GetRunNumber();
626
627 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
628 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
629 ntrack = 0;
630 nPos = 0;
631 nNeg = 0;
632 nNeutr =0;
633 nK0s = 0;
634 nNeutrons = 0;
635 nPi0s = 0;
636 nGamas = 0;
637 nProtons = 0;
638 nKaons = 0;
639 nPions = 0;
640 nMuons = 0;
ba4804f9 641 nFWMuons = 0;
08e1a23e 642 nElectrons = 0;
643 nCh1GeV = 0;
644 nCh3GeV = 0;
645 nCh10GeV = 0;
646 nMu1GeV = 0;
647 nMu3GeV = 0;
648 nMu10GeV = 0;
649 nEl1GeV = 0;
650 nEl3GeV = 0;
651 nEl10GeV = 0;
652 maxPt = .0;
653 meanPt = .0;
654 totalP = .0;
655 fVertexflag = 1;
656
657 t->GetEntry(iEventNumber);
658 iRunNumber = esd->GetRunNumber();
659 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
660 const AliESDVertex * vertexIn = esd->GetVertex();
661 fVertexName = vertexIn->GetName();
662 if(fVertexName == "default") fVertexflag = 0;
663
664 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
665 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
666 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
667 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
668 UInt_t status = esdTrack->GetStatus();
669
670 //select only tracks with ITS refit
671 if ((status&AliESDtrack::kITSrefit)==0) continue;
672 //select only tracks with TPC refit
673 if ((status&AliESDtrack::kTPCrefit)==0) continue;
674
675 //select only tracks with the "combined PID"
676 if ((status&AliESDtrack::kESDpid)==0) continue;
677 Double_t p[3];
678 esdTrack->GetPxPyPz(p);
60e55aee 679 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
680 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
681 Double_t fPt = TMath::Sqrt(pt2);
08e1a23e 682 totalP += momentum;
683 meanPt += fPt;
684 if(fPt > maxPt) maxPt = fPt;
685
686 if(esdTrack->GetSign() > 0) {
687 nPos++;
688 if(fPt > fLowPtCut) nCh1GeV++;
689 if(fPt > fHighPtCut) nCh3GeV++;
690 if(fPt > fVeryHighPtCut) nCh10GeV++;
691 }
692 if(esdTrack->GetSign() < 0) {
693 nNeg++;
694 if(fPt > fLowPtCut) nCh1GeV++;
695 if(fPt > fHighPtCut) nCh3GeV++;
696 if(fPt > fVeryHighPtCut) nCh10GeV++;
697 }
698 if(esdTrack->GetSign() == 0) nNeutr++;
699
700 //PID
701 Double_t prob[5];
702 esdTrack->GetESDpid(prob);
703
704 Double_t rcc = 0.0;
705 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
706 if(rcc == 0.0) continue;
707 //Bayes' formula
708 Double_t w[5];
709 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
710
711 //protons
712 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
713 //kaons
714 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
715 //pions
716 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
717 //electrons
718 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
719 nElectrons++;
720 if(fPt > fLowPtCut) nEl1GeV++;
721 if(fPt > fHighPtCut) nEl3GeV++;
722 if(fPt > fVeryHighPtCut) nEl10GeV++;
723 }
724 ntrack++;
725 }//esd track loop
726
727 /////////////
728 //muon code//
729 ////////////
730 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
731 // loop over all reconstructed tracks (also first track of combination)
732 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
733 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
734 if (muonTrack == 0x0) continue;
735
736 // Coordinates at vertex
737 fZ = muonTrack->GetZ();
738 fY = muonTrack->GetBendingCoor();
739 fX = muonTrack->GetNonBendingCoor();
740
741 fThetaX = muonTrack->GetThetaX();
742 fThetaY = muonTrack->GetThetaY();
743
744 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
745 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
746 fPxRec = fPzRec * TMath::Tan(fThetaX);
747 fPyRec = fPzRec * TMath::Tan(fThetaY);
748 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
749
750 //ChiSquare of the track if needed
751 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
752 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
753 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
754
755 // total number of muons inside a vertex cut
756 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
757 nMuons++;
ba4804f9 758 nFWMuons++;
08e1a23e 759 if(fEPvector.Pt() > fLowPtCut) {
760 nMu1GeV++;
761 if(fEPvector.Pt() > fHighPtCut) {
762 nMu3GeV++;
763 if (fEPvector.Pt() > fVeryHighPtCut) {
764 nMu10GeV++;
765 }
766 }
767 }
768 }
769 }//muon track loop
770
771 // Fill the event tags
772 if(ntrack != 0) meanPt = meanPt/ntrack;
773
7e3c2e04 774 //First physics data
775 const AliMultiplicity *spdMult = esd->GetMultiplicity();
776 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
777 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
778 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
779
4c454ade 780 AliESDVZERO *vzeroData = esd->GetVZEROData();
781 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
782 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
783 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
784 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
785
7e3c2e04 786 //evTag->SetEventId(iEventNumber+1);
787 evTag->SetPeriodNumber(esd->GetPeriodNumber());
788 evTag->SetOrbitNumber(esd->GetOrbitNumber());
789 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
790
08e1a23e 791 evTag->SetGUID(fguid);
792 evTag->SetMD5(fmd5);
793 evTag->SetTURL(fturl);
794 evTag->SetSize(size);
795 evTag->SetVertexX(vertexIn->GetXv());
796 evTag->SetVertexY(vertexIn->GetYv());
797 evTag->SetVertexZ(vertexIn->GetZv());
798 evTag->SetVertexZError(vertexIn->GetZRes());
799 evTag->SetVertexFlag(fVertexflag);
800
801 evTag->SetT0VertexZ(esd->GetT0zVertex());
802
803 evTag->SetTriggerMask(esd->GetTriggerMask());
804 evTag->SetTriggerCluster(esd->GetTriggerCluster());
805
806 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
807 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
a85132e7 808 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
08e1a23e 809 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
810 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
811 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
812
813
814 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
815 evTag->SetNumOfPosTracks(nPos);
816 evTag->SetNumOfNegTracks(nNeg);
817 evTag->SetNumOfNeutrTracks(nNeutr);
818
819 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
820 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
821 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
822 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
823
824 evTag->SetNumOfProtons(nProtons);
825 evTag->SetNumOfKaons(nKaons);
826 evTag->SetNumOfPions(nPions);
827 evTag->SetNumOfMuons(nMuons);
ba4804f9 828 evTag->SetNumOfFWMuons(nFWMuons);
08e1a23e 829 evTag->SetNumOfElectrons(nElectrons);
830 evTag->SetNumOfPhotons(nGamas);
831 evTag->SetNumOfPi0s(nPi0s);
832 evTag->SetNumOfNeutrons(nNeutrons);
833 evTag->SetNumOfKaon0s(nK0s);
834
835 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
836 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
837 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
838 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
839 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
840 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
841 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
842 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
843 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
844
a69c1246 845 tmp.Clear();
846 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
847 tmp.Clear();
848 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
08e1a23e 849
850 evTag->SetTotalMomentum(totalP);
851 evTag->SetMeanPt(meanPt);
852 evTag->SetMaxPt(maxPt);
853
854 tag->SetRunId(iInitRunNumber);
855 if(fIsSim) tag->SetDataType(0);
856 else tag->SetDataType(1);
857 tag->AddEventTag(*evTag);
858 }//event loop
859 lastEvent = iNumberOfEvents;
860
103d3fba 861 gSystem->GetMemInfo(meminfo);
862 AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
863 tempmem = meminfo->fMemUsed;
08e1a23e 864 t->Delete("");
865
103d3fba 866 gSystem->GetMemInfo(meminfo);
867 AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
868 tempmem = meminfo->fMemUsed;
869
08e1a23e 870 TString localFileName = "Run"; localFileName += tag->GetRunId();
871 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
872 localFileName += ".ESD.tag.root";
873
874 TString fileName;
875
876 if(fStorage == 0) {
877 fileName = localFileName.Data();
878 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
879 }
880 else if(fStorage == 1) {
881 TString alienLocation = "/alien";
882 alienLocation += gGrid->Pwd();
883 alienLocation += fgridpath.Data();
884 alienLocation += "/";
885 alienLocation += localFileName;
886 alienLocation += "?se=";
887 alienLocation += fSE.Data();
888 fileName = alienLocation.Data();
889 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
890 }
891
892 TFile* ftag = TFile::Open(fileName, "recreate");
893 ftag->cd();
7ee67d2a 894 ttag.Fill();
895 tag->Clear();
08e1a23e 896 ttag.Write();
897 ftag->Close();
898
103d3fba 899 gSystem->GetMemInfo(meminfo);
900 AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
901 tempmem = meminfo->fMemUsed;
902
08e1a23e 903 delete ftag;
904 delete esd;
905
906 delete tag;
103d3fba 907 gSystem->GetMemInfo(meminfo);
908 AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
08e1a23e 909}
910
911//_____________________________________________________________________________
912void AliESDTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
913 //private method that creates tag files
914 /////////////
915 //muon code//
916 ////////////
917 Double_t fMUONMASS = 0.105658369;
918 //Variables
919 Double_t fX,fY,fZ ;
920 Double_t fThetaX, fThetaY, fPyz, fChisquare;
921 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
922 Int_t fCharge;
923 TLorentzVector fEPvector;
924
925 Float_t fZVertexCut = 10.0;
926 Float_t fRhoVertexCut = 2.0;
927
928 Float_t fLowPtCut = 1.0;
929 Float_t fHighPtCut = 3.0;
930 Float_t fVeryHighPtCut = 10.0;
931 ////////////
932
933 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
934
935 // Creates the tags for all the events in a given ESD file
936 Bool_t fIsSim = kTRUE;
937 Int_t ntrack;
ba4804f9 938 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
08e1a23e 939 Int_t nPos, nNeg, nNeutr;
940 Int_t nK0s, nNeutrons, nPi0s, nGamas;
941 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
942 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
943 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
944 Float_t maxPt = .0, meanPt = .0, totalP = .0;
945 Int_t fVertexflag;
946 Int_t iRunNumber = 0;
947 TString fVertexName;
a69c1246 948 TRefArray tmp;
08e1a23e 949
950 AliRunTag *tag = new AliRunTag();
951 AliEventTag *evTag = new AliEventTag();
952 TTree ttag("T","A Tree with event tags");
953 TBranch * btag = ttag.Branch("AliTAG", &tag);
954 btag->SetCompressionLevel(9);
955
a1069ee1 956 AliInfo(Form("Creating the ESD tags......."));
08e1a23e 957
958 Int_t firstEvent = 0,lastEvent = 0;
959
960 TTree *t = (TTree*) file->Get("esdTree");
961 AliESDEvent *esd = new AliESDEvent();
962 esd->ReadFromTree(t);
963
964 t->GetEntry(0);
965 Int_t iInitRunNumber = esd->GetRunNumber();
966
967 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
968 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
969 ntrack = 0;
970 nPos = 0;
971 nNeg = 0;
972 nNeutr =0;
973 nK0s = 0;
974 nNeutrons = 0;
975 nPi0s = 0;
976 nGamas = 0;
977 nProtons = 0;
978 nKaons = 0;
979 nPions = 0;
980 nMuons = 0;
ba4804f9 981 nFWMuons = 0;
08e1a23e 982 nElectrons = 0;
983 nCh1GeV = 0;
984 nCh3GeV = 0;
985 nCh10GeV = 0;
986 nMu1GeV = 0;
987 nMu3GeV = 0;
988 nMu10GeV = 0;
989 nEl1GeV = 0;
990 nEl3GeV = 0;
991 nEl10GeV = 0;
992 maxPt = .0;
993 meanPt = .0;
994 totalP = .0;
995 fVertexflag = 1;
996
997 t->GetEntry(iEventNumber);
998 iRunNumber = esd->GetRunNumber();
999 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
1000 const AliESDVertex * vertexIn = esd->GetVertex();
1001 fVertexName = vertexIn->GetName();
1002 if(fVertexName == "default") fVertexflag = 0;
1003
1004 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
1005 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
1006 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
1007 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
1008 UInt_t status = esdTrack->GetStatus();
1009
1010 //select only tracks with ITS refit
1011 if ((status&AliESDtrack::kITSrefit)==0) continue;
1012 //select only tracks with TPC refit
1013 if ((status&AliESDtrack::kTPCrefit)==0) continue;
1014
1015 //select only tracks with the "combined PID"
1016 if ((status&AliESDtrack::kESDpid)==0) continue;
1017 Double_t p[3];
1018 esdTrack->GetPxPyPz(p);
60e55aee 1019 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
1020 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
1021 Double_t fPt = TMath::Sqrt(pt2);
08e1a23e 1022 totalP += momentum;
1023 meanPt += fPt;
1024 if(fPt > maxPt) maxPt = fPt;
1025
1026 if(esdTrack->GetSign() > 0) {
1027 nPos++;
1028 if(fPt > fLowPtCut) nCh1GeV++;
1029 if(fPt > fHighPtCut) nCh3GeV++;
1030 if(fPt > fVeryHighPtCut) nCh10GeV++;
1031 }
1032 if(esdTrack->GetSign() < 0) {
1033 nNeg++;
1034 if(fPt > fLowPtCut) nCh1GeV++;
1035 if(fPt > fHighPtCut) nCh3GeV++;
1036 if(fPt > fVeryHighPtCut) nCh10GeV++;
1037 }
1038 if(esdTrack->GetSign() == 0) nNeutr++;
1039
1040 //PID
1041 Double_t prob[5];
1042 esdTrack->GetESDpid(prob);
1043
1044 Double_t rcc = 0.0;
1045 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1046 if(rcc == 0.0) continue;
1047 //Bayes' formula
1048 Double_t w[5];
1049 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1050
1051 //protons
1052 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1053 //kaons
1054 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1055 //pions
1056 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1057 //electrons
1058 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1059 nElectrons++;
1060 if(fPt > fLowPtCut) nEl1GeV++;
1061 if(fPt > fHighPtCut) nEl3GeV++;
1062 if(fPt > fVeryHighPtCut) nEl10GeV++;
1063 }
1064 ntrack++;
1065 }//esd track loop
1066
1067 /////////////
1068 //muon code//
1069 ////////////
1070 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1071 // loop over all reconstructed tracks (also first track of combination)
1072 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1073 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1074 if (muonTrack == 0x0) continue;
1075
1076 // Coordinates at vertex
1077 fZ = muonTrack->GetZ();
1078 fY = muonTrack->GetBendingCoor();
1079 fX = muonTrack->GetNonBendingCoor();
1080
1081 fThetaX = muonTrack->GetThetaX();
1082 fThetaY = muonTrack->GetThetaY();
1083
1084 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1085 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1086 fPxRec = fPzRec * TMath::Tan(fThetaX);
1087 fPyRec = fPzRec * TMath::Tan(fThetaY);
1088 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1089
1090 //ChiSquare of the track if needed
1091 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1092 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1093 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1094
1095 // total number of muons inside a vertex cut
1096 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1097 nMuons++;
ba4804f9 1098 nFWMuons++;
08e1a23e 1099 if(fEPvector.Pt() > fLowPtCut) {
1100 nMu1GeV++;
1101 if(fEPvector.Pt() > fHighPtCut) {
1102 nMu3GeV++;
1103 if (fEPvector.Pt() > fVeryHighPtCut) {
1104 nMu10GeV++;
1105 }
1106 }
1107 }
1108 }
1109 }//muon track loop
1110
1111 // Fill the event tags
1112 if(ntrack != 0) meanPt = meanPt/ntrack;
1113
7e3c2e04 1114 //First physics data
1115 const AliMultiplicity *spdMult = esd->GetMultiplicity();
1116 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
1117 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
1118 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
1119
4c454ade 1120 AliESDVZERO *vzeroData = esd->GetVZEROData();
1121 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
1122 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
1123 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
1124 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
1125
7e3c2e04 1126 //evTag->SetEventId(iEventNumber+1);
1127 evTag->SetPeriodNumber(esd->GetPeriodNumber());
1128 evTag->SetOrbitNumber(esd->GetOrbitNumber());
1129 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
08e1a23e 1130 evTag->SetPath(filepath);
1131
1132 evTag->SetVertexX(vertexIn->GetXv());
1133 evTag->SetVertexY(vertexIn->GetYv());
1134 evTag->SetVertexZ(vertexIn->GetZv());
1135 evTag->SetVertexZError(vertexIn->GetZRes());
1136 evTag->SetVertexFlag(fVertexflag);
1137
1138 evTag->SetT0VertexZ(esd->GetT0zVertex());
1139
1140 evTag->SetTriggerMask(esd->GetTriggerMask());
1141 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1142
1143 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1144 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
a85132e7 1145 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
08e1a23e 1146 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
1147 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
1148 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1149
1150
1151 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1152 evTag->SetNumOfPosTracks(nPos);
1153 evTag->SetNumOfNegTracks(nNeg);
1154 evTag->SetNumOfNeutrTracks(nNeutr);
1155
1156 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1157 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1158 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1159 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1160
1161 evTag->SetNumOfProtons(nProtons);
1162 evTag->SetNumOfKaons(nKaons);
1163 evTag->SetNumOfPions(nPions);
1164 evTag->SetNumOfMuons(nMuons);
ba4804f9 1165 evTag->SetNumOfFWMuons(nFWMuons);
08e1a23e 1166 evTag->SetNumOfElectrons(nElectrons);
1167 evTag->SetNumOfPhotons(nGamas);
1168 evTag->SetNumOfPi0s(nPi0s);
1169 evTag->SetNumOfNeutrons(nNeutrons);
1170 evTag->SetNumOfKaon0s(nK0s);
1171
1172 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1173 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1174 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1175 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1176 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1177 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1178 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1179 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1180 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1181
a69c1246 1182 tmp.Clear();
1183 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
1184 tmp.Clear();
1185 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
08e1a23e 1186
1187 evTag->SetTotalMomentum(totalP);
1188 evTag->SetMeanPt(meanPt);
1189 evTag->SetMaxPt(maxPt);
1190
1191 tag->SetRunId(iInitRunNumber);
1192 if(fIsSim) tag->SetDataType(0);
1193 else tag->SetDataType(1);
1194 tag->AddEventTag(*evTag);
1195 }//event loop
1196 lastEvent = iNumberOfEvents;
1197
1198 t->Delete("");
1199
08e1a23e 1200 TString localFileName = "Run"; localFileName += tag->GetRunId();
1201 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
1202 localFileName += ".ESD.tag.root";
1203
1204 TString fileName;
1205
1206 if(fStorage == 0) {
1207 fileName = localFileName.Data();
1208 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
1209 }
1210 else if(fStorage == 1) {
1211 TString alienLocation = "/alien";
1212 alienLocation += gGrid->Pwd();
1213 alienLocation += fgridpath.Data();
1214 alienLocation += "/";
1215 alienLocation += localFileName;
1216 alienLocation += "?se=";
1217 alienLocation += fSE.Data();
1218 fileName = alienLocation.Data();
1219 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
1220 }
1221
1222 TFile* ftag = TFile::Open(fileName, "recreate");
1223 ftag->cd();
7ee67d2a 1224 ttag.Fill();
1225 tag->Clear();
08e1a23e 1226 ttag.Write();
1227 ftag->Close();
1228
1229 delete ftag;
1230 delete esd;
1231
1232 delete tag;
1233}
1234
1235//_____________________________________________________________________________
27293674 1236void AliESDTagCreator::CreateESDTags(Int_t fFirstEvent, Int_t fLastEvent, AliGRPObject *grpData, ULong_t * qa, Bool_t * es, Int_t qalength, Int_t eslength) {
08e1a23e 1237 //GRP
1238 Float_t lhcLuminosity = 0.0;
1239 TString lhcState = "test";
44e45fac 1240 //UInt_t detectorMask = 0;
1241 Int_t detectorMask = 0;
08e1a23e 1242
44e45fac 1243 detectorMask = grpData->GetDetectorMask();
1244 time_t startTime = grpData->GetTimeStart();
126f4d0c 1245 TTimeStamp *t1 = new TTimeStamp(startTime);
44e45fac 1246 time_t endTime = grpData->GetTimeEnd();
1247 TTimeStamp *t2 = new TTimeStamp(endTime);
1248 const char* beamtype = grpData->GetBeamType();
1249 Float_t beamenergy = grpData->GetBeamEnergy();
126f4d0c 1250
1251
08e1a23e 1252 /////////////
1253 //muon code//
1254 ////////////
1255 Double_t fMUONMASS = 0.105658369;
1256 //Variables
1257 Double_t fX,fY,fZ ;
1258 Double_t fThetaX, fThetaY, fPyz, fChisquare;
1259 Double_t fPxRec,fPyRec, fPzRec, fEnergy;
1260 Int_t fCharge;
1261 TLorentzVector fEPvector;
1262
1263 Float_t fZVertexCut = 10.0;
1264 Float_t fRhoVertexCut = 2.0;
1265
1266 Float_t fLowPtCut = 1.0;
1267 Float_t fHighPtCut = 3.0;
1268 Float_t fVeryHighPtCut = 10.0;
1269 ////////////
1270
1271 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
1272
1273 // Creates the tags for all the events in a given ESD file
1274 Int_t ntrack;
ba4804f9 1275 Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons;
08e1a23e 1276 Int_t nPos, nNeg, nNeutr;
1277 Int_t nK0s, nNeutrons, nPi0s, nGamas;
1278 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
1279 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
1280 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
1281 Float_t maxPt = .0, meanPt = .0, totalP = .0;
1282 Int_t fVertexflag;
1283 Int_t iRunNumber = 0;
1284 TString fVertexName("default");
a69c1246 1285 TRefArray tmp;
08e1a23e 1286
a1069ee1 1287 AliInfo(Form("Creating the ESD tags......."));
08e1a23e 1288
1289 TFile *file = TFile::Open("AliESDs.root");
1290 if (!file || !file->IsOpen()) {
1291 AliError(Form("opening failed"));
1292 delete file;
1293 return ;
1294 }
1295 Int_t lastEvent = 0;
1296 TTree *b = (TTree*) file->Get("esdTree");
1297 AliESDEvent *esd = new AliESDEvent();
1298 esd->ReadFromTree(b);
1299
1300 b->GetEntry(fFirstEvent);
1301 Int_t iInitRunNumber = esd->GetRunNumber();
1302
1303 Int_t iNumberOfEvents = (Int_t)b->GetEntries();
fcc6b05f 1304 if(fLastEvent == -1) lastEvent = (Int_t)b->GetEntries();
1305 else lastEvent = fLastEvent;
1306
1307 char fileName[256];
1308 sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root",
517aef4e 1309 iInitRunNumber,fFirstEvent,lastEvent);
fcc6b05f 1310 AliInfo(Form("writing tags to file %s", fileName));
1311 AliDebug(1, Form("writing tags to file %s", fileName));
1312
1313 TFile* ftag = TFile::Open(fileName, "recreate");
1314
517aef4e 1315 AliRunTag *tag = new AliRunTag();
1316 AliEventTag *evTag = new AliEventTag();
1317 TTree ttag("T","A Tree with event tags");
1318 TBranch * btag = ttag.Branch("AliTAG", &tag);
1319 btag->SetCompressionLevel(9);
1320
08e1a23e 1321 if(fLastEvent != -1) iNumberOfEvents = fLastEvent + 1;
1322 for (Int_t iEventNumber = fFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) {
1323 ntrack = 0;
1324 nPos = 0;
1325 nNeg = 0;
1326 nNeutr =0;
1327 nK0s = 0;
1328 nNeutrons = 0;
1329 nPi0s = 0;
1330 nGamas = 0;
1331 nProtons = 0;
1332 nKaons = 0;
1333 nPions = 0;
1334 nMuons = 0;
ba4804f9 1335 nFWMuons = 0;
08e1a23e 1336 nElectrons = 0;
1337 nCh1GeV = 0;
1338 nCh3GeV = 0;
1339 nCh10GeV = 0;
1340 nMu1GeV = 0;
1341 nMu3GeV = 0;
1342 nMu10GeV = 0;
1343 nEl1GeV = 0;
1344 nEl3GeV = 0;
1345 nEl10GeV = 0;
1346 maxPt = .0;
1347 meanPt = .0;
1348 totalP = .0;
1349 fVertexflag = 0;
1350
1351 b->GetEntry(iEventNumber);
1352 iRunNumber = esd->GetRunNumber();
1353 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
1354 const AliESDVertex * vertexIn = esd->GetVertex();
1355 if (!vertexIn) AliError("ESD has not defined vertex.");
1356 if (vertexIn) fVertexName = vertexIn->GetName();
1357 if(fVertexName != "default") fVertexflag = 1;
1358 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
1359 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
1360 UInt_t status = esdTrack->GetStatus();
1361
1362 //select only tracks with ITS refit
1363 if ((status&AliESDtrack::kITSrefit)==0) continue;
1364 //select only tracks with TPC refit
1365 if ((status&AliESDtrack::kTPCrefit)==0) continue;
1366
1367 //select only tracks with the "combined PID"
1368 if ((status&AliESDtrack::kESDpid)==0) continue;
1369 Double_t p[3];
1370 esdTrack->GetPxPyPz(p);
60e55aee 1371 Double_t pt2 = p[0]*p[0]+p[1]*p[1];
1372 Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
1373 Double_t fPt = TMath::Sqrt(pt2);
08e1a23e 1374 totalP += momentum;
1375 meanPt += fPt;
1376 if(fPt > maxPt) maxPt = fPt;
1377
1378 if(esdTrack->GetSign() > 0) {
1379 nPos++;
1380 if(fPt > fLowPtCut) nCh1GeV++;
1381 if(fPt > fHighPtCut) nCh3GeV++;
1382 if(fPt > fVeryHighPtCut) nCh10GeV++;
1383 }
1384 if(esdTrack->GetSign() < 0) {
1385 nNeg++;
1386 if(fPt > fLowPtCut) nCh1GeV++;
1387 if(fPt > fHighPtCut) nCh3GeV++;
1388 if(fPt > fVeryHighPtCut) nCh10GeV++;
1389 }
1390 if(esdTrack->GetSign() == 0) nNeutr++;
1391
1392 //PID
1393 Double_t prob[5];
1394 esdTrack->GetESDpid(prob);
1395
1396 Double_t rcc = 0.0;
1397 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1398 if(rcc == 0.0) continue;
1399 //Bayes' formula
1400 Double_t w[5];
1401 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1402
1403 //protons
1404 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1405 //kaons
1406 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1407 //pions
1408 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1409 //electrons
1410 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1411 nElectrons++;
1412 if(fPt > fLowPtCut) nEl1GeV++;
1413 if(fPt > fHighPtCut) nEl3GeV++;
1414 if(fPt > fVeryHighPtCut) nEl10GeV++;
1415 }
1416 ntrack++;
1417 }//track loop
1418
1419 /////////////
1420 //muon code//
1421 ////////////
1422 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1423 // loop over all reconstructed tracks (also first track of combination)
1424 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1425 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1426 if (muonTrack == 0x0) continue;
1427
1428 // Coordinates at vertex
1429 fZ = muonTrack->GetZ();
1430 fY = muonTrack->GetBendingCoor();
1431 fX = muonTrack->GetNonBendingCoor();
1432
1433 fThetaX = muonTrack->GetThetaX();
1434 fThetaY = muonTrack->GetThetaY();
1435
1436 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1437 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1438 fPxRec = fPzRec * TMath::Tan(fThetaX);
1439 fPyRec = fPzRec * TMath::Tan(fThetaY);
1440 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1441
1442 //ChiSquare of the track if needed
1443 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1444 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1445 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1446
1447 // total number of muons inside a vertex cut
1448 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1449 nMuons++;
ba4804f9 1450 nFWMuons++;
08e1a23e 1451 if(fEPvector.Pt() > fLowPtCut) {
1452 nMu1GeV++;
1453 if(fEPvector.Pt() > fHighPtCut) {
1454 nMu3GeV++;
1455 if (fEPvector.Pt() > fVeryHighPtCut) {
1456 nMu10GeV++;
1457 }
1458 }
1459 }
1460 }
1461 }//muon track loop
7e3c2e04 1462
08e1a23e 1463
1464 // Fill the event tags
1465 if(ntrack != 0)
1466 meanPt = meanPt/ntrack;
7e3c2e04 1467
1468 //First physics data
1469 const AliMultiplicity *spdMult = esd->GetMultiplicity();
1470 evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
1471 evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
1472 evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
1473
4c454ade 1474 AliESDVZERO *vzeroData = esd->GetVZEROData();
1475 evTag->SetMTotV0A(vzeroData->GetMTotV0A());
1476 evTag->SetMTotV0C(vzeroData->GetMTotV0C());
1477 evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
1478 evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
1479
7e3c2e04 1480 //evTag->SetEventId(iEventNumber+1);
1481 evTag->SetPeriodNumber(esd->GetPeriodNumber());
1482 evTag->SetOrbitNumber(esd->GetOrbitNumber());
1483 evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
08e1a23e 1484 if (vertexIn) {
1485 evTag->SetVertexX(vertexIn->GetXv());
1486 evTag->SetVertexY(vertexIn->GetYv());
1487 evTag->SetVertexZ(vertexIn->GetZv());
1488 evTag->SetVertexZError(vertexIn->GetZRes());
1489 }
1490 evTag->SetVertexFlag(fVertexflag);
1491
1492 evTag->SetT0VertexZ(esd->GetT0zVertex());
1493
1494 evTag->SetTriggerMask(esd->GetTriggerMask());
1495 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1496
1497 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1498 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1499 evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
1500 evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
a85132e7 1501 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
08e1a23e 1502 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1503
1504
1505 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1506 evTag->SetNumOfPosTracks(nPos);
1507 evTag->SetNumOfNegTracks(nNeg);
1508 evTag->SetNumOfNeutrTracks(nNeutr);
1509
1510 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1511 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1512 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1513 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1514
1515 evTag->SetNumOfProtons(nProtons);
1516 evTag->SetNumOfKaons(nKaons);
1517 evTag->SetNumOfPions(nPions);
1518 evTag->SetNumOfMuons(nMuons);
ba4804f9 1519 evTag->SetNumOfFWMuons(nFWMuons);
08e1a23e 1520 evTag->SetNumOfElectrons(nElectrons);
1521 evTag->SetNumOfPhotons(nGamas);
1522 evTag->SetNumOfPi0s(nPi0s);
1523 evTag->SetNumOfNeutrons(nNeutrons);
1524 evTag->SetNumOfKaon0s(nK0s);
1525
1526 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1527 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1528 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1529 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1530 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1531 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1532 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1533 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1534 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1535
a69c1246 1536 tmp.Clear();
1537 evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
1538 tmp.Clear();
1539 evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
08e1a23e 1540
1541 evTag->SetTotalMomentum(totalP);
1542 evTag->SetMeanPt(meanPt);
1543 evTag->SetMaxPt(maxPt);
1544
1545 tag->SetLHCTag(lhcLuminosity,lhcState);
1546 tag->SetDetectorTag(detectorMask);
1547
1548 tag->SetRunId(iInitRunNumber);
126f4d0c 1549 tag->SetRunStartTime(t1->GetDate());
1550 tag->SetRunStopTime(t2->GetDate());
1551 tag->SetBeamEnergy(beamenergy);
1552 tag->SetBeamType(beamtype);
27293674 1553
1554 //QA setting
1555 tag->SetQA(qa, qalength) ;
1556 tag->SetEventSpecies(es, eslength) ;
126f4d0c 1557
08e1a23e 1558 tag->AddEventTag(*evTag);
1559 }
08e1a23e 1560
08e1a23e 1561 ftag->cd();
7ee67d2a 1562 ttag.Fill();
1563 tag->Clear();
08e1a23e 1564 ttag.Write();
1565 ftag->Close();
1566 file->cd();
1567 delete tag;
1568 delete evTag;
1569}
1570
517aef4e 1571//_____________________________________________________________________________
1572void AliESDTagCreator::SwitchOffBranches() const {
2856e38b 1573 //
1574 // Switch of branches on user request
517aef4e 1575 TObjArray * tokens = fBranches.Tokenize(" ");
1576 Int_t ntok = tokens->GetEntries();
1577 for (Int_t i = 0; i < ntok; i++) {
1578 TString str = ((TObjString*) tokens->At(i))->GetString();
1579 fChain->SetBranchStatus(Form("%s%s%s","*", str.Data(), "*"), 0);
1580 AliInfo(Form("Branch %s switched off \n", str.Data()));
1581 }
2856e38b 1582}