STEER/AliAODTagCreator.cxx

   1 /**************************************************************************
   2  * Author: Panos Christakoglou.                                           *
   3  * Contributors are mentioned in the code where appropriate.              *
   4  *                                                                        *
   5  * Permission to use, copy, modify and distribute this software and its   *
   6  * documentation strictly for non-commercial purposes is hereby granted   *
   7  * without fee, provided that the above copyright notice appears in all   *
   8  * copies and that both the copyright notice and this permission notice   *
   9  * appear in the supporting documentation. The authors make no claims     *
  10  * about the suitability of this software for any purpose. It is          *
  11  * provided "as is" without express or implied warranty.                  *
  12  **************************************************************************/
  13
  14 /* $Id$ */
  15
  16 //-----------------------------------------------------------------
  17 //           AliAODTagCreator class
  18 //   This is the class to deal with the tag creation (post process)
  19 //   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
  20 //-----------------------------------------------------------------
  21
  22 //ROOT
  23 #include <Riostream.h>
  24 #include <TFile.h>
  25 #include <TString.h>
  26 #include <TTree.h>
  27 #include <TSystem.h>
  28 #include <TChain.h>
  29 #include <TLorentzVector.h>
  30
  31 //ROOT-AliEn
  32 #include <TGrid.h>
  33 #include <TGridResult.h>
  34
  35 //AliRoot
  36 #include "AliRunTag.h"
  37 #include "AliEventTag.h"
  38 #include "AliPID.h"
  39 #include "AliAODEvent.h"
  40 #include "AliAODVertex.h"
  41 #include "AliLog.h"
  42
  43 #include "AliAODTagCreator.h"
  44
  45
  46 ClassImp(AliAODTagCreator)
  47
  48
  49 //______________________________________________________________________________
  50   AliAODTagCreator::AliAODTagCreator() :
  51     AliTagCreator() {
  52   //==============Default constructor for a AliAODTagCreator================
  53 }
  54
  55 //______________________________________________________________________________
  56 AliAODTagCreator::~AliAODTagCreator() {
  57 //================Default destructor for a AliAODTagCreator===================
  58 }
  59
  60 //______________________________________________________________________________
  61 Bool_t AliAODTagCreator::ReadGridCollection(TGridResult *fresult) {
  62   // Reads the entry of the TGridResult and creates the tags
  63   Int_t nEntries = fresult->GetEntries();
  64
  65   TString alienUrl;
  66   const char *guid;
  67   const char *md5;
  68   const char *turl;
  69   Long64_t size = -1;
  70
  71   Int_t counter = 0;
  72   for(Int_t i = 0; i < nEntries; i++) {
  73     alienUrl = fresult->GetKey(i,"turl");
  74     guid = fresult->GetKey(i,"guid");
  75     if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
  76     md5 = fresult->GetKey(i,"md5");
  77     turl = fresult->GetKey(i,"turl");
  78     if(md5 && !strlen(guid)) md5 = 0;
  79     if(guid && !strlen(guid)) guid = 0;
  80
  81     TFile *f = TFile::Open(alienUrl,"READ");
  82     CreateTag(f,guid,md5,turl,size,counter);
  83     f->Close();
  84     delete f;
  85     counter += 1;
  86   }//grid result loop
  87
  88   return kTRUE;
  89 }
  90
  91 //______________________________________________________________________________
  92 Bool_t AliAODTagCreator::ReadLocalCollection(const char *localpath) {
  93   // Checks the different subdirs of the given local path and in the
  94   // case where it finds an AliAODs.root file it creates the tags
  95
  96   void *dira =  gSystem->OpenDirectory(localpath);
  97   Char_t fPath[256];
  98   const char * dirname = 0x0;
  99   const char * filename = 0x0;
 100   const char * pattern = "AliAOD.root";
 101
 102   Int_t counter = 0;
 103   while((dirname = gSystem->GetDirEntry(dira))) {
 104     sprintf(fPath,"%s/%s",localpath,dirname);
 105     void *dirb =  gSystem->OpenDirectory(fPath);
 106     while((filename = gSystem->GetDirEntry(dirb))) {
 107       if(strstr(filename,pattern)) {
 108         TString fAODFileName;
 109         fAODFileName = fPath;
 110         fAODFileName += "/";
 111         fAODFileName += pattern;
 112         TFile *f = TFile::Open(fAODFileName,"READ");
 113         CreateTag(f,fAODFileName,counter);
 114         f->Close();
 115         delete f;
 116
 117         counter += 1;
 118       }//pattern check
 119     }//child directory's entry loop
 120   }//parent directory's entry loop
 121
 122   return kTRUE;
 123 }
 124
 125 //______________________________________________________________________________
 126 Bool_t AliAODTagCreator::ReadCAFCollection(const char *filename) {
 127   // Temporary solution for CAF: Takes as an input the ascii file that
 128   // lists the AODs stored in the SE of the CAF and creates the tags.
 129
 130   // Open the input stream
 131   ifstream in;
 132   in.open(filename);
 133
 134   Int_t counter = 0;
 135   TString esdfile;
 136   // Read the input list of files and add them to the chain
 137   while(in.good()) {
 138     in >> esdfile;
 139     if (!esdfile.Contains("root")) continue; // protection
 140     TFile *f = TFile::Open(esdfile,"READ");
 141     CreateTag(f,esdfile,counter);
 142     f->Close();
 143     delete f;
 144
 145     counter += 1;
 146   }
 147
 148   return kTRUE;
 149 }
 150
 151 //__________________________________________________________________________
 152 void AliAODTagCreator::CreateAODTags(Int_t fFirstEvent, Int_t fLastEvent) {
 153   //creates tag files for AODs
 154
 155   Float_t fLowPtCut = 1.0;
 156   Float_t fHighPtCut = 3.0;
 157   Float_t fVeryHighPtCut = 10.0;
 158   ////////////
 159
 160   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
 161
 162   // Creates the tags for all the events in a given AOD file
 163   Int_t ntrack;
 164   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
 165   Int_t nPos, nNeg, nNeutr;
 166   Int_t nKinks, nV0s, nCascades;
 167   Int_t nK0s, nNeutrons, nPi0s, nGamas;
 168   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
 169   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
 170   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
 171   Float_t maxPt = .0, meanPt = .0, totalP = .0;
 172
 173   AliRunTag *tag = new AliRunTag();
 174   TTree ttag("T","A Tree with event tags");
 175   TBranch * btag = ttag.Branch("AliTAG", &tag);
 176   btag->SetCompressionLevel(9);
 177
 178   //reading the esd tag file
 179   TChain *oldTagTree = new TChain("T");
 180   const char * tagPattern = "ESD.tag";
 181   // Open the working directory
 182   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
 183   const char * name = 0x0;
 184   // Add all files matching *pattern* to the chain
 185   while((name = gSystem->GetDirEntry(dirp))) {
 186     if (strstr(name,tagPattern)) oldTagTree->Add(name);
 187   }//directory loop
 188   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
 189
 190   //reading the esd tag file
 191   AliRunTag *oldtag = new AliRunTag();
 192   TString tagFilename;
 193   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
 194   oldTagTree->GetEntry(0);
 195   tag->CopyStandardContent(oldtag);
 196   const TClonesArray *evTagList = oldtag->GetEventTags();
 197
 198   AliInfo(Form("Creating the AOD tags......."));
 199
 200   TFile *file = TFile::Open("AliAOD.root");
 201   if (!file || !file->IsOpen()) {
 202     AliError(Form("opening failed"));
 203     delete file;
 204     return ;
 205   }
 206   TTree *aodTree = (TTree*)file->Get("aodTree");
 207   AliAODEvent *aod = new AliAODEvent();
 208   aod->ReadFromTree(aodTree);
 209
 210   Int_t lastEvent = 0;
 211   if(fLastEvent == -1) lastEvent = (Int_t)aodTree->GetEntries();
 212   else lastEvent = fLastEvent;
 213
 214   // loop over events
 215   Int_t nEvents = aodTree->GetEntries();
 216   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
 217     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);
 218     ntrack = 0;
 219     nPos = 0; nNeg = 0; nNeutr =0;
 220     nKinks = 0; nV0s = 0; nCascades = 0;
 221     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
 222     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;
 223     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
 224     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
 225     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
 226     maxPt = .0; meanPt = .0; totalP = .0;
 227
 228     // read events
 229     aodTree->GetEvent(iEventNumber);
 230
 231     // set pointers
 232     aod->GetStdContent();
 233
 234     Int_t nTracks = aod->GetNTracks();
 235     // loop over vertices
 236     Int_t nVtxs = aod->GetNVertices();
 237     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
 238       // print track info
 239       AliAODVertex *vertex = aod->GetVertex(nVtx);
 240       if(vertex->GetType() == 1) nKinks += 1;
 241       if(vertex->GetType() == 2) nV0s += 1;
 242       if(vertex->GetType() == 3) nCascades += 1;
 243     }
 244     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
 245       AliAODTrack *track = aod->GetTrack(nTr);
 246
 247       Double_t fPt = track->Pt();
 248       if(fPt > maxPt) maxPt = fPt;
 249       if(track->Charge() > 0) {
 250         nPos++;
 251         if(fPt > fLowPtCut) nCh1GeV++;
 252         if(fPt > fHighPtCut) nCh3GeV++;
 253         if(fPt > fVeryHighPtCut) nCh10GeV++;
 254       }
 255       if(track->Charge() < 0) {
 256         nNeg++;
 257         if(fPt > fLowPtCut) nCh1GeV++;
 258         if(fPt > fHighPtCut) nCh3GeV++;
 259         if(fPt > fVeryHighPtCut) nCh10GeV++;
 260       }
 261       if(track->Charge() == 0) nNeutr++;
 262
 263       //PID
 264       const Double32_t *prob = track->PID();
 265       Double_t rcc = 0.0;
 266       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
 267       if(rcc == 0.0) continue;
 268       //Bayes' formula
 269       Double_t w[10];
 270       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
 271
 272       //protons
 273       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
 274       //kaons
 275       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
 276       //pions
 277       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
 278       //muons
 279       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
 280         nMuons++;
 281         if(fPt > fLowPtCut) nMu1GeV++;
 282         if(fPt > fHighPtCut) nMu3GeV++;
 283         if(fPt > fVeryHighPtCut) nMu10GeV++;
 284         }
 285       //electrons
 286       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
 287         nElectrons++;
 288         if(fPt > fLowPtCut) nEl1GeV++;
 289         if(fPt > fHighPtCut) nEl3GeV++;
 290         if(fPt > fVeryHighPtCut) nEl10GeV++;
 291       }
 292
 293       totalP += track->P();
 294       meanPt += fPt;
 295       ntrack++;
 296     }//track loop
 297     // Fill the event tags
 298     if(ntrack != 0)
 299       meanPt = meanPt/ntrack;
 300
 301     evTag->SetEventId(iEventNumber+1);
 302
 303     evTag->SetNumOfTracks(nTracks);
 304     evTag->SetNumOfPosTracks(nPos);
 305     evTag->SetNumOfNegTracks(nNeg);
 306     evTag->SetNumOfNeutrTracks(nNeutr);
 307
 308     evTag->SetNumOfV0s(nV0s);
 309     evTag->SetNumOfCascades(nCascades);
 310     evTag->SetNumOfKinks(nKinks);
 311
 312     evTag->SetNumOfProtons(nProtons);
 313     evTag->SetNumOfKaons(nKaons);
 314     evTag->SetNumOfPions(nPions);
 315     evTag->SetNumOfMuons(nMuons);
 316     evTag->SetNumOfElectrons(nElectrons);
 317     evTag->SetNumOfPhotons(nGamas);
 318     evTag->SetNumOfPi0s(nPi0s);
 319     evTag->SetNumOfNeutrons(nNeutrons);
 320     evTag->SetNumOfKaon0s(nK0s);
 321
 322     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
 323     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
 324     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
 325     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
 326     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
 327     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
 328     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
 329     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
 330     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
 331
 332     evTag->SetTotalMomentum(totalP);
 333     evTag->SetMeanPt(meanPt);
 334     evTag->SetMaxPt(maxPt);
 335     tag->AddEventTag(*evTag);
 336   }//event loop
 337   if(fLastEvent == -1) lastEvent = (Int_t)aodTree->GetEntries();
 338   else lastEvent = fLastEvent;
 339
 340   char fileName[256];
 341   sprintf(fileName, "Run%d.Event%d_%d.AOD.tag.root",
 342           tag->GetRunId(),fFirstEvent,lastEvent );
 343   AliInfo(Form("writing tags to file %s", fileName));
 344   AliDebug(1, Form("writing tags to file %s", fileName));
 345
 346   TFile* ftag = TFile::Open(fileName, "recreate");
 347   ftag->cd();
 348   ttag.Fill();
 349   tag->Clear();
 350   ttag.Write();
 351   ftag->Close();
 352   file->cd();
 353   file->Close();
 354 }
 355
 356 //_____________________________________________________________________________
 357 void AliAODTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
 358   //private method that creates tag files
 359   TString fguid = guid;
 360   TString fmd5 = md5;
 361   TString fturl = turl;
 362
 363   //private method that creates tag files
 364   Float_t fLowPtCut = 1.0;
 365   Float_t fHighPtCut = 3.0;
 366   Float_t fVeryHighPtCut = 10.0;
 367   ////////////
 368   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
 369
 370   // Creates the tags for all the events in a given AOD file
 371   Int_t ntrack;
 372   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
 373   Int_t nPos, nNeg, nNeutr;
 374   Int_t nKinks, nV0s, nCascades;
 375   Int_t nK0s, nNeutrons, nPi0s, nGamas;
 376   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
 377   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
 378   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
 379   Float_t maxPt = .0, meanPt = .0, totalP = .0;
 380
 381   AliRunTag *tag = new AliRunTag();
 382   TTree ttag("T","A Tree with event tags");
 383   TBranch * btag = ttag.Branch("AliTAG", &tag);
 384   btag->SetCompressionLevel(9);
 385
 386   //reading the esd tag file
 387
 388   TChain *oldTagTree = new TChain("T");
 389   const char * tagPattern = "ESD.tag";
 390   // Open the working directory
 391   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
 392   const char * name = 0x0;
 393   // Add all files matching *pattern* to the chain
 394   while((name = gSystem->GetDirEntry(dirp))) {
 395     if (strstr(name,tagPattern)) oldTagTree->Add(name);
 396   }//directory loop
 397   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
 398
 399   //reading the esd tag file
 400   AliRunTag *oldtag = new AliRunTag();
 401   TString tagFilename;
 402   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
 403   oldTagTree->GetEntry(0);
 404   tag->CopyStandardContent(oldtag);
 405   const TClonesArray *evTagList = oldtag->GetEventTags();
 406
 407   AliInfo(Form("Creating the AOD tags......."));
 408
 409   if (!file || !file->IsOpen()) {
 410     AliError(Form("opening failed"));
 411     delete file;
 412     return ;
 413   }
 414   TTree *aodTree = (TTree*)file->Get("aodTree");
 415   AliAODEvent *aod = new AliAODEvent();
 416   aod->ReadFromTree(aodTree);
 417   Int_t firstEvent = 0, lastEvent = 0;
 418   lastEvent = (Int_t)aodTree->GetEntries();
 419
 420   // loop over events
 421   Int_t nEvents = aodTree->GetEntries();
 422   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
 423     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);
 424     ntrack = 0;
 425     nPos = 0; nNeg = 0; nNeutr =0;
 426     nKinks = 0; nV0s = 0; nCascades = 0;
 427     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
 428     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;
 429     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
 430     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
 431     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
 432     maxPt = .0; meanPt = .0; totalP = .0;
 433
 434     // read events
 435     aodTree->GetEvent(iEventNumber);
 436     // set pointers
 437     aod->GetStdContent();
 438
 439     Int_t nTracks = aod->GetNTracks();
 440     // loop over vertices
 441     Int_t nVtxs = aod->GetNVertices();
 442     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
 443       AliAODVertex *vertex = aod->GetVertex(nVtx);
 444       if(vertex->GetType() == 1) nKinks += 1;
 445       if(vertex->GetType() == 2) nV0s += 1;
 446       if(vertex->GetType() == 3) nCascades += 1;
 447     }
 448     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
 449       AliAODTrack *track = aod->GetTrack(nTr);
 450
 451       Double_t fPt = track->Pt();
 452       if(fPt > maxPt) maxPt = fPt;
 453       if(track->Charge() > 0) {
 454         nPos++;
 455         if(fPt > fLowPtCut) nCh1GeV++;
 456         if(fPt > fHighPtCut) nCh3GeV++;
 457         if(fPt > fVeryHighPtCut) nCh10GeV++;
 458       }
 459       if(track->Charge() < 0) {
 460         nNeg++;
 461         if(fPt > fLowPtCut) nCh1GeV++;
 462         if(fPt > fHighPtCut) nCh3GeV++;
 463         if(fPt > fVeryHighPtCut) nCh10GeV++;
 464       }
 465       if(track->Charge() == 0) nNeutr++;
 466       //PID
 467       const Double32_t *prob = track->PID();
 468       Double_t rcc = 0.0;
 469       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
 470       if(rcc == 0.0) continue;
 471       //Bayes' formula
 472       Double_t w[10];
 473       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
 474
 475       //protons
 476       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
 477       //kaons
 478       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
 479       //pions
 480       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
 481       //muons
 482       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
 483         nMuons++;
 484         if(fPt > fLowPtCut) nMu1GeV++;
 485         if(fPt > fHighPtCut) nMu3GeV++;
 486         if(fPt > fVeryHighPtCut) nMu10GeV++;
 487       }
 488       //electrons
 489       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
 490         nElectrons++;
 491         if(fPt > fLowPtCut) nEl1GeV++;
 492         if(fPt > fHighPtCut) nEl3GeV++;
 493         if(fPt > fVeryHighPtCut) nEl10GeV++;
 494       }
 495
 496       totalP += track->P();
 497       meanPt += fPt;
 498       ntrack++;
 499     }//track loop
 500     // Fill the event tags
 501     if(ntrack != 0)
 502       meanPt = meanPt/ntrack;
 503
 504     evTag->SetEventId(iEventNumber+1);
 505     evTag->SetGUID(fguid);
 506     evTag->SetMD5(fmd5);
 507     evTag->SetTURL(fturl);
 508     evTag->SetSize(size);
 509
 510     evTag->SetNumOfTracks(nTracks);
 511     evTag->SetNumOfPosTracks(nPos);
 512     evTag->SetNumOfNegTracks(nNeg);
 513     evTag->SetNumOfNeutrTracks(nNeutr);
 514
 515     evTag->SetNumOfV0s(nV0s);
 516     evTag->SetNumOfCascades(nCascades);
 517     evTag->SetNumOfKinks(nKinks);
 518
 519     evTag->SetNumOfProtons(nProtons);
 520     evTag->SetNumOfKaons(nKaons);
 521     evTag->SetNumOfPions(nPions);
 522     evTag->SetNumOfMuons(nMuons);
 523     evTag->SetNumOfElectrons(nElectrons);
 524     evTag->SetNumOfPhotons(nGamas);
 525     evTag->SetNumOfPi0s(nPi0s);
 526     evTag->SetNumOfNeutrons(nNeutrons);
 527     evTag->SetNumOfKaon0s(nK0s);
 528
 529     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
 530     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
 531     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
 532     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
 533     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
 534     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
 535     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
 536     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
 537     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
 538
 539     evTag->SetTotalMomentum(totalP);
 540     evTag->SetMeanPt(meanPt);
 541     evTag->SetMaxPt(maxPt);
 542     tag->AddEventTag(*evTag);
 543   }//event loop
 544
 545   TString localFileName = "Run"; localFileName += tag->GetRunId();
 546   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_";
 547   localFileName += lastEvent; localFileName += "."; localFileName += Counter;
 548   localFileName += ".AOD.tag.root";
 549
 550   TString fileName;
 551
 552   if(fStorage == 0) {
 553     fileName = localFileName.Data();
 554     AliInfo(Form("Writing AOD tags to local file: %s",fileName.Data()));
 555   }
 556   else if(fStorage == 1) {
 557     TString alienLocation = "/alien";
 558     alienLocation += gGrid->Pwd();
 559     alienLocation += fgridpath.Data();
 560     alienLocation += "/";
 561     alienLocation +=  localFileName;
 562     alienLocation += "?se=";
 563     alienLocation += fSE.Data();
 564     fileName = alienLocation.Data();
 565     AliInfo(Form("Writing AOD tags to grid file: %s",fileName.Data()));
 566   }
 567
 568   TFile* ftag = TFile::Open(fileName, "recreate");
 569   ftag->cd();
 570   ttag.Fill();
 571   tag->Clear();
 572   ttag.Write();
 573   ftag->Close();
 574 }
 575
 576
 577 //_____________________________________________________________________________
 578 void AliAODTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
 579   //private method that creates tag files
 580   Float_t fLowPtCut = 1.0;
 581   Float_t fHighPtCut = 3.0;
 582   Float_t fVeryHighPtCut = 10.0;
 583   ////////////
 584
 585   Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
 586
 587   // Creates the tags for all the events in a given AOD file
 588   Int_t ntrack;
 589   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
 590   Int_t nPos, nNeg, nNeutr;
 591   Int_t nKinks, nV0s, nCascades;
 592   Int_t nK0s, nNeutrons, nPi0s, nGamas;
 593   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
 594   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
 595   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
 596   Float_t maxPt = .0, meanPt = .0, totalP = .0;
 597
 598   AliRunTag *tag = new AliRunTag();
 599   TTree ttag("T","A Tree with event tags");
 600   TBranch * btag = ttag.Branch("AliTAG", &tag);
 601   btag->SetCompressionLevel(9);
 602
 603   //reading the esd tag file
 604   TChain *oldTagTree = new TChain("T");
 605   const char * tagPattern = "ESD.tag";
 606   // Open the working directory
 607   void * dirp = gSystem->OpenDirectory(gSystem->pwd());
 608   const char * name = 0x0;
 609   // Add all files matching *pattern* to the chain
 610   while((name = gSystem->GetDirEntry(dirp))) {
 611     if (strstr(name,tagPattern)) oldTagTree->Add(name);
 612   }//directory loop
 613   AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
 614
 615   //reading the esd tag file
 616   AliRunTag *oldtag = new AliRunTag();
 617   TString tagFilename;
 618   oldTagTree->SetBranchAddress("AliTAG",&oldtag);
 619   oldTagTree->GetEntry(0);
 620   tag->CopyStandardContent(oldtag);
 621   const TClonesArray *evTagList = oldtag->GetEventTags();
 622
 623   AliInfo(Form("Creating the AOD tags......."));
 624
 625   if (!file || !file->IsOpen()) {
 626     AliError(Form("opening failed"));
 627     delete file;
 628     return ;
 629   }
 630   TTree *aodTree = (TTree*)file->Get("aodTree");
 631   AliAODEvent *aod = new AliAODEvent();
 632   aod->ReadFromTree(aodTree);
 633   Int_t firstEvent = 0, lastEvent = 0;
 634   lastEvent = (Int_t)aodTree->GetEntries();
 635
 636   // loop over events
 637   Int_t nEvents = aodTree->GetEntries();
 638   for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
 639     AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);
 640     ntrack = 0;
 641     nPos = 0; nNeg = 0; nNeutr =0;
 642     nKinks = 0; nV0s = 0; nCascades = 0;
 643     nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
 644     nProtons = 0;  nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;
 645     nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
 646     nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
 647     nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
 648     maxPt = .0; meanPt = .0; totalP = .0;
 649
 650     // read events
 651     aodTree->GetEvent(iEventNumber);
 652
 653     // set pointers
 654     aod->GetStdContent();
 655
 656     Int_t nTracks = aod->GetNTracks();
 657     // loop over vertices
 658     Int_t nVtxs = aod->GetNVertices();
 659     for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
 660       // print track info
 661       AliAODVertex *vertex = aod->GetVertex(nVtx);
 662       if(vertex->GetType() == 1) nKinks += 1;
 663       if(vertex->GetType() == 2) nV0s += 1;
 664       if(vertex->GetType() == 3) nCascades += 1;
 665     }
 666     for (Int_t nTr = 0; nTr < nTracks; nTr++) {
 667       AliAODTrack *track = aod->GetTrack(nTr);
 668
 669       Double_t fPt = track->Pt();
 670       if(fPt > maxPt) maxPt = fPt;
 671       if(track->Charge() > 0) {
 672       nPos++;
 673       if(fPt > fLowPtCut) nCh1GeV++;
 674       if(fPt > fHighPtCut) nCh3GeV++;
 675       if(fPt > fVeryHighPtCut) nCh10GeV++;
 676       }
 677       if(track->Charge() < 0) {
 678       nNeg++;
 679       if(fPt > fLowPtCut) nCh1GeV++;
 680       if(fPt > fHighPtCut) nCh3GeV++;
 681       if(fPt > fVeryHighPtCut) nCh10GeV++;
 682       }
 683       if(track->Charge() == 0) nNeutr++;
 684
 685       //PID
 686       const Double32_t *prob = track->PID();
 687       Double_t rcc = 0.0;
 688       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
 689       if(rcc == 0.0) continue;
 690       //Bayes' formula
 691       Double_t w[10];
 692       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
 693
 694       //protons
 695       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
 696       //kaons
 697       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
 698       //pions
 699       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
 700       //muons
 701       if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
 702       nMuons++;
 703       if(fPt > fLowPtCut) nMu1GeV++;
 704       if(fPt > fHighPtCut) nMu3GeV++;
 705       if(fPt > fVeryHighPtCut) nMu10GeV++;
 706       }
 707       //electrons
 708       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
 709       nElectrons++;
 710       if(fPt > fLowPtCut) nEl1GeV++;
 711       if(fPt > fHighPtCut) nEl3GeV++;
 712       if(fPt > fVeryHighPtCut) nEl10GeV++;
 713       }
 714
 715       totalP += track->P();
 716       meanPt += fPt;
 717       ntrack++;
 718     }//track loop
 719     // Fill the event tags
 720     if(ntrack != 0)
 721       meanPt = meanPt/ntrack;
 722
 723     evTag->SetEventId(iEventNumber+1);
 724     evTag->SetPath(filepath);
 725
 726     evTag->SetNumOfTracks(nTracks);
 727     evTag->SetNumOfPosTracks(nPos);
 728     evTag->SetNumOfNegTracks(nNeg);
 729     evTag->SetNumOfNeutrTracks(nNeutr);
 730
 731     evTag->SetNumOfV0s(nV0s);
 732     evTag->SetNumOfCascades(nCascades);
 733     evTag->SetNumOfKinks(nKinks);
 734
 735     evTag->SetNumOfProtons(nProtons);
 736     evTag->SetNumOfKaons(nKaons);
 737     evTag->SetNumOfPions(nPions);
 738     evTag->SetNumOfMuons(nMuons);
 739     evTag->SetNumOfElectrons(nElectrons);
 740     evTag->SetNumOfPhotons(nGamas);
 741     evTag->SetNumOfPi0s(nPi0s);
 742     evTag->SetNumOfNeutrons(nNeutrons);
 743     evTag->SetNumOfKaon0s(nK0s);
 744
 745     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
 746     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
 747     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
 748     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
 749     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
 750     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
 751     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
 752     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
 753     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
 754
 755     evTag->SetTotalMomentum(totalP);
 756     evTag->SetMeanPt(meanPt);
 757     evTag->SetMaxPt(maxPt);
 758     tag->AddEventTag(*evTag);
 759   }//event loop
 760
 761   TString localFileName = "Run"; localFileName += tag->GetRunId();
 762   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_";
 763   localFileName += lastEvent; localFileName += "."; localFileName += Counter;
 764   localFileName += ".AOD.tag.root";
 765
 766   TString fileName;
 767
 768   if(fStorage == 0) {
 769     fileName = localFileName.Data();
 770     AliInfo(Form("Writing AOD tags to local file: %s",fileName.Data()));
 771   }
 772   else if(fStorage == 1) {
 773     TString alienLocation = "/alien";
 774     alienLocation += gGrid->Pwd();
 775     alienLocation += fgridpath.Data();
 776     alienLocation += "/";
 777     alienLocation +=  localFileName;
 778     alienLocation += "?se=";
 779     alienLocation += fSE.Data();
 780     fileName = alienLocation.Data();
 781     AliInfo(Form("Writing AOD tags to grid file: %s",fileName.Data()));
 782   }
 783
 784   TFile* ftag = TFile::Open(fileName, "recreate");
 785   ftag->cd();
 786   ttag.Fill();
 787   tag->Clear();
 788   ttag.Write();
 789   ftag->Close();
 790 }
 791