STEER/AliTagCreator.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 //           AliTagCreator 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 <TFile.h>
  24 #include <TString.h>
  25 #include <TTree.h>
  26 #include <TSystem.h>
  27 #include <TChain.h>
  28 #include <TLorentzVector.h>
  29
  30 //ROOT-AliEn
  31 #include <TGrid.h>
  32 #include <TGridResult.h>
  33
  34 //AliRoot
  35 #include "AliRunTag.h"
  36 #include "AliEventTag.h"
  37 #include "AliESD.h"
  38 #include "AliESDVertex.h"
  39 #include "AliLog.h"
  40
  41
  42 #include "AliTagCreator.h"
  43
  44
  45 ClassImp(AliTagCreator)
  46
  47
  48 //______________________________________________________________________________
  49 AliTagCreator::AliTagCreator() //local mode
  50 {
  51   //==============Default constructor for a AliTagCreator==================
  52   fgridpath = "";
  53   fSE = "";
  54   fStorage = 0;
  55 }
  56
  57 //______________________________________________________________________________
  58 AliTagCreator::~AliTagCreator()
  59 {
  60 //================Default destructor for a AliTagCreator=======================
  61 }
  62
  63 //______________________________________________________________________________
  64 void AliTagCreator::SetStorage(Int_t storage)
  65 {
  66   // Sets correctly the storage: 0 for local, 1 for GRID
  67   fStorage = storage;
  68   if(fStorage == 0)
  69     AliInfo(Form("Tags will be stored locally...."));
  70   if(fStorage == 1)
  71     AliInfo(Form("Tags will be stored in the grid...."));
  72   if((fStorage != 0)&&(fStorage != 1))
  73     {
  74       AliInfo(Form("Storage was not properly set!!!"));
  75       abort();
  76     }
  77 }
  78
  79
  80 //______________________________________________________________________________
  81 Bool_t AliTagCreator::ReadESDCollection(TGridResult *fresult)
  82 {
  83   // Reads the entry of the TGridResult and creates the tags
  84   Int_t nEntries = fresult->GetEntries();
  85
  86   TString alienUrl;
  87   const char *guid;
  88   const char *md5;
  89   const char *turl;
  90   Long64_t size = -1;
  91
  92   Int_t counter = 0;
  93   for(Int_t i = 0; i < nEntries; i++)
  94     {
  95       alienUrl = fresult->GetKey(i,"turl");
  96       guid = fresult->GetKey(i,"guid");
  97       if(fresult->GetKey(i,"size"))
  98         size = atol (fresult->GetKey(i,"size"));
  99       md5 = fresult->GetKey(i,"md5");
 100       turl = fresult->GetKey(i,"turl");
 101       if(md5 && !strlen(guid))
 102         md5 = 0;
 103       if(guid && !strlen(guid))
 104         guid = 0;
 105
 106       TFile *f = TFile::Open(alienUrl,"READ");
 107       CreateTag(f,guid,md5,turl,size,counter);
 108       f->Close();
 109       delete f;
 110       counter += 1;
 111     }//grid result loop
 112
 113   return kTRUE;
 114 }
 115
 116 //__________________________________________________________________________
 117 Bool_t AliTagCreator::MergeTags()
 118 {
 119   //Merges the tags and stores the merged tag file
 120   //locally if fStorage=0 or in the grid if fStorage=1
 121   AliInfo(Form("Merging tags....."));
 122   TChain *fgChain = new TChain("T");
 123
 124   if(fStorage == 0) {
 125     const char * tagPattern = "tag";
 126     // Open the working directory
 127     void * dirp = gSystem->OpenDirectory(gSystem->pwd());
 128     const char * name = 0x0;
 129     // Add all files matching *pattern* to the chain
 130     while((name = gSystem->GetDirEntry(dirp))) {
 131       if (strstr(name,tagPattern))
 132         fgChain->Add(name);
 133     }//directory loop
 134     AliInfo(Form("Chained tag files: %d",fgChain->GetEntries()));
 135   }//local mode
 136
 137   else if(fStorage == 1) {
 138     TString alienLocation = gGrid->Pwd();
 139     alienLocation += fgridpath.Data();
 140     alienLocation += "/";
 141
 142     TGridResult *tagresult = gGrid->Query(alienLocation,"*tag.root","","");
 143     Int_t nEntries = tagresult->GetEntries();
 144     for(Int_t i = 0; i < nEntries; i++) {
 145       TString alienUrl = tagresult->GetKey(i,"turl");
 146       fgChain->Add(alienUrl);
 147     }//grid result loop
 148     AliInfo(Form("Chained tag files: %d",fgChain->GetEntries()));
 149   }//grid mode
 150
 151   AliRunTag *tag = new AliRunTag;
 152   AliEventTag *evTag = new AliEventTag;
 153   fgChain->SetBranchAddress("AliTAG",&tag);
 154
 155   //Defining new tag objects
 156   AliRunTag *newTag = new AliRunTag();
 157   TTree ttag("T","A Tree with event tags");
 158   TBranch * btag = ttag.Branch("AliTAG", &newTag);
 159   btag->SetCompressionLevel(9);
 160   for(Int_t iTagFiles = 0; iTagFiles < fgChain->GetEntries(); iTagFiles++) {
 161     fgChain->GetEntry(iTagFiles);
 162     newTag->SetRunId(tag->GetRunId());
 163     const TClonesArray *tagList = tag->GetEventTags();
 164     for(Int_t j = 0; j < tagList->GetEntries(); j++) {
 165       evTag = (AliEventTag *) tagList->At(j);
 166       newTag->AddEventTag(*evTag);
 167     }
 168     ttag.Fill();
 169     newTag->Clear();
 170   }//tag file loop
 171
 172   TString localFileName = "Run"; localFileName += tag->GetRunId();
 173   localFileName += ".Merged"; localFileName += ".ESD.tag.root";
 174
 175   TString alienFileName = "/alien";
 176   alienFileName += gGrid->Pwd();
 177   alienFileName += fgridpath.Data();
 178   alienFileName += "/";
 179   alienFileName +=  localFileName;
 180   alienFileName += "?se=";
 181   alienFileName += fSE.Data();
 182
 183   TString filename = 0x0;
 184
 185   if(fStorage == 0) {
 186     filename = localFileName.Data();
 187     AliInfo(Form("Writing merged tags to local file: %s",filename.Data()));
 188   }
 189   if(fStorage == 1) {
 190     filename = alienFileName.Data();
 191     AliInfo(Form("Writing merged tags to grid file: %s",filename.Data()));
 192   }
 193
 194   TFile* ftag = TFile::Open(filename, "recreate");
 195   ftag->cd();
 196   ttag.Write();
 197   ftag->Close();
 198
 199   delete tag;
 200   delete newTag;
 201
 202   return kTRUE;
 203 }
 204
 205 //_____________________________________________________________________________
 206 void AliTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter)
 207 {
 208   /////////////
 209   //muon code//
 210   ////////////
 211   Double_t fMUONMASS = 0.105658369;
 212   //Variables
 213   Double_t fX,fY,fZ ;
 214   Double_t fThetaX, fThetaY, fPyz, fChisquare;
 215   Double_t fPxRec, fPyRec, fPzRec, fEnergy;
 216   Int_t fCharge;
 217   TLorentzVector fEPvector;
 218
 219   Float_t fZVertexCut = 10.0;
 220   Float_t fRhoVertexCut = 2.0;
 221
 222   Float_t fLowPtCut = 1.0;
 223   Float_t fHighPtCut = 3.0;
 224   Float_t fVeryHighPtCut = 10.0;
 225   ////////////
 226
 227   Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
 228
 229   // Creates the tags for all the events in a given ESD file
 230   Int_t ntrack;
 231   Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
 232   Int_t nPos, nNeg, nNeutr;
 233   Int_t nK0s, nNeutrons, nPi0s, nGamas;
 234   Int_t nCh1GeV, nCh3GeV, nCh10GeV;
 235   Int_t nMu1GeV, nMu3GeV, nMu10GeV;
 236   Int_t nEl1GeV, nEl3GeV, nEl10GeV;
 237   Float_t maxPt = .0, meanPt = .0, totalP = .0;
 238   Int_t fVertexflag;
 239   Int_t iRunNumber = 0;
 240   TString fVertexName;
 241
 242   AliRunTag *tag = new AliRunTag();
 243   AliEventTag *evTag = new AliEventTag();
 244   TTree ttag("T","A Tree with event tags");
 245   TBranch * btag = ttag.Branch("AliTAG", &tag);
 246   btag->SetCompressionLevel(9);
 247
 248   AliInfo(Form("Creating the tags......."));
 249
 250   Int_t firstEvent = 0,lastEvent = 0;
 251   TTree *t = (TTree*) file->Get("esdTree");
 252   TBranch * b = t->GetBranch("ESD");
 253   AliESD *esd = 0;
 254   b->SetAddress(&esd);
 255
 256   b->GetEntry(0);
 257   Int_t iInitRunNumber = esd->GetRunNumber();
 258
 259   Int_t iNumberOfEvents = b->GetEntries();
 260   for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
 261     ntrack = 0;
 262     nPos = 0;
 263     nNeg = 0;
 264     nNeutr =0;
 265     nK0s = 0;
 266     nNeutrons = 0;
 267     nPi0s = 0;
 268     nGamas = 0;
 269     nProtons = 0;
 270     nKaons = 0;
 271     nPions = 0;
 272     nMuons = 0;
 273     nElectrons = 0;
 274     nCh1GeV = 0;
 275     nCh3GeV = 0;
 276     nCh10GeV = 0;
 277     nMu1GeV = 0;
 278     nMu3GeV = 0;
 279     nMu10GeV = 0;
 280     nEl1GeV = 0;
 281     nEl3GeV = 0;
 282     nEl10GeV = 0;
 283     maxPt = .0;
 284     meanPt = .0;
 285     totalP = .0;
 286     fVertexflag = 1;
 287
 288     b->GetEntry(iEventNumber);
 289     iRunNumber = esd->GetRunNumber();
 290     if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
 291     const AliESDVertex * vertexIn = esd->GetVertex();
 292     fVertexName = vertexIn->GetName();
 293     if(fVertexName == "default") fVertexflag = 0;
 294
 295     for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
 296       AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
 297       UInt_t status = esdTrack->GetStatus();
 298
 299       //select only tracks with ITS refit
 300       if ((status&AliESDtrack::kITSrefit)==0) continue;
 301       //select only tracks with TPC refit
 302       if ((status&AliESDtrack::kTPCrefit)==0) continue;
 303
 304       //select only tracks with the "combined PID"
 305       if ((status&AliESDtrack::kESDpid)==0) continue;
 306       Double_t p[3];
 307       esdTrack->GetPxPyPz(p);
 308       Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
 309       Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
 310       totalP += momentum;
 311       meanPt += fPt;
 312       if(fPt > maxPt) maxPt = fPt;
 313
 314       if(esdTrack->GetSign() > 0) {
 315         nPos++;
 316         if(fPt > fLowPtCut) nCh1GeV++;
 317         if(fPt > fHighPtCut) nCh3GeV++;
 318         if(fPt > fVeryHighPtCut) nCh10GeV++;
 319       }
 320       if(esdTrack->GetSign() < 0) {
 321         nNeg++;
 322         if(fPt > fLowPtCut) nCh1GeV++;
 323         if(fPt > fHighPtCut) nCh3GeV++;
 324         if(fPt > fVeryHighPtCut) nCh10GeV++;
 325       }
 326       if(esdTrack->GetSign() == 0) nNeutr++;
 327
 328       //PID
 329       Double_t prob[5];
 330       esdTrack->GetESDpid(prob);
 331
 332       Double_t rcc = 0.0;
 333       for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
 334       if(rcc == 0.0) continue;
 335       //Bayes' formula
 336       Double_t w[5];
 337       for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
 338
 339       //protons
 340       if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
 341       //kaons
 342       if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
 343       //pions
 344       if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
 345       //electrons
 346       if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
 347         nElectrons++;
 348         if(fPt > fLowPtCut) nEl1GeV++;
 349         if(fPt > fHighPtCut) nEl3GeV++;
 350         if(fPt > fVeryHighPtCut) nEl10GeV++;
 351       }
 352       ntrack++;
 353     }//esd track loop
 354
 355     /////////////
 356     //muon code//
 357     ////////////
 358     Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
 359     // loop over all reconstructed tracks (also first track of combination)
 360     for (Int_t iTrack = 0; iTrack <  nMuonTracks;  iTrack++) {
 361       AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
 362       if (muonTrack == 0x0) continue;
 363
 364       // Coordinates at vertex
 365       fZ = muonTrack->GetZ();
 366       fY = muonTrack->GetBendingCoor();
 367       fX = muonTrack->GetNonBendingCoor();
 368
 369       fThetaX = muonTrack->GetThetaX();
 370       fThetaY = muonTrack->GetThetaY();
 371
 372       fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
 373       fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
 374       fPxRec = fPzRec * TMath::Tan(fThetaX);
 375       fPyRec = fPzRec * TMath::Tan(fThetaY);
 376       fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
 377
 378       //ChiSquare of the track if needed
 379       fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
 380       fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
 381       fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
 382
 383       // total number of muons inside a vertex cut
 384       if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
 385         nMuons++;
 386         if(fEPvector.Pt() > fLowPtCut) {
 387           nMu1GeV++;
 388           if(fEPvector.Pt() > fHighPtCut) {
 389             nMu3GeV++;
 390             if (fEPvector.Pt() > fVeryHighPtCut) {
 391               nMu10GeV++;
 392             }
 393           }
 394         }
 395       }
 396     }//muon track loop
 397
 398     // Fill the event tags
 399     if(ntrack != 0)
 400       meanPt = meanPt/ntrack;
 401
 402     evTag->SetEventId(iEventNumber+1);
 403     evTag->SetGUID(guid);
 404     evTag->SetMD5(md5);
 405     evTag->SetTURL(turl);
 406     evTag->SetSize(size);
 407     evTag->SetVertexX(vertexIn->GetXv());
 408     evTag->SetVertexY(vertexIn->GetYv());
 409     evTag->SetVertexZ(vertexIn->GetZv());
 410     evTag->SetVertexZError(vertexIn->GetZRes());
 411     evTag->SetVertexFlag(fVertexflag);
 412
 413     evTag->SetT0VertexZ(esd->GetT0zVertex());
 414
 415     evTag->SetTriggerMask(esd->GetTriggerMask());
 416     evTag->SetTriggerCluster(esd->GetTriggerCluster());
 417
 418     evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
 419     evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
 420     evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
 421     evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
 422     evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
 423     evTag->SetNumOfParticipants(esd->GetZDCParticipants());
 424
 425
 426     evTag->SetNumOfTracks(esd->GetNumberOfTracks());
 427     evTag->SetNumOfPosTracks(nPos);
 428     evTag->SetNumOfNegTracks(nNeg);
 429     evTag->SetNumOfNeutrTracks(nNeutr);
 430
 431     evTag->SetNumOfV0s(esd->GetNumberOfV0s());
 432     evTag->SetNumOfCascades(esd->GetNumberOfCascades());
 433     evTag->SetNumOfKinks(esd->GetNumberOfKinks());
 434     evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
 435
 436     evTag->SetNumOfProtons(nProtons);
 437     evTag->SetNumOfKaons(nKaons);
 438     evTag->SetNumOfPions(nPions);
 439     evTag->SetNumOfMuons(nMuons);
 440     evTag->SetNumOfElectrons(nElectrons);
 441     evTag->SetNumOfPhotons(nGamas);
 442     evTag->SetNumOfPi0s(nPi0s);
 443     evTag->SetNumOfNeutrons(nNeutrons);
 444     evTag->SetNumOfKaon0s(nK0s);
 445
 446     evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
 447     evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
 448     evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
 449     evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
 450     evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
 451     evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
 452     evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
 453     evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
 454     evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
 455
 456     evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
 457     evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
 458
 459     evTag->SetTotalMomentum(totalP);
 460     evTag->SetMeanPt(meanPt);
 461     evTag->SetMaxPt(maxPt);
 462
 463     tag->SetRunId(iInitRunNumber);
 464     tag->AddEventTag(*evTag);
 465   }//event loop
 466   lastEvent = iNumberOfEvents;
 467
 468   t->Delete("");
 469
 470   ttag.Fill();
 471   tag->Clear();
 472
 473   TString localFileName = "Run"; localFileName += tag->GetRunId();
 474   localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
 475   localFileName += ".ESD.tag.root";
 476
 477   TString alienLocation = "/alien";
 478   alienLocation += gGrid->Pwd();
 479   alienLocation += fgridpath.Data();
 480   alienLocation += "/";
 481   alienLocation +=  localFileName;
 482   alienLocation += "?se=";
 483   alienLocation += fSE.Data();
 484
 485   TString fileName;
 486
 487   if(fStorage == 0)
 488     {
 489       fileName = localFileName.Data();
 490       AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
 491     }
 492   if(fStorage == 1)
 493     {
 494       fileName = alienLocation.Data();
 495       AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
 496     }
 497
 498   TFile* ftag = TFile::Open(fileName, "recreate");
 499   ftag->cd();
 500   ttag.Write();
 501   ftag->Close();
 502
 503   delete ftag;
 504   delete esd;
 505
 506   delete tag;
 507 }
 508