4e619bb6d4a35a3f3bcaa95bc16b8a5d5ed3ed94
[u/mrichter/AliRoot.git] / STEER / AliAODTagCreator.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 //           AliAODTagCreator 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 <TLorentzVector.h>
30
31 //ROOT-AliEn
32 #include <TGrid.h>
33 #include <TGridResult.h>
34
35 //AliRoot
36 #include "AliRunTag.h"
37 #include "AliEventTag.h"
38 #include "AliPID.h"
39 #include "AliAODEvent.h"
40 #include "AliAODVertex.h"
41 #include "AliLog.h"
42
43 #include "AliAODTagCreator.h"
44
45
46 ClassImp(AliAODTagCreator)
47
48
49 //______________________________________________________________________________
50   AliAODTagCreator::AliAODTagCreator() :
51     AliTagCreator(), fChain(new TChain("aodTree")) {
52   //==============Default constructor for a AliAODTagCreator================
53 }
54
55 //______________________________________________________________________________
56 AliAODTagCreator::~AliAODTagCreator() {
57 //================Default destructor for a AliAODTagCreator===================
58   delete fChain;
59 }
60
61 //______________________________________________________________________________
62 Bool_t AliAODTagCreator::ReadGridCollection(TGridResult *fresult) {
63   // Reads the entry of the TGridResult and creates the tags
64   Int_t nEntries = fresult->GetEntries();
65
66   TString alienUrl;
67   const char* guid;
68   const char* md5;
69   const char* turl;
70   Long64_t size = -1;
71
72   Int_t counter = 0;
73   for(Int_t i = 0; i < nEntries; i++) {
74     alienUrl = fresult->GetKey(i,"turl");
75     guid = fresult->GetKey(i,"guid");
76     if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
77     md5 = fresult->GetKey(i,"md5");
78     turl = fresult->GetKey(i,"turl");
79     if(md5 && !strlen(guid)) md5 = 0;
80     if(guid && !strlen(guid)) guid = 0;
81     
82     fChain->Add(alienUrl);
83     //fGUIDList->Add(new TObjString(guid));
84     //fMD5List->Add(new TObjString(md5));
85     //fTURLList->Add(new TObjString(turl));
86     
87     //TFile *f = TFile::Open(alienUrl,"READ");
88     //CreateTag(f,guid,md5,turl,size,counter);
89     //f->Close();
90     //delete f;  
91     counter += 1;
92   }//grid result loop
93   
94   AliInfo(Form("AOD chain created......."));    
95   AliInfo(Form("Chain entries: %d",fChain->GetEntries()));      
96   CreateTag(fChain,"grid");
97   
98   return kTRUE;
99 }
100
101 //______________________________________________________________________________
102 /*Bool_t AliAODTagCreator::ReadGridCollection(TGridResult *fresult) {
103   // Reads the entry of the TGridResult and creates the tags
104   Int_t nEntries = fresult->GetEntries();
105
106   TString alienUrl;
107   const char *guid;
108   const char *md5;
109   const char *turl;
110   Long64_t size = -1;
111
112   Int_t counter = 0;
113   for(Int_t i = 0; i < nEntries; i++) {
114     alienUrl = fresult->GetKey(i,"turl");
115     guid = fresult->GetKey(i,"guid");
116     if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
117     md5 = fresult->GetKey(i,"md5");
118     turl = fresult->GetKey(i,"turl");
119     if(md5 && !strlen(guid)) md5 = 0;
120     if(guid && !strlen(guid)) guid = 0;
121
122     TFile *f = TFile::Open(alienUrl,"READ");
123     CreateTag(f,guid,md5,turl,size,counter);
124     f->Close();
125     delete f;    
126     counter += 1;
127   }//grid result loop
128
129   return kTRUE;
130   }*/
131
132 //______________________________________________________________________________
133 Bool_t AliAODTagCreator::ReadLocalCollection(const char *localpath) {
134   // Checks the different subdirs of the given local path and in the
135   // case where it finds an AliESDs.root file it creates the tags
136   
137   void *dira =  gSystem->OpenDirectory(localpath);
138   Char_t fPath[256];
139   const char * dirname = 0x0;
140   const char * filename = 0x0;
141   const char * pattern = "AliAODs.root"; 
142
143   Int_t counter = 0;
144   while((dirname = gSystem->GetDirEntry(dira))) {
145     sprintf(fPath,"%s/%s",localpath,dirname);
146     void *dirb =  gSystem->OpenDirectory(fPath);
147     while((filename = gSystem->GetDirEntry(dirb))) {
148       if(strstr(filename,pattern)) {
149         TString fESDFileName;
150         fESDFileName = fPath;
151         fESDFileName += "/";
152         fESDFileName += pattern;
153
154         fChain->Add(fESDFileName);
155
156         //TFile *f = TFile::Open(fESDFileName,"READ");
157         //CreateTag(f,fESDFileName,counter);
158         //f->Close();
159         //delete f;      
160         
161         counter += 1;
162       }//pattern check
163     }//child directory's entry loop
164   }//parent directory's entry loop
165
166   AliInfo(Form("AOD chain created......."));    
167   AliInfo(Form("Chain entries: %d",fChain->GetEntries()));      
168   CreateTag(fChain,"local");
169
170   return kTRUE;
171 }
172
173 //______________________________________________________________________________
174 /*Bool_t AliAODTagCreator::ReadLocalCollection(const char *localpath) {
175   // Checks the different subdirs of the given local path and in the
176   // case where it finds an AliAODs.root file it creates the tags
177   
178   void *dira =  gSystem->OpenDirectory(localpath);
179   Char_t fPath[256];
180   const char * dirname = 0x0;
181   const char * filename = 0x0;
182   const char * pattern = "AliAOD.root"; 
183
184   Int_t counter = 0;
185   while((dirname = gSystem->GetDirEntry(dira))) {
186     sprintf(fPath,"%s/%s",localpath,dirname);
187     void *dirb =  gSystem->OpenDirectory(fPath);
188     while((filename = gSystem->GetDirEntry(dirb))) {
189       if(strstr(filename,pattern)) {
190         TString fAODFileName;
191         fAODFileName = fPath;
192         fAODFileName += "/";
193         fAODFileName += pattern;
194         TFile *f = TFile::Open(fAODFileName,"READ");
195         CreateTag(f,fAODFileName,counter);
196         f->Close();
197         delete f;        
198         
199         counter += 1;
200       }//pattern check
201     }//child directory's entry loop
202   }//parent directory's entry loop
203
204   return kTRUE;
205   }*/
206
207
208 //______________________________________________________________________________
209 Bool_t AliAODTagCreator::ReadCAFCollection(const char *filename) {
210   // Temporary solution for CAF: Takes as an input the ascii file that
211   // lists the ESDs stored in the SE of the CAF and creates the tags.
212
213   // Open the input stream
214   ifstream in;
215   in.open(filename);
216
217   Int_t counter = 0;
218   TString esdfile;
219   // Read the input list of files and add them to the chain
220   while(in.good()) {
221     in >> esdfile;
222     if (!esdfile.Contains("root")) continue; // protection
223
224     fChain->Add(esdfile);
225   
226     //TFile *f = TFile::Open(esdfile,"READ");
227     //CreateTag(f,esdfile,counter);
228     //f->Close();
229     //delete f;  
230     
231     counter += 1;
232   }
233
234   AliInfo(Form("AOD chain created......."));    
235   AliInfo(Form("Chain entries: %d",fChain->GetEntries()));      
236   CreateTag(fChain,"proof");
237
238   return kTRUE;
239 }
240
241 //______________________________________________________________________________
242 /*Bool_t AliAODTagCreator::ReadCAFCollection(const char *filename) {
243   // Temporary solution for CAF: Takes as an input the ascii file that
244   // lists the AODs stored in the SE of the CAF and creates the tags.
245
246   // Open the input stream
247   ifstream in;
248   in.open(filename);
249
250   Int_t counter = 0;
251   TString esdfile;
252   // Read the input list of files and add them to the chain
253   while(in.good()) {
254     in >> esdfile;
255     if (!esdfile.Contains("root")) continue; // protection
256     TFile *f = TFile::Open(esdfile,"READ");
257     CreateTag(f,esdfile,counter);
258     f->Close();
259     delete f;    
260     
261     counter += 1;
262   }
263
264   return kTRUE;
265   }*/
266
267 //__________________________________________________________________________
268 void AliAODTagCreator::CreateAODTags(Int_t fFirstEvent, Int_t fLastEvent) {
269   //creates tag files for AODs
270   
271   Float_t fLowPtCut = 1.0;
272   Float_t fHighPtCut = 3.0;
273   Float_t fVeryHighPtCut = 10.0;
274   ////////////
275
276   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
277
278   // Creates the tags for all the events in a given AOD file
279   Int_t ntrack;
280   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
281   Int_t nPos, nNeg, nNeutr;
282   Int_t nKinks, nV0s, nCascades;
283   Int_t nK0s, nNeutrons, nPi0s, nGamas;
284   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
285   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
286   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
287   Float_t maxPt = .0, meanPt = .0, totalP = .0;
288
289   AliRunTag *tag = new AliRunTag();
290   TTree ttag("T","A Tree with event tags");
291   TBranch * btag = ttag.Branch("AliTAG", &tag);
292   btag->SetCompressionLevel(9);
293   
294   //reading the esd tag file
295   TChain *oldTagTree = new TChain("T");
296   const char * tagPattern = "ESD.tag";
297   // Open the working directory
298   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
299   const char * name = 0x0;
300   // Add all files matching *pattern* to the chain
301   while((name = gSystem->GetDirEntry(dirp))) {
302     if (strstr(name,tagPattern)) oldTagTree->Add(name);  
303   }//directory loop
304   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
305
306   //reading the esd tag file
307   AliRunTag *oldtag = new AliRunTag();
308   TString tagFilename;
309   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
310   oldTagTree->GetEntry(0);
311   tag->CopyStandardContent(oldtag);
312   const TClonesArray *evTagList = oldtag->GetEventTags();
313
314   AliInfo(Form("Creating the AOD tags......."));        
315
316   TFile *file = TFile::Open("AliAOD.root");
317   if (!file || !file->IsOpen()) {
318     AliError(Form("opening failed"));
319     delete file;
320     return ;
321   }
322   TTree *aodTree = (TTree*)file->Get("aodTree");
323   AliAODEvent *aod = new AliAODEvent();
324   aod->ReadFromTree(aodTree);
325
326   Int_t lastEvent = 0;  
327   if(fLastEvent == -1) lastEvent = (Int_t)aodTree->GetEntries();
328   else lastEvent = fLastEvent;
329
330   // loop over events
331   Int_t nEvents = aodTree->GetEntries();
332   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
333     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);    
334     ntrack = 0;
335     nPos = 0; nNeg = 0; nNeutr =0;
336     nKinks = 0; nV0s = 0; nCascades = 0;
337     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
338     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;    
339     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
340     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
341     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
342     maxPt = .0; meanPt = .0; totalP = .0;
343
344     // read events
345     aodTree->GetEvent(iEventNumber);
346     
347     // set pointers
348     aod->GetStdContent();
349     
350     Int_t nTracks = aod->GetNTracks();
351     // loop over vertices
352     Int_t nVtxs = aod->GetNVertices();
353     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
354       // print track info
355       AliAODVertex *vertex = aod->GetVertex(nVtx);
356       if(vertex->GetType() == 1) nKinks += 1;
357       if(vertex->GetType() == 2) nV0s += 1;
358       if(vertex->GetType() == 3) nCascades += 1;
359     }
360     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
361       AliAODTrack *track = aod->GetTrack(nTr);
362       
363       Double_t fPt = track->Pt();
364       if(fPt > maxPt) maxPt = fPt;
365       if(track->Charge() > 0) {
366         nPos++;
367         if(fPt > fLowPtCut) nCh1GeV++;
368         if(fPt > fHighPtCut) nCh3GeV++;
369         if(fPt > fVeryHighPtCut) nCh10GeV++;
370       }
371       if(track->Charge() < 0) {
372         nNeg++;
373         if(fPt > fLowPtCut) nCh1GeV++;
374         if(fPt > fHighPtCut) nCh3GeV++;
375         if(fPt > fVeryHighPtCut) nCh10GeV++;
376       }
377       if(track->Charge() == 0) nNeutr++;
378
379       //PID
380       const Double32_t *prob = track->PID();
381       Double_t rcc = 0.0;
382       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
383       if(rcc == 0.0) continue;
384       //Bayes' formula
385       Double_t w[10];
386       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
387       
388       //protons
389       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
390       //kaons
391       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
392       //pions
393       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++; 
394       //muons
395       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
396         nMuons++;
397         if(fPt > fLowPtCut) nMu1GeV++;
398         if(fPt > fHighPtCut) nMu3GeV++;
399         if(fPt > fVeryHighPtCut) nMu10GeV++;
400         }
401       //electrons
402       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
403         nElectrons++;
404         if(fPt > fLowPtCut) nEl1GeV++;
405         if(fPt > fHighPtCut) nEl3GeV++;
406         if(fPt > fVeryHighPtCut) nEl10GeV++;
407       }
408
409       totalP += track->P();
410       meanPt += fPt;
411       ntrack++;
412     }//track loop    
413     // Fill the event tags 
414     if(ntrack != 0)
415       meanPt = meanPt/ntrack;
416
417     evTag->SetEventId(iEventNumber+1);
418         
419     evTag->SetNumOfTracks(nTracks);
420     evTag->SetNumOfPosTracks(nPos);
421     evTag->SetNumOfNegTracks(nNeg);
422     evTag->SetNumOfNeutrTracks(nNeutr);
423     
424     evTag->SetNumOfV0s(nV0s);
425     evTag->SetNumOfCascades(nCascades);
426     evTag->SetNumOfKinks(nKinks);
427     
428     evTag->SetNumOfProtons(nProtons);
429     evTag->SetNumOfKaons(nKaons);
430     evTag->SetNumOfPions(nPions);
431     evTag->SetNumOfMuons(nMuons);
432     evTag->SetNumOfElectrons(nElectrons);
433     evTag->SetNumOfPhotons(nGamas);
434     evTag->SetNumOfPi0s(nPi0s);
435     evTag->SetNumOfNeutrons(nNeutrons);
436     evTag->SetNumOfKaon0s(nK0s);
437     
438     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
439     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
440     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
441     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
442     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
443     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
444     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
445     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
446     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
447     
448     evTag->SetTotalMomentum(totalP);
449     evTag->SetMeanPt(meanPt);
450     evTag->SetMaxPt(maxPt);
451     tag->AddEventTag(*evTag);
452   }//event loop
453   if(fLastEvent == -1) lastEvent = (Int_t)aodTree->GetEntries();
454   else lastEvent = fLastEvent;
455
456   char fileName[256];
457   sprintf(fileName, "Run%d.Event%d_%d.AOD.tag.root", 
458           tag->GetRunId(),fFirstEvent,lastEvent );
459   AliInfo(Form("writing tags to file %s", fileName));
460   AliDebug(1, Form("writing tags to file %s", fileName));
461  
462   TFile* ftag = TFile::Open(fileName, "recreate");
463   ftag->cd();
464   ttag.Fill();
465   tag->Clear();
466   ttag.Write();
467   ftag->Close();
468   file->cd();
469   file->Close();
470 }
471
472 //_____________________________________________________________________________
473 void AliAODTagCreator::CreateTag(TChain* fChain, const char *type) {
474   //private method that creates tag files
475   TString fSession = type;
476   //Int_t iCounter = 0;
477   TString fguid, fmd5, fturl;
478   TString fTempGuid = 0;
479
480   //private method that creates tag files                                            
481   Float_t fLowPtCut = 1.0;
482   Float_t fHighPtCut = 3.0;
483   Float_t fVeryHighPtCut = 10.0;
484   ////////////                            
485   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
486
487   // Creates the tags for all the events in a given AOD file
488   Int_t ntrack;
489   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
490   Int_t nPos, nNeg, nNeutr;
491   Int_t nKinks, nV0s, nCascades;
492   Int_t nK0s, nNeutrons, nPi0s, nGamas;
493   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
494   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
495   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
496   Float_t maxPt = .0, meanPt = .0, totalP = .0;
497
498   AliRunTag *tag = new AliRunTag();
499   TTree ttag("T","A Tree with event tags");
500   TBranch * btag = ttag.Branch("AliTAG", &tag);
501   btag->SetCompressionLevel(9);
502   
503   //reading the esd tag file                    
504                               
505   TChain *oldTagTree = new TChain("T");
506   const char * tagPattern = "ESD.tag";
507   // Open the working directory
508   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
509   const char * name = 0x0;
510   // Add all files matching *pattern* to the chain
511   while((name = gSystem->GetDirEntry(dirp))) {
512     if (strstr(name,tagPattern)) oldTagTree->Add(name);
513   }//directory loop
514   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
515   
516   //reading the esd tag file 
517   AliRunTag *oldtag = new AliRunTag();
518   TString tagFilename;
519   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
520   oldTagTree->GetEntry(0);
521   tag->CopyStandardContent(oldtag);
522   const TClonesArray *evTagList = oldtag->GetEventTags();
523
524   AliInfo(Form("Creating the AOD tags......."));
525
526   /*if (!file || !file->IsOpen()) {
527     AliError(Form("opening failed"));
528     delete file;
529     return ;
530   }
531   TTree *aodTree = (TTree*)file->Get("aodTree");*/
532   AliAODEvent *aod = new AliAODEvent();
533   aod->ReadFromTree(fChain);
534   Int_t firstEvent = 0, lastEvent = 0;
535   //lastEvent = (Int_t)aodTree->GetEntries();
536
537   // loop over events 
538   Int_t nEvents = fChain->GetEntries();
539   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
540     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);
541     ntrack = 0;
542     nPos = 0; nNeg = 0; nNeutr =0;
543     nKinks = 0; nV0s = 0; nCascades = 0;
544     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
545     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;
546     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
547     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
548     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
549     maxPt = .0; meanPt = .0; totalP = .0;
550
551     // read events
552     fChain->GetEntry(iEventNumber);
553     TFile *f = fChain->GetFile();
554     const TUrl *url = f->GetEndpointUrl();
555     fguid = f->GetUUID().AsString();
556     if(fSession == "grid") {
557       TString fturltemp = "alien://"; fturltemp += url->GetFile();
558       fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
559     }
560     else fturl = url->GetFile();
561
562     // set pointers
563     aod->GetStdContent();
564
565     Int_t nTracks = aod->GetNTracks();
566     // loop over vertices 
567     Int_t nVtxs = aod->GetNVertices();
568     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
569       AliAODVertex *vertex = aod->GetVertex(nVtx);
570       if(vertex->GetType() == 1) nKinks += 1;
571       if(vertex->GetType() == 2) nV0s += 1;
572       if(vertex->GetType() == 3) nCascades += 1;
573     }
574     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
575       AliAODTrack *track = aod->GetTrack(nTr);
576
577       Double_t fPt = track->Pt();
578       if(fPt > maxPt) maxPt = fPt;
579       if(track->Charge() > 0) {
580         nPos++;
581         if(fPt > fLowPtCut) nCh1GeV++;
582         if(fPt > fHighPtCut) nCh3GeV++;
583         if(fPt > fVeryHighPtCut) nCh10GeV++;
584       }
585       if(track->Charge() < 0) {
586         nNeg++;
587         if(fPt > fLowPtCut) nCh1GeV++;
588         if(fPt > fHighPtCut) nCh3GeV++;
589         if(fPt > fVeryHighPtCut) nCh10GeV++;
590       }
591       if(track->Charge() == 0) nNeutr++;
592       //PID
593       const Double32_t *prob = track->PID();
594       Double_t rcc = 0.0;
595       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
596       if(rcc == 0.0) continue;
597       //Bayes' formula  
598       Double_t w[10];
599       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
600
601       //protons
602       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
603       //kaons
604       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
605       //pions
606       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
607       //muons 
608       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
609         nMuons++;
610         if(fPt > fLowPtCut) nMu1GeV++;
611         if(fPt > fHighPtCut) nMu3GeV++;
612         if(fPt > fVeryHighPtCut) nMu10GeV++;
613       }
614       //electrons  
615       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
616         nElectrons++;
617         if(fPt > fLowPtCut) nEl1GeV++;
618         if(fPt > fHighPtCut) nEl3GeV++;
619         if(fPt > fVeryHighPtCut) nEl10GeV++;
620       }
621
622       totalP += track->P();
623       meanPt += fPt;
624       ntrack++;
625     }//track loop
626     // Fill the event tags  
627     if(ntrack != 0)
628       meanPt = meanPt/ntrack;
629     
630     evTag->SetEventId(iEventNumber+1);
631     evTag->SetGUID(fguid);
632     if(fSession == "grid") {
633       evTag->SetMD5(0);
634       evTag->SetTURL(fturl);
635       evTag->SetSize(0);
636     }
637     else evTag->SetPath(fturl);
638
639     evTag->SetNumOfTracks(nTracks);
640     evTag->SetNumOfPosTracks(nPos);
641     evTag->SetNumOfNegTracks(nNeg);
642     evTag->SetNumOfNeutrTracks(nNeutr);
643
644     evTag->SetNumOfV0s(nV0s);
645     evTag->SetNumOfCascades(nCascades);
646     evTag->SetNumOfKinks(nKinks);
647
648     evTag->SetNumOfProtons(nProtons);
649     evTag->SetNumOfKaons(nKaons);
650     evTag->SetNumOfPions(nPions);
651     evTag->SetNumOfMuons(nMuons);
652     evTag->SetNumOfElectrons(nElectrons);
653     evTag->SetNumOfPhotons(nGamas);
654     evTag->SetNumOfPi0s(nPi0s);
655     evTag->SetNumOfNeutrons(nNeutrons);
656     evTag->SetNumOfKaon0s(nK0s);
657
658     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
659     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
660     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
661     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
662     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
663     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
664     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
665     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
666     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
667
668     evTag->SetTotalMomentum(totalP);
669     evTag->SetMeanPt(meanPt);
670     evTag->SetMaxPt(maxPt);
671     tag->AddEventTag(*evTag);
672
673     if(fguid != fTempGuid) {
674       fTempGuid = fguid;
675       ttag.Fill();
676       tag->Clear("");
677     }
678   }//event loop
679   lastEvent = fChain->GetEntries();
680     
681   TString localFileName = "Run"; localFileName += tag->GetRunId();
682   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; 
683   localFileName += lastEvent; //localFileName += "."; localFileName += Counter;
684   localFileName += ".AOD.tag.root";
685
686   TString fileName;
687
688   if(fStorage == 0) {
689     fileName = localFileName.Data();
690     AliInfo(Form("Writing AOD tags to local file: %s",fileName.Data()));
691   }
692   else if(fStorage == 1) {
693     TString alienLocation = "/alien";
694     alienLocation += gGrid->Pwd();
695     alienLocation += fgridpath.Data();
696     alienLocation += "/";
697     alienLocation +=  localFileName;
698     alienLocation += "?se=";
699     alienLocation += fSE.Data();
700     fileName = alienLocation.Data();
701     AliInfo(Form("Writing AOD tags to grid file: %s",fileName.Data()));
702   }
703
704   TFile* ftag = TFile::Open(fileName, "recreate");
705   ftag->cd();
706   //ttag.Fill();
707   tag->Clear();
708   ttag.Write();
709   ftag->Close();
710 }
711
712 //_____________________________________________________________________________
713 void AliAODTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
714   //private method that creates tag files
715   TString fguid = guid;
716   TString fmd5 = md5;
717   TString fturl = turl;
718
719   //private method that creates tag files                                            
720   Float_t fLowPtCut = 1.0;
721   Float_t fHighPtCut = 3.0;
722   Float_t fVeryHighPtCut = 10.0;
723   ////////////                            
724   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
725
726   // Creates the tags for all the events in a given AOD file
727   Int_t ntrack;
728   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
729   Int_t nPos, nNeg, nNeutr;
730   Int_t nKinks, nV0s, nCascades;
731   Int_t nK0s, nNeutrons, nPi0s, nGamas;
732   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
733   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
734   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
735   Float_t maxPt = .0, meanPt = .0, totalP = .0;
736
737   AliRunTag *tag = new AliRunTag();
738   TTree ttag("T","A Tree with event tags");
739   TBranch * btag = ttag.Branch("AliTAG", &tag);
740   btag->SetCompressionLevel(9);
741   
742   //reading the esd tag file                    
743                               
744   TChain *oldTagTree = new TChain("T");
745   const char * tagPattern = "ESD.tag";
746   // Open the working directory
747   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
748   const char * name = 0x0;
749   // Add all files matching *pattern* to the chain
750   while((name = gSystem->GetDirEntry(dirp))) {
751     if (strstr(name,tagPattern)) oldTagTree->Add(name);
752   }//directory loop
753   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
754   
755   //reading the esd tag file 
756   AliRunTag *oldtag = new AliRunTag();
757   TString tagFilename;
758   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
759   oldTagTree->GetEntry(0);
760   tag->CopyStandardContent(oldtag);
761   const TClonesArray *evTagList = oldtag->GetEventTags();
762
763   AliInfo(Form("Creating the AOD tags......."));
764
765   if (!file || !file->IsOpen()) {
766     AliError(Form("opening failed"));
767     delete file;
768     return ;
769   }
770   TTree *aodTree = (TTree*)file->Get("aodTree");
771   AliAODEvent *aod = new AliAODEvent();
772   aod->ReadFromTree(aodTree);
773   Int_t firstEvent = 0, lastEvent = 0;
774   lastEvent = (Int_t)aodTree->GetEntries();
775
776   // loop over events 
777   Int_t nEvents = aodTree->GetEntries();
778   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
779     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);
780     ntrack = 0;
781     nPos = 0; nNeg = 0; nNeutr =0;
782     nKinks = 0; nV0s = 0; nCascades = 0;
783     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
784     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;
785     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
786     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
787     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
788     maxPt = .0; meanPt = .0; totalP = .0;
789
790     // read events
791     aodTree->GetEvent(iEventNumber);
792     // set pointers
793     aod->GetStdContent();
794
795     Int_t nTracks = aod->GetNTracks();
796     // loop over vertices 
797     Int_t nVtxs = aod->GetNVertices();
798     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
799       AliAODVertex *vertex = aod->GetVertex(nVtx);
800       if(vertex->GetType() == 1) nKinks += 1;
801       if(vertex->GetType() == 2) nV0s += 1;
802       if(vertex->GetType() == 3) nCascades += 1;
803     }
804     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
805       AliAODTrack *track = aod->GetTrack(nTr);
806
807       Double_t fPt = track->Pt();
808       if(fPt > maxPt) maxPt = fPt;
809       if(track->Charge() > 0) {
810         nPos++;
811         if(fPt > fLowPtCut) nCh1GeV++;
812         if(fPt > fHighPtCut) nCh3GeV++;
813         if(fPt > fVeryHighPtCut) nCh10GeV++;
814       }
815       if(track->Charge() < 0) {
816         nNeg++;
817         if(fPt > fLowPtCut) nCh1GeV++;
818         if(fPt > fHighPtCut) nCh3GeV++;
819         if(fPt > fVeryHighPtCut) nCh10GeV++;
820       }
821       if(track->Charge() == 0) nNeutr++;
822       //PID
823       const Double32_t *prob = track->PID();
824       Double_t rcc = 0.0;
825       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
826       if(rcc == 0.0) continue;
827       //Bayes' formula  
828       Double_t w[10];
829       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
830
831       //protons
832       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
833       //kaons
834       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
835       //pions
836       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
837       //muons 
838       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
839         nMuons++;
840         if(fPt > fLowPtCut) nMu1GeV++;
841         if(fPt > fHighPtCut) nMu3GeV++;
842         if(fPt > fVeryHighPtCut) nMu10GeV++;
843       }
844       //electrons  
845       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
846         nElectrons++;
847         if(fPt > fLowPtCut) nEl1GeV++;
848         if(fPt > fHighPtCut) nEl3GeV++;
849         if(fPt > fVeryHighPtCut) nEl10GeV++;
850       }
851
852       totalP += track->P();
853       meanPt += fPt;
854       ntrack++;
855     }//track loop
856     // Fill the event tags  
857     if(ntrack != 0)
858       meanPt = meanPt/ntrack;
859     
860     evTag->SetEventId(iEventNumber+1);
861     evTag->SetGUID(fguid);
862     evTag->SetMD5(fmd5);
863     evTag->SetTURL(fturl);
864     evTag->SetSize(size);
865
866     evTag->SetNumOfTracks(nTracks);
867     evTag->SetNumOfPosTracks(nPos);
868     evTag->SetNumOfNegTracks(nNeg);
869     evTag->SetNumOfNeutrTracks(nNeutr);
870
871     evTag->SetNumOfV0s(nV0s);
872     evTag->SetNumOfCascades(nCascades);
873     evTag->SetNumOfKinks(nKinks);
874
875     evTag->SetNumOfProtons(nProtons);
876     evTag->SetNumOfKaons(nKaons);
877     evTag->SetNumOfPions(nPions);
878     evTag->SetNumOfMuons(nMuons);
879     evTag->SetNumOfElectrons(nElectrons);
880     evTag->SetNumOfPhotons(nGamas);
881     evTag->SetNumOfPi0s(nPi0s);
882     evTag->SetNumOfNeutrons(nNeutrons);
883     evTag->SetNumOfKaon0s(nK0s);
884
885     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
886     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
887     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
888     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
889     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
890     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
891     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
892     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
893     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
894
895     evTag->SetTotalMomentum(totalP);
896     evTag->SetMeanPt(meanPt);
897     evTag->SetMaxPt(maxPt);
898     tag->AddEventTag(*evTag);
899   }//event loop
900     
901   TString localFileName = "Run"; localFileName += tag->GetRunId();
902   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; 
903   localFileName += lastEvent; localFileName += "."; localFileName += Counter;
904   localFileName += ".AOD.tag.root";
905
906   TString fileName;
907
908   if(fStorage == 0) {
909     fileName = localFileName.Data();
910     AliInfo(Form("Writing AOD tags to local file: %s",fileName.Data()));
911   }
912   else if(fStorage == 1) {
913     TString alienLocation = "/alien";
914     alienLocation += gGrid->Pwd();
915     alienLocation += fgridpath.Data();
916     alienLocation += "/";
917     alienLocation +=  localFileName;
918     alienLocation += "?se=";
919     alienLocation += fSE.Data();
920     fileName = alienLocation.Data();
921     AliInfo(Form("Writing AOD tags to grid file: %s",fileName.Data()));
922   }
923
924   TFile* ftag = TFile::Open(fileName, "recreate");
925   ftag->cd();
926   ttag.Fill();
927   tag->Clear();
928   ttag.Write();
929   ftag->Close();
930 }
931   
932
933 //_____________________________________________________________________________
934 void AliAODTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
935   //private method that creates tag files
936   Float_t fLowPtCut = 1.0;
937   Float_t fHighPtCut = 3.0;
938   Float_t fVeryHighPtCut = 10.0;
939   ////////////
940   
941   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
942   
943   // Creates the tags for all the events in a given AOD file
944   Int_t ntrack;
945   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
946   Int_t nPos, nNeg, nNeutr;
947   Int_t nKinks, nV0s, nCascades;
948   Int_t nK0s, nNeutrons, nPi0s, nGamas;
949   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
950   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
951   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
952   Float_t maxPt = .0, meanPt = .0, totalP = .0;
953
954   AliRunTag *tag = new AliRunTag();
955   TTree ttag("T","A Tree with event tags");
956   TBranch * btag = ttag.Branch("AliTAG", &tag);
957   btag->SetCompressionLevel(9);
958
959   //reading the esd tag file
960   TChain *oldTagTree = new TChain("T");
961   const char * tagPattern = "ESD.tag";
962   // Open the working directory
963   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
964   const char * name = 0x0;
965   // Add all files matching *pattern* to the chain
966   while((name = gSystem->GetDirEntry(dirp))) {
967     if (strstr(name,tagPattern)) oldTagTree->Add(name);
968   }//directory loop
969   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
970
971   //reading the esd tag file
972   AliRunTag *oldtag = new AliRunTag();
973   TString tagFilename;
974   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
975   oldTagTree->GetEntry(0);
976   tag->CopyStandardContent(oldtag);
977   const TClonesArray *evTagList = oldtag->GetEventTags();
978
979   AliInfo(Form("Creating the AOD tags......."));
980
981   if (!file || !file->IsOpen()) {
982     AliError(Form("opening failed"));
983     delete file;
984     return ;
985   }
986   TTree *aodTree = (TTree*)file->Get("aodTree");
987   AliAODEvent *aod = new AliAODEvent();
988   aod->ReadFromTree(aodTree);
989   Int_t firstEvent = 0, lastEvent = 0;  
990   lastEvent = (Int_t)aodTree->GetEntries();
991   
992   // loop over events
993   Int_t nEvents = aodTree->GetEntries();
994   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
995     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);    
996     ntrack = 0;
997     nPos = 0; nNeg = 0; nNeutr =0;
998     nKinks = 0; nV0s = 0; nCascades = 0;
999     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
1000     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;  
1001     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
1002     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
1003     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
1004     maxPt = .0; meanPt = .0; totalP = .0;
1005
1006     // read events
1007     aodTree->GetEvent(iEventNumber);
1008     
1009     // set pointers
1010     aod->GetStdContent();
1011     
1012     Int_t nTracks = aod->GetNTracks();
1013     // loop over vertices
1014     Int_t nVtxs = aod->GetNVertices();
1015     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
1016       // print track info
1017       AliAODVertex *vertex = aod->GetVertex(nVtx);
1018       if(vertex->GetType() == 1) nKinks += 1;
1019       if(vertex->GetType() == 2) nV0s += 1;
1020       if(vertex->GetType() == 3) nCascades += 1;
1021     }
1022     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
1023       AliAODTrack *track = aod->GetTrack(nTr);
1024       
1025       Double_t fPt = track->Pt();
1026       if(fPt > maxPt) maxPt = fPt;
1027       if(track->Charge() > 0) {
1028       nPos++;
1029       if(fPt > fLowPtCut) nCh1GeV++;
1030       if(fPt > fHighPtCut) nCh3GeV++;
1031       if(fPt > fVeryHighPtCut) nCh10GeV++;
1032       }
1033       if(track->Charge() < 0) {
1034       nNeg++;
1035       if(fPt > fLowPtCut) nCh1GeV++;
1036       if(fPt > fHighPtCut) nCh3GeV++;
1037       if(fPt > fVeryHighPtCut) nCh10GeV++;
1038       }
1039       if(track->Charge() == 0) nNeutr++;
1040
1041       //PID
1042       const Double32_t *prob = track->PID();
1043       Double_t rcc = 0.0;
1044       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1045       if(rcc == 0.0) continue;
1046       //Bayes' formula
1047       Double_t w[10];
1048       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1049       
1050       //protons
1051       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1052       //kaons
1053       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1054       //pions
1055       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++; 
1056       //muons
1057       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
1058       nMuons++;
1059       if(fPt > fLowPtCut) nMu1GeV++;
1060       if(fPt > fHighPtCut) nMu3GeV++;
1061       if(fPt > fVeryHighPtCut) nMu10GeV++;
1062       }
1063       //electrons
1064       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1065       nElectrons++;
1066       if(fPt > fLowPtCut) nEl1GeV++;
1067       if(fPt > fHighPtCut) nEl3GeV++;
1068       if(fPt > fVeryHighPtCut) nEl10GeV++;
1069       }
1070
1071       totalP += track->P();
1072       meanPt += fPt;
1073       ntrack++;
1074     }//track loop    
1075     // Fill the event tags 
1076     if(ntrack != 0)
1077       meanPt = meanPt/ntrack;
1078
1079     evTag->SetEventId(iEventNumber+1);
1080     evTag->SetPath(filepath);
1081         
1082     evTag->SetNumOfTracks(nTracks);
1083     evTag->SetNumOfPosTracks(nPos);
1084     evTag->SetNumOfNegTracks(nNeg);
1085     evTag->SetNumOfNeutrTracks(nNeutr);
1086     
1087     evTag->SetNumOfV0s(nV0s);
1088     evTag->SetNumOfCascades(nCascades);
1089     evTag->SetNumOfKinks(nKinks);
1090     
1091     evTag->SetNumOfProtons(nProtons);
1092     evTag->SetNumOfKaons(nKaons);
1093     evTag->SetNumOfPions(nPions);
1094     evTag->SetNumOfMuons(nMuons);
1095     evTag->SetNumOfElectrons(nElectrons);
1096     evTag->SetNumOfPhotons(nGamas);
1097     evTag->SetNumOfPi0s(nPi0s);
1098     evTag->SetNumOfNeutrons(nNeutrons);
1099     evTag->SetNumOfKaon0s(nK0s);
1100     
1101     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1102     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1103     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1104     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1105     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1106     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1107     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1108     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1109     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1110     
1111     evTag->SetTotalMomentum(totalP);
1112     evTag->SetMeanPt(meanPt);
1113     evTag->SetMaxPt(maxPt);
1114     tag->AddEventTag(*evTag);
1115   }//event loop  
1116
1117   TString localFileName = "Run"; localFileName += tag->GetRunId(); 
1118   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; 
1119   localFileName += lastEvent; localFileName += "."; localFileName += Counter;
1120   localFileName += ".AOD.tag.root";
1121
1122   TString fileName;
1123   
1124   if(fStorage == 0) {
1125     fileName = localFileName.Data();      
1126     AliInfo(Form("Writing AOD tags to local file: %s",fileName.Data()));
1127   }
1128   else if(fStorage == 1) {
1129     TString alienLocation = "/alien";
1130     alienLocation += gGrid->Pwd();
1131     alienLocation += fgridpath.Data();
1132     alienLocation += "/";
1133     alienLocation +=  localFileName;
1134     alienLocation += "?se=";
1135     alienLocation += fSE.Data();
1136     fileName = alienLocation.Data();
1137     AliInfo(Form("Writing AOD tags to grid file: %s",fileName.Data()));
1138   }
1139
1140   TFile* ftag = TFile::Open(fileName, "recreate");
1141   ftag->cd();
1142   ttag.Fill();
1143   tag->Clear();
1144   ttag.Write();
1145   ftag->Close();
1146 }
1147