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