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