Event server (Mihai)
[u/mrichter/AliRoot.git] / STEER / STEER / AliESDTagCreator.cxx
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>
29 #include <TList.h>
30 #include <TObjString.h>
31 #include <TLorentzVector.h>
32 #include <TMap.h>
33 #include <TTimeStamp.h>
34 #include <TRefArray.h>
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"
47 #include "AliGRPObject.h"
48
49 #include "AliESDTagCreator.h"
50
51 using std::ifstream;
52 ClassImp(AliESDTagCreator)
53
54
55 //______________________________________________________________________________
56   AliESDTagCreator::AliESDTagCreator() :
57     AliTagCreator(),
58     fChain(new TChain("esdTree")), fGUIDList(new TList()), 
59     fMD5List(new TList()), fTURLList(new TList()), fBranches(""), 
60     meminfo(new MemInfo_t) {
61   //==============Default constructor for a AliESDTagCreator================
62 }
63
64 //______________________________________________________________________________
65 AliESDTagCreator::~AliESDTagCreator() {
66 //================Default destructor for a AliESDTagCreator===================
67   delete fChain;
68   delete fGUIDList;
69   delete fMD5List;
70   delete fTURLList;
71   delete meminfo;
72 }
73
74 //______________________________________________________________________________
75 Bool_t AliESDTagCreator::ReadGridCollection(TGridResult *fresult) {
76   // Reads the entry of the TGridResult and creates the tags
77   Int_t nEntries = fresult->GetEntries();
78
79   TString alienUrl;
80 //   const char* guid;
81 //   const char* md5;
82 //   const char* turl;
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;
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;  
104     counter += 1;
105   }//grid result loop
106   
107   if (fChain->GetEntries() > 0) {
108     AliInfo(Form("ESD chain created......."));  
109     AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));  
110   } else {
111     AliWarning(Form("No ESD files found !"));
112     return kFALSE;
113   }
114     
115   // Switch of branches on user request
116   SwitchOffBranches();
117   CreateTag(fChain,"grid");
118   
119   return kTRUE;
120 }
121
122 //______________________________________________________________________________
123 Bool_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[512];
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     snprintf(fPath, 512,"%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;
143
144         fChain->Add(fESDFileName);
145
146         //TFile *f = TFile::Open(fESDFileName,"READ");
147         //CreateTag(f,fESDFileName,counter);
148         //f->Close();
149         //delete f;      
150         
151         counter += 1;
152       }//pattern check
153     }//child directory's entry loop
154   }//parent directory's entry loop
155
156   AliInfo(Form("ESD chain created......."));    
157   AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));    
158   // Switch of branches on user request
159   SwitchOffBranches();
160   CreateTag(fChain,"local");
161
162   return kTRUE;
163 }
164
165 //______________________________________________________________________________
166 Bool_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
180
181     fChain->Add(esdfile);
182   
183     //TFile *f = TFile::Open(esdfile,"READ");
184     //CreateTag(f,esdfile,counter);
185     //f->Close();
186     //delete f;  
187     
188     counter += 1;
189   }
190
191   AliInfo(Form("ESD chain created......."));    
192   AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));    
193   // Switch of branches on user request
194   SwitchOffBranches();
195   CreateTag(fChain,"proof");
196
197   return kTRUE;
198 }
199
200 //_____________________________________________________________________________
201 void AliESDTagCreator::CreateTag(TChain* chain, const char *type) {
202   //private method that creates tag files
203   TString fSession = type;
204   TString fguid, fmd5, fturl, foldguid;
205   TString fTempGuid;
206
207   Int_t iRunNumber = 0;
208   //gSystem->GetMemInfo(meminfo);
209   //AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
210   //Int_t tempmem = meminfo->fMemUsed;
211   
212   AliInfo(Form("Creating the ESD tags......."));        
213   
214   Int_t firstEvent = 0,lastEvent = 0;
215   AliESDEvent *esd = new AliESDEvent();
216   esd->ReadFromTree(chain);
217   //  AliESD *esdold = 0x0;
218   
219   //gSystem->GetMemInfo(meminfo);
220   //AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
221   //tempmem = meminfo->fMemUsed;
222   
223   Int_t iInitRunNumber = -1;
224   chain->GetEntry(0);
225   TFile *f = chain->GetFile();
226   fTempGuid = f->GetUUID().AsString();
227
228   TString localFileName = "Run"; localFileName += esd->GetRunNumber(); 
229   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
230   localFileName += ".ESD.tag.root";
231
232   TString fileName;
233  
234   if(fStorage == 0) {
235     fileName = localFileName.Data();      
236     AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
237   }
238   else if(fStorage == 1) {
239     TString alienLocation = "/alien";
240     alienLocation += gGrid->Pwd();
241     alienLocation += fgridpath.Data();
242     alienLocation += "/";
243     alienLocation +=  localFileName;
244     alienLocation += "?se=";
245     alienLocation += fSE.Data();
246     fileName = alienLocation.Data();
247     AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
248   }
249
250   TFile* ftag = TFile::Open(fileName, "recreate");
251
252   AliRunTag *tag = new AliRunTag();
253   AliEventTag *evTag = new AliEventTag();
254   TTree * ttag = new TTree("T","A Tree with event tags");
255   TBranch * btag = ttag->Branch("AliTAG", &tag);
256   btag->SetCompressionLevel(9);
257   // Run related information
258   tag->SetMagneticField(esd->GetMagneticField());
259   tag->SetBeamEnergy(esd->GetBeamEnergy());
260   tag->SetBeamType(TString(esd->GetBeamType()));
261   tag->SetActiveTriggerClasses(esd->GetESDRun()->GetActiveTriggerClasses());
262   
263   foldguid = "";
264
265   for(Int_t iEventNumber = 0; iEventNumber < chain->GetEntries(); iEventNumber++) {
266     FillEventTag(chain, evTag, iEventNumber, esd);
267
268     if(iEventNumber == 0) iInitRunNumber = esd->GetRunNumber();
269     iRunNumber = esd->GetRunNumber();
270     if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD - You are trying to merge different runs!!!");
271
272     TFile *file = chain->GetFile();
273     //    const TUrl *url = file->GetEndpointUrl();
274     fguid = file->GetUUID().AsString();
275
276     if (foldguid == fguid) {
277       tag->AddEventTag(*evTag);
278     }
279     else {
280       AliFileTag *nftag = new AliFileTag();
281       nftag->SetGUID(fguid);
282
283 //       if(fSession == "grid") {
284 //      TString fturltemp = "alien://"; fturltemp += url->GetFile();
285 //      fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
286 //       }
287 //       else fturl = url->GetFile();
288       fturl = file->GetName();
289
290       if(fSession == "grid") {
291         nftag->SetMD5("");
292         nftag->SetTURL(fturl);
293         nftag->SetSize(0);
294       }
295       else {
296         nftag->SetPath(fturl);
297         nftag->SetSize(0);
298         nftag->SetMD5("");
299         nftag->SetTURL(fturl);
300       }
301       foldguid = fguid;
302       
303       if (tag->GetFileId(fguid) > -1)
304         AliFatal("Adding a file which is already in the RunTag.");
305
306       tag->AddFileTag(nftag);
307     }
308
309     tag->SetRunId(iInitRunNumber);
310 //     if(fIsSim) tag->SetDataType(0);
311 //     else tag->SetDataType(1);
312
313 //     if(fguid != fTempGuid) {
314 //       fTempGuid = fguid;
315 //       ttag->Fill();
316 //       tag->Clear("");
317 //     }
318     if(iEventNumber+1 == chain->GetEntries()) {
319       //AliInfo(Form("File: %s",fturl.Data()));
320
321       ttag->Fill();
322       tag->Clear("");
323     }      
324   }//event loop
325   lastEvent = chain->GetEntries();
326   
327   //gSystem->GetMemInfo(meminfo);
328   //AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
329   //tempmem = meminfo->fMemUsed;
330
331   //chain->Delete("");
332   
333   //gSystem->GetMemInfo(meminfo);
334   //AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
335   //tempmem = meminfo->fMemUsed;
336
337   ftag->cd();
338   tag->Clear();
339   ttag->Write();
340   ftag->Close();
341
342   //gSystem->GetMemInfo(meminfo);
343   //AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
344   //tempmem = meminfo->fMemUsed;
345
346   delete esd;
347   delete tag;
348
349   //gSystem->GetMemInfo(meminfo);
350   //AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
351 }
352
353 //_____________________________________________________________________________
354 void AliESDTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
355   //private method that creates tag files
356   TString fguid = guid;
357   TString fmd5 = md5;
358   TString fturl = turl;
359   /////////////
360   //muon code//
361   ////////////
362     //  Double_t fMUONMASS = 0.105658369;
363   //Variables
364 //   Double_t fX,fY,fZ ;
365 //   Double_t fThetaX, fThetaY, fPyz, fChisquare;
366 //   Double_t fPxRec, fPyRec, fPzRec, fEnergy;
367 //   Int_t fCharge;
368 //   TLorentzVector fEPvector;
369
370 //   Float_t fLowPtCut = 1.0;
371 //   Float_t fHighPtCut = 3.0;
372 //   Float_t fVeryHighPtCut = 10.0;
373   ////////////
374
375 //   Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
376
377   // Creates the tags for all the events in a given ESD file
378   Bool_t fIsSim = kTRUE;
379 //   Int_t ntrack;
380 //   Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons, nFWMatchedMuons;
381 //   Int_t nPos, nNeg, nNeutr;
382 //   Int_t nK0s, nNeutrons, nPi0s, nGamas;
383 //   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
384 //   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
385 //   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
386 //   Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
387 //   Int_t fVertexflag;
388   Int_t iRunNumber = 0;
389 //   TString fVertexName;
390 //   TRefArray tmp;
391
392   AliRunTag *tag = new AliRunTag();
393   AliEventTag *evTag = new AliEventTag();
394   TTree * ttag = new TTree("T","A Tree with event tags");
395   TBranch * btag = ttag->Branch("AliTAG", &tag);
396   btag->SetCompressionLevel(9);
397   gSystem->GetMemInfo(meminfo);
398   AliInfo(Form("After the tag initialization - Memory used: %d MB",meminfo->fMemUsed));
399   Int_t tempmem = meminfo->fMemUsed;
400   
401   AliInfo(Form("Creating the ESD tags......."));        
402   
403   Int_t firstEvent = 0,lastEvent = 0;
404   TTree *t = (TTree*) file->Get("esdTree");
405   AliESDEvent *esd = new AliESDEvent();
406   esd->ReadFromTree(t);
407   
408   gSystem->GetMemInfo(meminfo);
409   AliInfo(Form("After the esd initialization - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
410   tempmem = meminfo->fMemUsed;
411
412   t->GetEntry(0);
413   Int_t iInitRunNumber = esd->GetRunNumber();
414   tag->SetMagneticField(esd->GetMagneticField());
415   tag->SetBeamEnergy(esd->GetBeamEnergy());
416   tag->SetBeamType(TString(esd->GetBeamType()));
417   tag->SetActiveTriggerClasses(esd->GetESDRun()->GetActiveTriggerClasses());
418
419   AliFileTag *eftag = new AliFileTag();
420   eftag->SetMD5(md5);
421   eftag->SetTURL(fturl);
422   eftag->SetSize(size);
423   tag->AddFileTag(eftag);
424
425   Int_t iNumberOfEvents = (Int_t)t->GetEntries();
426   for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
427     FillEventTag(t, evTag, iEventNumber, esd);
428     iRunNumber = esd->GetRunNumber();
429     if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
430     
431     tag->SetRunId(iInitRunNumber);
432     if(fIsSim) tag->SetDataType(0);
433     else tag->SetDataType(1);
434     tag->AddEventTag(*evTag);
435   }//event loop
436   lastEvent = iNumberOfEvents;
437   
438   gSystem->GetMemInfo(meminfo);
439   AliInfo(Form("After the event and track loop - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
440   tempmem = meminfo->fMemUsed;
441   t->Delete("");
442   
443   gSystem->GetMemInfo(meminfo);
444   AliInfo(Form("After the t->Delete - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
445   tempmem = meminfo->fMemUsed;
446
447   TString localFileName = "Run"; localFileName += tag->GetRunId(); 
448   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
449   localFileName += ".ESD.tag.root";
450
451   TString fileName;
452   
453   if(fStorage == 0) {
454     fileName = localFileName.Data();      
455     AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
456   }
457   else if(fStorage == 1) {
458     TString alienLocation = "/alien";
459     alienLocation += gGrid->Pwd();
460     alienLocation += fgridpath.Data();
461     alienLocation += "/";
462     alienLocation +=  localFileName;
463     alienLocation += "?se=";
464     alienLocation += fSE.Data();
465     fileName = alienLocation.Data();
466     AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
467   }
468
469   TFile* ftag = TFile::Open(fileName, "recreate");
470   ftag->cd();
471   ttag->Fill();
472   tag->Clear();
473   ttag->Write();
474   ftag->Close();
475
476   gSystem->GetMemInfo(meminfo);
477   AliInfo(Form("After the file closing - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
478   tempmem = meminfo->fMemUsed;
479
480   delete ftag;
481   delete esd;
482
483   delete tag;
484   gSystem->GetMemInfo(meminfo);
485   AliInfo(Form("After the delete objects - Memory used: %d MB - Increase: %d MB",meminfo->fMemUsed,meminfo->fMemUsed - tempmem));
486 }
487
488 //_____________________________________________________________________________
489 void AliESDTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
490   //private method that creates tag files
491   /////////////
492   //muon code//
493   ////////////
494   //  Double_t fMUONMASS = 0.105658369;
495   //Variables
496 //   Double_t fX,fY,fZ ;
497 //   Double_t fThetaX, fThetaY, fPyz, fChisquare;
498 //   Double_t fPxRec, fPyRec, fPzRec, fEnergy;
499 //   Int_t fCharge;
500 //   TLorentzVector fEPvector;
501
502 //   Float_t fLowPtCut = 1.0;
503 //   Float_t fHighPtCut = 3.0;
504 //   Float_t fVeryHighPtCut = 10.0;
505   ////////////
506
507 //   Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
508
509   // Creates the tags for all the events in a given ESD file
510 //   Bool_t fIsSim = kTRUE;
511 //   Int_t ntrack;
512 //   Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons, nFWMatchedMuons;
513 //   Int_t nPos, nNeg, nNeutr;
514 //   Int_t nK0s, nNeutrons, nPi0s, nGamas;
515 //   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
516 //   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
517 //   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
518 //   Float_t maxPt = .0, etamaxPt = -999, phimaxPt = -999., meanPt = .0, totalP = .0;
519 //   Int_t fVertexflag;
520   Int_t iRunNumber = 0;
521 //   TString fVertexName;
522 //   TRefArray tmp;
523
524   AliRunTag *tag = new AliRunTag();
525   AliEventTag *evTag = new AliEventTag();
526   TTree * ttag = new TTree("T","A Tree with event tags");
527   TBranch * btag = ttag->Branch("AliTAG", &tag);
528   btag->SetCompressionLevel(9);
529   
530   AliInfo(Form("Creating the ESD tags......."));        
531   
532   Int_t firstEvent = 0,lastEvent = 0;
533   
534   TTree *t = (TTree*) file->Get("esdTree");
535   AliESDEvent *esd = new AliESDEvent();
536   esd->ReadFromTree(t);
537   
538   t->GetEntry(0);
539   Int_t iInitRunNumber = esd->GetRunNumber();
540   tag->SetMagneticField(esd->GetMagneticField());
541   tag->SetBeamEnergy(esd->GetBeamEnergy());
542   tag->SetBeamType(TString(esd->GetBeamType()));
543   tag->SetActiveTriggerClasses(esd->GetESDRun()->GetActiveTriggerClasses());
544
545   AliFileTag *eftag = new AliFileTag();
546   eftag->SetPath(filepath);
547   eftag->SetTURL(Form("local://%s", filepath));
548   eftag->SetSize(0);
549   eftag->SetMD5("");
550   tag->AddFileTag(eftag);
551
552   Int_t iNumberOfEvents = (Int_t)t->GetEntries();
553   for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
554     FillEventTag(t, evTag, iEventNumber, esd);
555     iRunNumber = esd->GetRunNumber();
556     if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
557     //    evTag->SetPath(filepath);
558     
559     tag->SetRunId(iInitRunNumber);
560 //     if(fIsSim) tag->SetDataType(0);
561 //     else tag->SetDataType(1);
562     tag->AddEventTag(*evTag);
563   }//event loop
564   lastEvent = iNumberOfEvents;
565   
566   t->Delete("");
567   
568   TString localFileName = "Run"; localFileName += tag->GetRunId(); 
569   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
570   localFileName += ".ESD.tag.root";
571
572   TString fileName;
573   
574   if(fStorage == 0) {
575     fileName = localFileName.Data();      
576     AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
577   }
578   else if(fStorage == 1) {
579     TString alienLocation = "/alien";
580     alienLocation += gGrid->Pwd();
581     alienLocation += fgridpath.Data();
582     alienLocation += "/";
583     alienLocation +=  localFileName;
584     alienLocation += "?se=";
585     alienLocation += fSE.Data();
586     fileName = alienLocation.Data();
587     AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
588   }
589
590   TFile* ftag = TFile::Open(fileName, "recreate");
591   ftag->cd();
592   ttag->Fill();
593   tag->Clear();
594   ttag->Write();
595   ftag->Close();
596
597   delete ftag;
598   delete esd;
599
600   delete tag;
601 }
602
603 //_____________________________________________________________________________
604 void AliESDTagCreator::CreateESDTags(Int_t fFirstEvent, Int_t fLastEvent, AliGRPObject *grpData, ULong_t * qa, Bool_t * es, Int_t qalength, Int_t eslength) {
605   //GRP
606   Float_t lhcLuminosity = 0.0;
607   TString lhcState = "test";
608   //UInt_t detectorMask = 0;
609   Int_t detectorMask = 0;
610
611   detectorMask = grpData->GetDetectorMask();
612   time_t startTime = grpData->GetTimeStart();
613   TTimeStamp t1(startTime);
614   time_t endTime = grpData->GetTimeEnd();
615   TTimeStamp t2(endTime);
616   const char* beamtype = grpData->GetBeamType();
617   Float_t beamenergy = grpData->GetBeamEnergy();
618
619
620   /////////////
621   //muon code//
622   ////////////
623 //   Double_t fMUONMASS = 0.105658369;
624   //Variables
625 //   Double_t fX,fY,fZ ;
626 //   Double_t fThetaX, fThetaY, fPyz, fChisquare;
627 //   Double_t fPxRec,fPyRec, fPzRec, fEnergy;
628 //   Int_t fCharge;
629 //   TLorentzVector fEPvector;
630
631 //   Float_t fLowPtCut = 1.0;
632 //   Float_t fHighPtCut = 3.0;
633 //   Float_t fVeryHighPtCut = 10.0;
634   ////////////
635
636 //   Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
637
638   // Creates the tags for all the events in a given ESD file
639 //   Int_t ntrack;
640 //   Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons, nFWMatchedMuons;
641 //   Int_t nPos, nNeg, nNeutr;
642 //   Int_t nK0s, nNeutrons, nPi0s, nGamas;
643 //   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
644 //   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
645 //   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
646 //   Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
647 //   Int_t fVertexflag;
648   Int_t iRunNumber = 0;
649   TString fguid, fmd5, fturl;
650 //   TString fVertexName("default");
651 //   TRefArray tmp;
652   
653   AliInfo(Form("Creating the ESD tags......."));        
654
655   TFile *esdfile = TFile::Open("AliESDs.root");
656   if (!esdfile || !esdfile->IsOpen()) {
657     AliError(Form("opening failed"));
658     delete esdfile;
659     return ;
660   }  
661   Int_t lastEvent = 0;
662   TTree *b = (TTree*) esdfile->Get("esdTree");
663   AliESDEvent *esd = new AliESDEvent();
664   esd->ReadFromTree(b);
665
666   b->GetEntry(0);
667   Int_t iInitRunNumber = esd->GetRunNumber();
668   
669   Int_t iNumberOfEvents = (Int_t)b->GetEntries();
670   if ((fLastEvent == -1) || ((Int_t) b->GetEntries() < fLastEvent))
671     lastEvent = fFirstEvent  + (Int_t)b->GetEntries() - 1;
672   else lastEvent = fLastEvent;
673
674   char fileName[256];
675   snprintf(fileName, 256, "Run%d.Event%d_%d.ESD.tag.root", 
676           iInitRunNumber,fFirstEvent,lastEvent);
677   AliInfo(Form("writing tags to file %s", fileName));
678   AliDebug(1, Form("writing tags to file %s", fileName));
679  
680   TFile* ftag = TFile::Open(fileName, "recreate");
681   
682   AliRunTag *tag = new AliRunTag();
683   AliEventTag *evTag = new AliEventTag();
684   TTree * ttag = new TTree("T","A Tree with event tags");
685   TBranch * btag = ttag->Branch("AliTAG", &tag);
686   btag->SetCompressionLevel(9);
687
688   if ((fLastEvent != -1) && ((Int_t) b->GetEntries() > fLastEvent)) 
689     iNumberOfEvents = fLastEvent + 1;
690
691   AliFileTag *eftag = new AliFileTag();
692   tag->AddFileTag(eftag);
693
694   for (Int_t iEventNumber = fFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) {
695     FillEventTag(b, evTag, iEventNumber, esd);
696     iRunNumber = esd->GetRunNumber();
697     if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
698
699     if (iEventNumber == fFirstEvent) {
700       TFile *file = b->GetCurrentFile();
701 //      const TUrl *url = file->GetEndpointUrl();
702       fguid = file->GetUUID().AsString();
703
704 //       if(fStorage == 1) {
705 //      TString fturltemp = "alien://"; fturltemp += url->GetFile();
706 //      fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
707 //       }
708 //       else fturl = url->GetFile(); 
709       fturl = file->GetName();
710       
711       //    evTag->SetGUID(fguid);
712       ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetGUID(fguid);
713       if(fStorage == 1) {
714         ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetMD5("");
715         ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetTURL(fturl);
716         ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetSize(0);
717       }
718       else {
719         //      evTag->SetPath(fturl);
720         ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetPath(fturl);
721         ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetMD5("");
722         ((AliFileTag *) tag->GetFileTag(tag->GetNFiles()-1))->SetSize(0);
723       }
724
725     }
726
727     tag->AddEventTag(*evTag);
728   }    
729   
730   tag->SetLHCTag(lhcLuminosity,lhcState);
731   tag->SetDetectorTag(esd->GetESDRun()->GetDetectorsInDAQ(), esd->GetESDRun()->GetDetectorsInReco());
732   tag->SetActiveTriggerClasses(esd->GetESDRun()->GetActiveTriggerClasses());
733
734   // Get magnetic field info
735   Bool_t ok = kTRUE;
736   
737   Float_t l3Current = grpData->GetL3Current((AliGRPObject::Stats)0);
738   if (l3Current == AliGRPObject::GetInvalidFloat()) {
739     AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
740     ok = kFALSE;
741   }
742   
743   Char_t l3Polarity = grpData->GetL3Polarity();
744   if (l3Polarity == AliGRPObject::GetInvalidChar()) {
745     AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
746     ok = kFALSE;
747   }
748   
749   // Dipole
750   Float_t diCurrent = grpData->GetDipoleCurrent((AliGRPObject::Stats)0);
751   if (diCurrent == AliGRPObject::GetInvalidFloat()) {
752     AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
753     ok = kFALSE;
754   }
755   
756   Char_t diPolarity = grpData->GetDipolePolarity();
757   if (diPolarity == AliGRPObject::GetInvalidChar()) {
758     AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
759     ok = kFALSE;
760   }
761   
762   if (ok && grpData->IsPolarityConventionLHC()) {
763     if ((TMath::Abs(l3Current) > 29000.0) && (l3Polarity == 1))
764       tag->SetMagneticField(-0.5);
765     if ((TMath::Abs(l3Current) > 29000.0) && (l3Polarity == 0)) 
766       tag->SetMagneticField(0.5);
767     if (TMath::Abs(l3Current) < 2000.0) 
768       tag->SetMagneticField(0.0);
769     
770     if ((TMath::Abs(diCurrent) > 5900.0) && (diPolarity == 1))
771       tag->SetDipoleField(-0.2);
772     if ((TMath::Abs(diCurrent) > 5900.0) && (diPolarity == 0))
773       tag->SetDipoleField(0.2);
774     if (TMath::Abs(diCurrent) < 500.0)
775       tag->SetDipoleField(0.0);
776   }
777   
778   tag->SetRunId(iInitRunNumber);
779   tag->SetRunStartTime(t1.GetDate());
780   tag->SetRunStopTime(t2.GetDate());
781   tag->SetBeamEnergy(beamenergy);
782   tag->SetBeamType(beamtype);
783   
784   //QA setting 
785   tag->SetQAArray(qa, qalength) ; 
786   tag->SetEventSpecies(es, eslength) ;
787
788   ftag->cd();
789   ttag->Fill();
790   tag->Clear();
791   ttag->Write();
792   ftag->Close();
793   esdfile->cd();
794   delete esdfile;
795   delete ftag;
796   delete esd;
797   delete tag;
798   delete evTag;
799 }
800
801 void AliESDTagCreator::CreateESDTagsFullRun(TTree *chain, AliGRPObject *grpData, ULong_t * qa, Bool_t * es, Int_t qalength, Int_t eslength)
802 {
803   //GRP
804   Float_t lhcLuminosity = 0.0;
805   TString lhcState = "test";
806   //UInt_t detectorMask = 0;
807   Int_t detectorMask = 0;
808
809   detectorMask = grpData->GetDetectorMask();
810   time_t startTime = grpData->GetTimeStart();
811   TTimeStamp t1(startTime);
812   time_t endTime = grpData->GetTimeEnd();
813   TTimeStamp t2(endTime);
814   const char* beamtype = grpData->GetBeamType();
815   Float_t beamenergy = grpData->GetBeamEnergy();
816
817   Int_t iRunNumber = 0;
818   TString fguid, fmd5, fturl;
819   TString fturlold;
820
821   AliInfo(Form("Creating the ESD tags......."));        
822
823   AliESDEvent *esd = new AliESDEvent();
824   esd->ReadFromTree(chain);
825
826   chain->GetEntry(0);
827   Int_t iInitRunNumber = esd->GetRunNumber();
828   
829   Int_t iNumberOfEvents = (Int_t)chain->GetEntries();
830   Int_t iFirstEvent = 0;
831
832   char fileName[256];
833   snprintf(fileName, 256, "Run%d.Event%d_%d.ESD.tag.root", 
834           iInitRunNumber,iFirstEvent,iNumberOfEvents);
835   AliInfo(Form("writing tags to file %s", fileName));
836   AliDebug(1, Form("writing tags to file %s", fileName));
837  
838   TFile* ftag = TFile::Open(fileName, "recreate");
839  
840   AliRunTag *tag = new AliRunTag();
841   AliEventTag *evTag = new AliEventTag();
842   TTree * ttag = new TTree("T","A Tree with event tags");
843   TBranch * btag = ttag->Branch("AliTAG", &tag);
844   btag->SetCompressionLevel(9);
845
846 //   AliFileTag *eftag = new AliFileTag();
847 //   tag->AddFileTag(*eftag);
848
849   for (Int_t iEventNumber = iFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) {
850     FillEventTag(chain, evTag, iEventNumber, esd);
851
852     iRunNumber = esd->GetRunNumber();
853     if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
854     
855     TFile *file = chain->GetCurrentFile();
856     //    const TUrl *url = file->GetName();
857     fguid = file->GetUUID().AsString();
858     fturl = file->GetName();
859 //     if(fStorage == 1) {
860 //       TString fturltemp = "alien://"; fturltemp += url->GetFile();
861 //       fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
862 //     }
863 //     else fturl = url->GetFile();
864
865     if (fturl.CompareTo(fturlold)) {
866
867       AliFileTag *eftag = new AliFileTag();
868       
869       //evTag->SetGUID(fguid);
870       eftag->SetGUID(fguid);
871       if(fStorage == 1) {
872         //       evTag->SetMD5("");
873         //       evTag->SetTURL(fturl);
874         //       evTag->SetSize(0);
875         eftag->SetPath("");
876         eftag->SetMD5("");
877         eftag->SetTURL(fturl);
878         eftag->SetSize(0);
879       }
880       else {
881         //       evTag->SetPath(fturl);
882         //       evTag->SetTURL(fturl);
883         eftag->SetPath(fturl);
884         eftag->SetTURL(fturl);
885         eftag->SetMD5("");
886         eftag->SetSize(0);
887       }
888
889       tag->AddFileTag(eftag);
890     
891       fturlold = fturl;
892       
893     }
894     else {
895       //      cout << "FileTag found " << fturl.Data() << " " << fturlold.Data() << endl;
896     }
897
898     tag->AddEventTag(*evTag);
899   }
900
901   tag->SetLHCTag(lhcLuminosity,lhcState);
902   tag->SetDetectorTag(esd->GetESDRun()->GetDetectorsInDAQ(), esd->GetESDRun()->GetDetectorsInReco());
903   tag->SetActiveTriggerClasses(esd->GetESDRun()->GetActiveTriggerClasses());
904   
905   // Get magnetic field info
906   Bool_t ok = kTRUE;
907   
908   Float_t l3Current = grpData->GetL3Current((AliGRPObject::Stats)0);
909   if (l3Current == AliGRPObject::GetInvalidFloat()) {
910     AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
911     ok = kFALSE;
912   }
913   
914   Char_t l3Polarity = grpData->GetL3Polarity();
915   if (l3Polarity == AliGRPObject::GetInvalidChar()) {
916     AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
917     ok = kFALSE;
918   }
919   
920   // Dipole
921   Float_t diCurrent = grpData->GetDipoleCurrent((AliGRPObject::Stats)0);
922   if (diCurrent == AliGRPObject::GetInvalidFloat()) {
923     AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
924     ok = kFALSE;
925   }
926   
927   Char_t diPolarity = grpData->GetDipolePolarity();
928   if (diPolarity == AliGRPObject::GetInvalidChar()) {
929     AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
930     ok = kFALSE;
931   }
932   
933   if (ok && grpData->IsPolarityConventionLHC()) {
934     if ((TMath::Abs(l3Current) > 29000.0) && (l3Polarity == 1))
935       tag->SetMagneticField(-0.5);
936     if ((TMath::Abs(l3Current) > 29000.0) && (l3Polarity == 0)) 
937       tag->SetMagneticField(0.5);
938     if (TMath::Abs(l3Current) < 2000.0) 
939       tag->SetMagneticField(0.0);
940     
941     if ((TMath::Abs(diCurrent) > 5900.0) && (diPolarity == 1))
942       tag->SetDipoleField(-0.2);
943     if ((TMath::Abs(diCurrent) > 5900.0) && (diPolarity == 0))
944       tag->SetDipoleField(0.2);
945     if (TMath::Abs(diCurrent) < 500.0)
946       tag->SetDipoleField(0.0);
947   }
948   
949   tag->SetRunId(iInitRunNumber);
950   tag->SetRunStartTime(t1.GetDate());
951   tag->SetRunStopTime(t2.GetDate());
952   tag->SetBeamEnergy(beamenergy);
953   tag->SetBeamType(beamtype);
954   
955   //QA setting 
956   tag->SetQAArray(qa, qalength) ; 
957   tag->SetEventSpecies(es, eslength) ;
958
959   ftag->cd();
960   ttag->Fill();
961   tag->Clear();
962   ttag->Write();
963   ftag->Close();
964   delete ftag;
965   delete esd;
966   delete tag;
967   delete evTag;
968 }
969
970 //_____________________________________________________________________________
971 void AliESDTagCreator::SwitchOffBranches() const {
972   //
973   // Switch of branches on user request
974   TObjArray * tokens = fBranches.Tokenize(" ");
975   Int_t ntok = tokens->GetEntries();
976   for (Int_t i = 0; i < ntok; i++)  {
977     TString str = ((TObjString*) tokens->At(i))->GetString();
978     fChain->SetBranchStatus(Form("%s%s%s","*", str.Data(), "*"), 0);
979     AliInfo(Form("Branch %s switched off \n", str.Data()));
980   }
981   delete tokens;
982 }
983
984 //_____________________________________________________________________________
985 void AliESDTagCreator::FillEventTag(TTree *chain, AliEventTag *evTag, Int_t iEventNumber, AliESDEvent *esd)
986 {
987   // Fill the event specific information in the EventTag
988   AliESD *esdold = 0x0;
989
990   TString fTempGuid;
991
992   /////////////
993   //muon code//
994   ////////////
995   Double_t fMUONMASS = 0.105658369;
996   //Variables
997   Double_t fX,fY,fZ ;
998   Double_t fThetaX, fThetaY, fPyz, fChisquare;
999   Double_t fPxRec, fPyRec, fPzRec, fEnergy;
1000   Int_t fCharge;
1001   TLorentzVector fEPvector;
1002
1003   Float_t fLowPtCut      =  1.0;
1004   Float_t fHighPtCut     =  3.0;
1005   Float_t fVeryHighPtCut = 10.0;
1006   ////////////
1007
1008   Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
1009
1010   // Creates the tags for all the events in a given ESD file
1011   Bool_t fIsSim = kTRUE;
1012   Int_t ntrack;
1013   Int_t nProtons, nKaons, nPions, nMuons, nElectrons, nFWMuons, nFWMatchedMuons;
1014   Int_t nPos, nNeg, nNeutr;
1015   Int_t nK0s, nLambdas, nNeutrons, nPi0s, nGamas;
1016   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
1017   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
1018   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
1019   Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
1020   Int_t fVertexflag;
1021   TString fVertexName;
1022
1023   TRefArray tmp;
1024   
1025   ntrack = 0; nPos = 0; nNeg = 0; nNeutr =0;
1026   nK0s = 0; nLambdas = 0; nNeutrons = 0; nPi0s = 0;
1027   nGamas = 0; nProtons = 0; nKaons = 0;
1028   nPions = 0; nMuons = 0; nElectrons = 0; nFWMuons = 0; nFWMatchedMuons = 0;      
1029   nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
1030   nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
1031   nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
1032   maxPt = .0; etamaxPt = -999.; phimaxPt = -999.; meanPt = .0; totalP = .0;
1033   fVertexflag = 1;
1034   
1035   chain->GetEntry(iEventNumber);    
1036   esdold = esd->GetAliESDOld();
1037   if(esdold) esd->CopyFromOldESD();
1038   
1039 //   TFile *file = chain->GetFile();
1040 //   const TUrl *url = file->GetEndpointUrl();
1041 //   fguid = file->GetUUID().AsString();
1042 //   if(fSession == "grid") {
1043 //     TString fturltemp = "alien://"; fturltemp += url->GetFile();
1044 //     fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
1045 //   }
1046 //   else fturl = url->GetFile();
1047   
1048   const AliESDVertex * vertexIn = esd->GetVertex();
1049   fVertexName = vertexIn->GetName();
1050   if(fVertexName == "default") fVertexflag = 0;
1051   
1052   for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
1053     AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
1054     if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
1055     else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
1056     UInt_t status = esdTrack->GetStatus();
1057     
1058     //select only tracks with ITS refit
1059     if ((status&AliESDtrack::kITSrefit)==0) continue;
1060     //select only tracks with TPC refit
1061     if ((status&AliESDtrack::kTPCrefit)==0) continue;
1062     
1063     //select only tracks with the "combined PID"
1064     if ((status&AliESDtrack::kESDpid)==0) continue;
1065     Double_t p[3];
1066     esdTrack->GetPxPyPz(p);
1067     Double_t pt2 = p[0]*p[0]+p[1]*p[1];
1068     Double_t momentum = TMath::Sqrt(pt2+p[2]*p[2]);
1069     Double_t fPt = TMath::Sqrt(pt2);
1070     totalP += momentum;
1071     meanPt += fPt;
1072     if(fPt > maxPt) {
1073       maxPt = fPt;
1074       phimaxPt = esdTrack->Phi();
1075       etamaxPt = esdTrack->Eta();
1076     }
1077     
1078     if(esdTrack->GetSign() > 0) {
1079       nPos++;
1080       if(fPt > fLowPtCut) nCh1GeV++;
1081       if(fPt > fHighPtCut) nCh3GeV++;
1082       if(fPt > fVeryHighPtCut) nCh10GeV++;
1083     }
1084     if(esdTrack->GetSign() < 0) {
1085       nNeg++;
1086       if(fPt > fLowPtCut) nCh1GeV++;
1087       if(fPt > fHighPtCut) nCh3GeV++;
1088       if(fPt > fVeryHighPtCut) nCh10GeV++;
1089     }
1090     if(esdTrack->GetSign() == 0) nNeutr++;
1091     
1092     //PID
1093     Double_t prob[5];
1094     esdTrack->GetESDpid(prob);
1095     
1096     Double_t rcc = 0.0;
1097     for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1098     if(rcc == 0.0) continue;
1099     //Bayes' formula
1100     Double_t w[5];
1101     for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1102     
1103     //protons
1104     if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1105     //kaons
1106     if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1107     //pions
1108     if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++; 
1109     //electrons
1110     if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1111       nElectrons++;
1112       if(fPt > fLowPtCut) nEl1GeV++;
1113       if(fPt > fHighPtCut) nEl3GeV++;
1114       if(fPt > fVeryHighPtCut) nEl10GeV++;
1115     }     
1116     ntrack++;
1117   }
1118   //esd track loop
1119   
1120   /* muon code */
1121   Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1122   // loop over all reconstructed tracks (also first track of combination)
1123   for (Int_t iTrack = 0; iTrack <  nMuonTracks;  iTrack++) {
1124     AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1125     if (muonTrack == 0x0) continue;
1126     
1127     // Coordinates at vertex
1128     fZ = muonTrack->GetZ(); 
1129     fY = muonTrack->GetBendingCoor();
1130     fX = muonTrack->GetNonBendingCoor(); 
1131     
1132     fThetaX = muonTrack->GetThetaX();
1133     fThetaY = muonTrack->GetThetaY();
1134     
1135     fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1136     fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1137     fPxRec = fPzRec * TMath::Tan(fThetaX);
1138     fPyRec = fPzRec * TMath::Tan(fThetaY);
1139     fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1140     
1141     //ChiSquare of the track if needed
1142     fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1143     fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1144     fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1145     
1146     if (muonTrack->GetMatchTrigger()>0) nFWMatchedMuons++;
1147     
1148     nMuons++;
1149     nFWMuons++;
1150     if(fEPvector.Pt() > fLowPtCut) {
1151       nMu1GeV++; 
1152       if(fEPvector.Pt() > fHighPtCut) {
1153         nMu3GeV++; 
1154         if (fEPvector.Pt() > fVeryHighPtCut) {
1155           nMu10GeV++;
1156         }
1157       }
1158     }
1159   }//muon track loop
1160   
1161   // Fill the event tags 
1162   if(ntrack != 0) meanPt = meanPt/ntrack;
1163   
1164   //AliInfo(Form("====================================="));
1165   //AliInfo(Form("URL: %s - GUID: %s",fturl.Data(),fguid.Data()));
1166   //AliInfo(Form("====================================="));
1167   
1168   //First physics data
1169   const AliMultiplicity *spdMult = esd->GetMultiplicity();
1170   evTag->SetNumberOfFiredChipsLayer1(spdMult->GetNumberOfFiredChips(0));
1171   evTag->SetNumberOfFiredChipsLayer2(spdMult->GetNumberOfFiredChips(1));
1172   evTag->SetNumberOfSPDTracklets(spdMult->GetNumberOfTracklets());
1173   
1174   AliESDVZERO *vzeroData = esd->GetVZEROData();
1175   evTag->SetMTotV0A(vzeroData->GetMTotV0A());
1176   evTag->SetMTotV0C(vzeroData->GetMTotV0C());
1177   evTag->SetNbPMV0A(vzeroData->GetNbPMV0A());
1178   evTag->SetNbPMV0C(vzeroData->GetNbPMV0C());
1179   
1180   //evTag->SetEventId(iEventNumber+1);
1181   evTag->SetPeriodNumber(esd->GetPeriodNumber());
1182   evTag->SetOrbitNumber(esd->GetOrbitNumber());
1183   evTag->SetBunchCrossNumber(esd->GetBunchCrossNumber());
1184   //  evTag->SetGUID(fguid);
1185 //   if(fSession == "grid") {
1186 //     evTag->SetMD5("");
1187 //     evTag->SetTURL(fturl);
1188 //     evTag->SetSize(0);
1189 //   }
1190 //   else evTag->SetPath(fturl);
1191   
1192   evTag->SetVertexX(vertexIn->GetXv());
1193   evTag->SetVertexY(vertexIn->GetYv());
1194   evTag->SetVertexZ(vertexIn->GetZv());
1195   evTag->SetVertexZError(vertexIn->GetZRes());
1196   evTag->SetVertexFlag(fVertexflag);
1197   
1198   evTag->SetT0VertexZ(esd->GetT0zVertex());
1199   
1200   evTag->SetTriggerMask(esd->GetTriggerMask());
1201   evTag->SetTriggerCluster(esd->GetTriggerCluster());
1202   
1203   evTag->SetEventType(esd->GetEventType());
1204   //*T*  evTag->SetFiredTriggerClasses(esd->GetFiredTriggerClasses());
1205   
1206   evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1207   evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1208   evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
1209   evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
1210   evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
1211   evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1212   
1213   evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1214   evTag->SetNumOfPosTracks(nPos);
1215   evTag->SetNumOfNegTracks(nNeg);
1216   evTag->SetNumOfNeutrTracks(nNeutr);
1217   
1218   evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1219   evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1220   evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1221   evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1222   
1223   evTag->SetNumOfProtons(nProtons);
1224   evTag->SetNumOfKaons(nKaons);
1225   evTag->SetNumOfPions(nPions);
1226   evTag->SetNumOfMuons(nMuons);
1227   evTag->SetNumOfFWMuons(nFWMuons);
1228   evTag->SetNumOfFWMatchedMuons(nFWMatchedMuons);
1229   evTag->SetNumOfElectrons(nElectrons);
1230   evTag->SetNumOfPhotons(nGamas);
1231   evTag->SetNumOfPi0s(nPi0s);
1232   evTag->SetNumOfNeutrons(nNeutrons);
1233   evTag->SetNumOfKaon0s(nK0s);
1234   evTag->SetNumOfLambdas(nLambdas);
1235   
1236   evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1237   evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1238   evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1239   evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1240   evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1241   evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1242   evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1243   evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1244   evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1245
1246   tmp.Clear();
1247   evTag->SetNumOfPHOSClusters(esd->GetPHOSClusters(&tmp));
1248   tmp.Clear();
1249   evTag->SetNumOfEMCALClusters(esd->GetEMCALClusters(&tmp));
1250     
1251   evTag->SetTotalMomentum(totalP);
1252   evTag->SetMeanPt(meanPt);
1253   evTag->SetMaxPt(maxPt);
1254   evTag->SetEtaMaxPt(etamaxPt);
1255   evTag->SetPhiMaxPt(phimaxPt);
1256
1257   evTag->SetPhysicsFlag(kTRUE);
1258   evTag->SetBackgroungFlag(kFALSE);
1259 }
1260
1261 void AliESDTagCreator::CreateESDRunTagSummary(TTree *chain)
1262 {
1263   // Merge all tags from a run into a single RunTag
1264   // with only the File tags
1265   AliRunTag *rtag;
1266   chain->SetBranchAddress("AliTAG", &rtag);
1267
1268   TFile* ftag = TFile::Open("RunTagSummary.tag.root", "recreate");
1269
1270   AliRunTag *tag = new AliRunTag();
1271   TTree * ttag = new TTree("T","A Tree with event tags");
1272   TBranch * btag = ttag->Branch("AliTAG", &tag);
1273   btag->SetCompressionLevel(9);
1274   
1275   for (int itag=0; itag<chain->GetEntries(); itag++) {
1276     chain->GetEntry(itag);
1277     tag->CopyStandardContent(rtag);
1278     
1279     ttag->Fill();
1280     tag->Clear();
1281   }
1282
1283   ftag->cd();
1284   ttag->Write();
1285   ftag->Close();
1286   
1287 }