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