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