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