JETAN/AliAnalysisTaskFastEmbedding.cxx

   1 /*************************************************************************
   2  *                                                                       *
   3  * Task for fast embedding                                               *
   4  * read extra input from AOD                                             *
   5  *                                                                       *
   6  *************************************************************************/
   7
   8
   9 /**************************************************************************
  10  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  11  *                                                                        *
  12  * Author: The ALICE Off-line Project.                                    *
  13  * Contributors are mentioned in the code where appropriate.              *
  14  *                                                                        *
  15  * Permission to use, copy, modify and distribute this software and its   *
  16  * documentation strictly for non-commercial purposes is hereby granted   *
  17  * without fee, provided that the above copyright notice appears in all   *
  18  * copies and that both the copyright notice and this permission notice   *
  19  * appear in the supporting documentation. The authors make no claims     *
  20  * about the suitability of this software for any purpose. It is          *
  21  * provided "as is" without express or implied warranty.                  *
  22  **************************************************************************/
  23
  24 /* $Id: */
  25
  26 #include <TFile.h>
  27 #include <TTree.h>
  28 #include <TChain.h>
  29 #include <TClonesArray.h>
  30 #include <TDirectory.h>
  31 #include <TSystem.h>
  32 #include <TRef.h>
  33 #include <TRandom3.h>
  34 #include <TH1F.h>
  35 #include <TH2F.h>
  36
  37
  38 #include "AliAnalysisTaskFastEmbedding.h"
  39 #include "AliAnalysisManager.h"
  40 #include "AliAODEvent.h"
  41 #include "AliAODTrack.h"
  42 #include "AliAODJet.h"
  43 #include "AliAODMCParticle.h"
  44
  45 #include "AliLog.h"
  46
  47 ClassImp(AliAnalysisTaskFastEmbedding)
  48
  49 //__________________________________________________________________________
  50 AliAnalysisTaskFastEmbedding::AliAnalysisTaskFastEmbedding()
  51     : AliAnalysisTaskSE()
  52       ,fAODout(0)
  53       ,fAODevent(0)
  54       ,fAODtree(0)
  55       ,fAODfile(0)
  56       ,rndm(0)
  57       ,fAODPathArray(0)
  58       ,fAODPath("AliAOD.root")
  59       ,fTrackBranch("aodExtraTracks")
  60       ,fMCparticlesBranch("aodExtraMCparticles")
  61       ,fJetBranch("")
  62       ,fEntry(0)
  63       ,fEmbedMode(0)
  64       ,fEvtSelecMode(0)
  65       ,fEvtSelMinJetPt(-1)
  66       ,fEvtSelMaxJetPt(-1)
  67       ,fToyMinNbOfTracks(1)
  68       ,fToyMaxNbOfTracks(1)
  69       ,fToyMinTrackPt(50.)
  70       ,fToyMaxTrackPt(50.)
  71       ,fToyDistributionTrackPt(0.)
  72       ,fToyMinTrackEta(-.5)
  73       ,fToyMaxTrackEta(.5)
  74       ,fToyMinTrackPhi(0.)
  75       ,fToyMaxTrackPhi(2*TMath::Pi())
  76       ,fToyFilterMap(0)
  77       ,fHistList(0)
  78       ,fh1TrackPt(0)
  79       ,fh2TrackEtaPhi(0)
  80       ,fh1TrackN(0)
  81       ,fh1MCTrackPt(0)
  82       ,fh2MCTrackEtaPhi(0)
  83       ,fh1MCTrackN(0)
  84
  85
  86 {
  87     // default constructor
  88
  89 }
  90
  91
  92 //__________________________________________________________________________
  93 AliAnalysisTaskFastEmbedding::AliAnalysisTaskFastEmbedding(const char *name)
  94     : AliAnalysisTaskSE(name)
  95       ,fAODout(0)
  96       ,fAODevent(0)
  97       ,fAODtree(0)
  98       ,fAODfile(0)
  99       ,rndm(0)
 100       ,fAODPathArray(0)
 101       ,fAODPath("AliAOD.root")
 102       ,fTrackBranch("aodExtraTracks")
 103       ,fMCparticlesBranch("aodExtraMCparticles")
 104       ,fJetBranch("")
 105       ,fEntry(0)
 106       ,fEmbedMode(0)
 107       ,fEvtSelecMode(0)
 108       ,fEvtSelMinJetPt(-1)
 109       ,fEvtSelMaxJetPt(-1)
 110       ,fToyMinNbOfTracks(1)
 111       ,fToyMaxNbOfTracks(1)
 112       ,fToyMinTrackPt(50.)
 113       ,fToyMaxTrackPt(50.)
 114       ,fToyDistributionTrackPt(0.)
 115       ,fToyMinTrackEta(-.5)
 116       ,fToyMaxTrackEta(.5)
 117       ,fToyMinTrackPhi(0.)
 118       ,fToyMaxTrackPhi(2*TMath::Pi())
 119       ,fToyFilterMap(0)
 120       ,fHistList(0)
 121       ,fh1TrackPt(0)
 122       ,fh2TrackEtaPhi(0)
 123       ,fh1TrackN(0)
 124       ,fh1MCTrackPt(0)
 125       ,fh2MCTrackEtaPhi(0)
 126       ,fh1MCTrackN(0)
 127 {
 128     // constructor
 129     DefineOutput(1, TList::Class());
 130 }
 131
 132
 133 //__________________________________________________________________________
 134 AliAnalysisTaskFastEmbedding::AliAnalysisTaskFastEmbedding(const AliAnalysisTaskFastEmbedding &copy)
 135     : AliAnalysisTaskSE()
 136       ,fAODout(copy.fAODout)
 137       ,fAODevent(copy.fAODevent)
 138       ,fAODtree(copy.fAODtree)
 139       ,fAODfile(copy.fAODfile)
 140       ,rndm(copy.rndm)
 141       ,fAODPathArray(copy.fAODPathArray)
 142       ,fAODPath(copy.fAODPath)
 143       ,fTrackBranch(copy.fTrackBranch)
 144       ,fMCparticlesBranch(copy.fMCparticlesBranch)
 145       ,fJetBranch(copy.fJetBranch)
 146       ,fEntry(copy.fEntry)
 147       ,fEmbedMode(copy.fEmbedMode)
 148       ,fEvtSelecMode(copy.fEvtSelecMode)
 149       ,fEvtSelMinJetPt(copy.fEvtSelMinJetPt)
 150       ,fEvtSelMaxJetPt(copy.fEvtSelMaxJetPt)
 151       ,fToyMinNbOfTracks(copy.fToyMinNbOfTracks)
 152       ,fToyMaxNbOfTracks(copy.fToyMaxNbOfTracks)
 153       ,fToyMinTrackPt(copy.fToyMinTrackPt)
 154       ,fToyMaxTrackPt(copy.fToyMaxTrackPt)
 155       ,fToyDistributionTrackPt(copy.fToyDistributionTrackPt)
 156       ,fToyMinTrackEta(copy.fToyMinTrackEta)
 157       ,fToyMaxTrackEta(copy.fToyMaxTrackEta)
 158       ,fToyMinTrackPhi(copy.fToyMinTrackPhi)
 159       ,fToyMaxTrackPhi(copy.fToyMaxTrackPhi)
 160       ,fToyFilterMap(copy.fToyFilterMap)
 161       ,fHistList(copy.fHistList)
 162       ,fh1TrackPt(copy.fh1TrackPt)
 163       ,fh2TrackEtaPhi(copy.fh2TrackEtaPhi)
 164       ,fh1TrackN(copy.fh1TrackN)
 165       ,fh1MCTrackPt(copy.fh1MCTrackPt)
 166       ,fh2MCTrackEtaPhi(copy.fh2MCTrackEtaPhi)
 167       ,fh1MCTrackN(copy.fh1MCTrackN)
 168 {
 169     // copy constructor
 170 }
 171
 172
 173 //__________________________________________________________________________
 174 AliAnalysisTaskFastEmbedding& AliAnalysisTaskFastEmbedding::operator=(const AliAnalysisTaskFastEmbedding& o)
 175 {
 176     // assignment
 177
 178     if(this!=&o){
 179         AliAnalysisTaskSE::operator=(o);
 180         fAODout            = o.fAODout;
 181         fAODevent          = o.fAODevent;
 182         fAODtree           = o.fAODtree;
 183         fAODfile           = o.fAODfile;
 184         rndm               = o.rndm;
 185         fAODPathArray       = o.fAODPathArray;
 186         fAODPath           = o.fAODPath;
 187         fTrackBranch       = o.fTrackBranch;
 188         fMCparticlesBranch = o.fMCparticlesBranch;
 189         fJetBranch         = o.fJetBranch;
 190         fEntry             = o.fEntry;
 191         fEmbedMode         = o.fEmbedMode;
 192         fEvtSelecMode      = o.fEvtSelecMode;
 193         fEvtSelMinJetPt    = o.fEvtSelMinJetPt;
 194         fEvtSelMaxJetPt    = o.fEvtSelMaxJetPt;
 195         fToyMinNbOfTracks  = o.fToyMinNbOfTracks;
 196         fToyMaxNbOfTracks  = o.fToyMaxNbOfTracks;
 197         fToyMinTrackPt     = o.fToyMinTrackPt;
 198         fToyMaxTrackPt     = o.fToyMaxTrackPt;
 199         fToyDistributionTrackPt = o.fToyDistributionTrackPt;
 200         fToyMinTrackEta    = o.fToyMinTrackEta;
 201         fToyMaxTrackEta    = o.fToyMaxTrackEta;
 202         fToyMinTrackPhi    = o.fToyMinTrackPhi;
 203         fToyMaxTrackPhi    = o.fToyMaxTrackPhi;
 204         fToyFilterMap      = o.fToyFilterMap;
 205         fHistList          = o.fHistList;
 206         fh1TrackPt         = o.fh1TrackPt;
 207         fh2TrackEtaPhi     = o.fh2TrackEtaPhi;
 208         fh1TrackN          = o.fh1TrackN;
 209         fh1MCTrackPt       = o.fh1MCTrackPt;
 210         fh2MCTrackEtaPhi   = o.fh2MCTrackEtaPhi;
 211         fh1MCTrackN        = o.fh1MCTrackN;
 212     }
 213
 214     return *this;
 215 }
 216
 217
 218 //__________________________________________________________________________
 219 AliAnalysisTaskFastEmbedding::~AliAnalysisTaskFastEmbedding()
 220 {
 221     // destructor
 222     delete rndm;
 223 }
 224
 225
 226 //__________________________________________________________________________
 227 void AliAnalysisTaskFastEmbedding::UserCreateOutputObjects()
 228 {
 229     // create output objects
 230     if(fDebug > 1) Printf("AliAnalysisTaskFastEmbedding::UserCreateOutputObjects()");
 231
 232     rndm = new TRandom3();
 233     Int_t id = GetJobID();
 234     if(id>-1) rndm->SetSeed(id);
 235     else      rndm->SetSeed();   // a TTUID is generated and used for seed
 236     AliInfo(Form("TRandom3 seed: %d", rndm->GetSeed()));
 237
 238
 239     // embed mode with AOD
 240     if(fEmbedMode==kAODFull || fEmbedMode==kAODJetTracks || fEmbedMode==kAODJet4Mom){
 241
 242        // open input AOD
 243        if(fAODPathArray){
 244            Int_t rc = SelectAODfile();
 245            if(rc<0) return;
 246        }
 247
 248        Int_t rc = OpenAODfile();
 249        if(rc<0) return;
 250
 251     } //end: embed mode with AOD
 252
 253
 254     // connect output aod
 255     // create a new branch for extra tracks
 256     fAODout = AODEvent();
 257     if(!fAODout){
 258         AliError("Output AOD not found.");
 259         return;
 260     }
 261     if(!fAODout->FindListObject(fTrackBranch.Data()) && strlen(fTrackBranch.Data())){
 262         AliInfo(Form("Add AOD branch %s", fTrackBranch.Data()));
 263         TClonesArray *tracks = new TClonesArray("AliAODTrack",0);
 264         tracks->SetName(fTrackBranch.Data());
 265         AddAODBranch("TClonesArray", &tracks);
 266     }
 267     // create new branch for extra mcparticle if available as input
 268     if(fAODevent && fAODevent->FindListObject("mcparticles") && strlen(fMCparticlesBranch.Data())){
 269        AliInfo(Form("Add AOD branch %s", fMCparticlesBranch.Data()));
 270        TClonesArray *mcparticles = new TClonesArray("AliAODMCParticle",0);
 271        mcparticles->SetName(fMCparticlesBranch.Data());
 272        AddAODBranch("TClonesArray", &mcparticles);
 273     }
 274
 275
 276
 277
 278     //qa histograms
 279
 280     OpenFile(1);
 281     fHistList = new TList();
 282
 283     Bool_t oldStatus = TH1::AddDirectoryStatus();
 284     TH1::AddDirectory(kFALSE);
 285
 286     fh1TrackPt      =  new TH1F("fh1TrackPt","pT of extra tracks;p_{T};entries", 300, 0., 300.);
 287     fh2TrackEtaPhi  =  new TH2F("fh2TrackEtaPhi","eta-phi distribution of extra tracks;#eta;#phi", 20, -1., 1., 60, 0., 2*TMath::Pi());
 288     fh1TrackN       =  new TH1F("fh1TrackN", "nb. of extra tracks per event;nb. of tracks;entries",300, 0., 3000.);
 289
 290     fHistList->Add(fh1TrackPt);
 291     fHistList->Add(fh2TrackEtaPhi);
 292     fHistList->Add(fh1TrackN);
 293
 294
 295     if(fAODevent && fAODevent->FindListObject("mcparticles") && strlen(fMCparticlesBranch.Data())){
 296
 297        fh1MCTrackPt      =  new TH1F("fh1MCTrackPt","pT of MC extra tracks;p_{T};entries", 300, 0., 300.);
 298        fh2MCTrackEtaPhi  =  new TH2F("fh2MCTrackEtaPhi","eta-phi distribution of MC extra tracks;#eta;#phi", 20, -1., 1., 60, 0., 2*TMath::Pi());
 299        fh1MCTrackN       =  new TH1F("fh1MCTrackN", "nb. of MC extra tracks per event;nb. of tracks;entries",300, 0., 3000.);
 300
 301        fHistList->Add(fh1MCTrackPt);
 302        fHistList->Add(fh2MCTrackEtaPhi);
 303        fHistList->Add(fh1MCTrackN);
 304
 305     }
 306
 307     TH1::AddDirectory(oldStatus);
 308
 309 }
 310
 311
 312 //__________________________________________________________________________
 313 void AliAnalysisTaskFastEmbedding::Init()
 314 {
 315     // Initialization
 316     if(fDebug > 1) Printf("AliAnalysisTaskFastEmbedding::Init()");
 317
 318 }
 319
 320
 321 //__________________________________________________________________________
 322 void AliAnalysisTaskFastEmbedding::UserExec(Option_t *)
 323 {
 324     if(fDebug > 1) Printf("AliAnalysisTaskFastEmbedding::UserExec()");
 325
 326     if(!fAODout){
 327        AliError("Need output AOD, but is not connected.");
 328        return;
 329     }
 330
 331     // connect aod out
 332     TClonesArray *tracks = (TClonesArray*)(fAODout->FindListObject(fTrackBranch.Data()));
 333     if(!tracks){
 334         AliError("Extra track branch not found in output.");
 335         return;
 336     }
 337     tracks->Delete();
 338     Int_t nAODtracks=0;
 339
 340
 341     TRef dummy;
 342
 343     // === embed mode with AOD ===
 344     if(fEmbedMode==kAODFull || fEmbedMode==kAODJetTracks || fEmbedMode==kAODJet4Mom){
 345        if(!fAODevent){
 346           AliError("Need input AOD, but is not connected.");
 347           return;
 348        }
 349
 350        // fetch jets
 351        TClonesArray *aodJets = 0;
 352        if(fJetBranch.Length()) aodJets = dynamic_cast<TClonesArray*>(fAODevent->FindListObject(fJetBranch.Data()));
 353        else                    aodJets = fAODevent->GetJets();
 354        if(!aodJets){
 355           AliError("Could not find jets in AOD. Check jet branch when indicated.");
 356           return;
 357        }
 358
 359
 360        Int_t nEvents = fAODtree->GetEntries();
 361
 362        Bool_t useEntry = kFALSE;
 363        while(!useEntry){  // protection need, if no event fulfills requierment
 364           if(fEntry>=nEvents){
 365               fEntry=0;
 366               if(!fAODPathArray){
 367                  AliDebug(AliLog::kDebug, "Last event in AOD reached, start from entry 0 again.");
 368               }
 369               else {
 370                  AliDebug(AliLog::kDebug, "Last event in AOD reached, select new AOD file ...");
 371                  Int_t rc = SelectAODfile();
 372                  if(rc<0) return;
 373
 374                  rc = OpenAODfile();
 375                  if(rc<0) return;
 376
 377                  // new file => we must use the new jet array
 378                  if(fJetBranch.Length()) aodJets = dynamic_cast<TClonesArray*>(fAODevent->FindListObject(fJetBranch.Data()));
 379                  else                    aodJets = fAODevent->GetJets();
 380                  if(!aodJets){
 381                    AliError("Could not find jets in AOD. Check jet branch when indicated.");
 382                    return;
 383                  }
 384               }
 385           }
 386
 387           fAODtree->GetEvent(fEntry);
 388
 389           // jet pt selection
 390           if(fEvtSelecMode==kEventsJetPt){
 391              Int_t nJets = aodJets->GetEntries();
 392              for(Int_t ij=0; ij<nJets; ++ij){
 393                  AliAODJet *jet = dynamic_cast<AliAODJet*>(aodJets->At(ij));
 394                  if(!jet) continue;
 395
 396                  if(   (fEvtSelMinJetPt==-1. || jet->Pt()>=fEvtSelMinJetPt)
 397                     && (fEvtSelMaxJetPt==-1. || jet->Pt()<=fEvtSelMaxJetPt)){
 398                     useEntry = kTRUE;
 399                     break;
 400                  }
 401              }
 402           }
 403
 404           // no selection
 405           if(fEvtSelecMode==kEventsAll){
 406              useEntry = kTRUE;
 407           }
 408
 409           fEntry++;
 410        }
 411        AliInfo(Form("Use entry %d from extra AOD.", fEntry-1));
 412
 413
 414        TClonesArray *mcpartIN  = (TClonesArray*)(fAODevent->FindListObject("mcparticles"));
 415        TClonesArray *mcpartOUT = 0x0;
 416        if(mcpartIN){
 417            mcpartOUT = (TClonesArray*)(fAODout->FindListObject(fMCparticlesBranch.Data()));
 418            mcpartOUT->Delete();
 419        } else {
 420            AliInfo("No extra MC particles found.");
 421        }
 422
 423
 424        if(fEmbedMode==kAODFull || fEmbedMode==kAODJetTracks){ // take all tracks or jet tracks
 425            // loop over input tracks
 426            // add to output aod
 427            Int_t nTracks = fAODevent->GetNumberOfTracks();
 428            fh1TrackN->Fill((Float_t)nTracks);
 429
 430            for(Int_t it=0; it<nTracks; ++it){
 431                AliAODTrack *tmpTr = fAODevent->GetTrack(it);
 432                // ?? test filter bit, or something else??
 433
 434                if(fEmbedMode==kAODJetTracks){
 435                   // jet track? else continue
 436                   // not implemented yet
 437                   continue;
 438                }
 439
 440                new ((*tracks)[nAODtracks++]) AliAODTrack(*tmpTr);
 441                dummy = (*tracks)[nAODtracks-1];
 442
 443                fh1TrackPt->Fill(tmpTr->Pt());
 444                fh2TrackEtaPhi->Fill(tmpTr->Eta(), tmpTr->Phi());
 445            }
 446
 447            if(mcpartIN){
 448                Int_t nMCpart = mcpartIN->GetEntriesFast();
 449
 450                Int_t nPhysicalPrimary=0;
 451                Int_t nAODmcpart=0;
 452                for(Int_t ip=0; ip<nMCpart; ++ip){
 453                    AliAODMCParticle *tmpPart = (AliAODMCParticle*) mcpartIN->At(ip);
 454
 455                    if(fEmbedMode==kAODJetTracks){
 456                       // jet track? else continue
 457                       // not implemented yet
 458                       continue;
 459                    }
 460
 461                    new((*mcpartOUT)[nAODmcpart++]) AliAODMCParticle(*tmpPart);
 462                    dummy = (*mcpartOUT)[nAODmcpart-1];
 463
 464                    if(tmpPart->IsPhysicalPrimary() && tmpPart->Charge()!=0. && tmpPart->Charge()!=-99. ){
 465                       fh1MCTrackPt->Fill(tmpPart->Pt());
 466                       fh2MCTrackEtaPhi->Fill(tmpPart->Eta(), tmpPart->Phi());
 467                       nPhysicalPrimary++;
 468                    }
 469                }
 470                fh1MCTrackN->Fill((Float_t)nPhysicalPrimary);
 471
 472            }
 473        } // end: embed all tracks or jet tracks
 474
 475
 476        if(fEmbedMode==kAODJet4Mom){
 477
 478            // loop over jets
 479            Int_t nJets = aodJets->GetEntries();
 480            fh1TrackN->Fill((Float_t)nJets);
 481            for(Int_t ij=0; ij<nJets; ++ij){
 482                AliAODJet *jet = dynamic_cast<AliAODJet*>(aodJets->At(ij));
 483                if(!jet) continue;
 484                AliAODTrack *tmpTr = (AliAODTrack*)jet;
 485
 486                new ((*tracks)[nAODtracks++]) AliAODTrack(*tmpTr);
 487                dummy = (*tracks)[nAODtracks-1];
 488
 489                fh1TrackPt->Fill(tmpTr->Pt());
 490                fh2TrackEtaPhi->Fill(tmpTr->Eta(), tmpTr->Phi());
 491            }
 492
 493        } // end: embed jets as 4-momenta
 494
 495
 496     } //end: embed mode with AOD
 497
 498
 499     // === embed mode with toy ===
 500     if(fEmbedMode==kToyTracks){
 501         Int_t nT = (Int_t)(rndm->Uniform(fToyMinNbOfTracks, fToyMaxNbOfTracks)+0.5);
 502
 503         fh1TrackN->Fill((Float_t)nT);
 504
 505         for(Int_t i=0; i<nT; ++i){
 506
 507            Double_t pt = -1.;
 508            if(fToyMinTrackPt!=fToyMaxTrackPt){
 509               if(fToyDistributionTrackPt==0){
 510                  pt = rndm->Uniform(fToyMinTrackPt, fToyMaxTrackPt);
 511               } else {
 512                  while(pt<fToyMinTrackPt||pt>fToyMaxTrackPt){
 513                     pt = rndm->Exp(fToyDistributionTrackPt);   // no power law yet!!
 514                     pt += fToyMinTrackPt;
 515                  }
 516               }
 517            } else {
 518               pt = fToyMinTrackPt;
 519            }
 520            Double_t eta = rndm->Uniform(fToyMinTrackEta,fToyMaxTrackEta);
 521            Double_t phi = rndm->Uniform(fToyMinTrackPhi,fToyMaxTrackPhi);
 522            phi = TVector2::Phi_0_2pi(phi);
 523
 524            Printf("Add track #%d: pt %.2f, eta %.2f, phi %.2f", i, pt, eta, phi);
 525
 526            Double_t theta = 2*TMath::ATan(1/TMath::Exp(eta));
 527            Float_t mom[3];
 528            mom[0] = pt;
 529            mom[1] = phi;
 530            mom[2] = theta;
 531
 532            Float_t xyz[3];
 533            xyz[0] = -999.;
 534            xyz[1] = -999.;
 535            xyz[2] = -999.;
 536
 537            AliAODTrack *tmpTr = new AliAODTrack( -999,   // id
 538                                               -999,   // label
 539                                               mom,    // momentum[3]
 540                                               kFALSE, // cartesian
 541                                               xyz,    // position
 542                                               kFALSE, // DCA
 543                                               NULL,   // covMatrix,
 544                                               -99,    // charge
 545                                               0,      // itsClusMap
 546                                               NULL,   // pid
 547                                               NULL,   // prodVertex
 548                                               kFALSE, // used for vertex fit
 549                                               kFALSE, // used for prim vtx fit
 550                                               AliAODTrack::kUndef, // type
 551                                               fToyFilterMap,  // select info
 552                                               -999.    // chi2 per NDF
 553                                             );
 554            tmpTr->SetFlags(1<<27);
 555
 556            new((*tracks)[nAODtracks++]) AliAODTrack(*tmpTr);
 557            dummy = (*tracks)[nAODtracks-1];
 558
 559            fh1TrackPt->Fill(pt);
 560            fh2TrackEtaPhi->Fill(eta,phi);
 561
 562            delete tmpTr;
 563         }
 564     } //end: embed mode with toy
 565
 566
 567     PostData(1, fHistList);
 568 }
 569
 570
 571 //__________________________________________________________________________
 572 void AliAnalysisTaskFastEmbedding::Terminate(Option_t *)
 573 {
 574     if(fDebug > 1) Printf("AliAnalysisTaskFastEmbedding::Terminate()");
 575
 576     if(fAODfile && fAODfile->IsOpen())
 577     fAODfile->Close();
 578
 579 }
 580
 581 //__________________________________________________________________________
 582 Int_t AliAnalysisTaskFastEmbedding::GetJobID()
 583 {
 584    Int_t id=-1;
 585
 586    const char* env = gSystem->Getenv("ALIEN_PROC_ID"); // GRID
 587    //if(!env || !strlen(env)) env = gSystem->Getenv("LSB_JOBINDEX"); // GSI
 588
 589    if(env && strlen(env)){
 590        id= atoi(env);
 591        AliInfo(Form("Job index %d", id));
 592    }
 593    else{
 594        AliInfo("Job index not found. Okay if running locally.");
 595    }
 596
 597    return id;
 598 }
 599
 600 //__________________________________________________________________________
 601
 602 Int_t AliAnalysisTaskFastEmbedding::SelectAODfile(){
 603
 604      Int_t nFiles = fAODPathArray->GetEntries();
 605      Int_t n = rndm->Integer(nFiles);
 606      AliInfo(Form("Select AOD file %d", n));
 607      TObjString *objStr = (TObjString*) fAODPathArray->At(n);
 608      if(!objStr){
 609           AliError("Could not get path of aod file.");
 610           return -1;
 611      }
 612      fAODPath = objStr->GetString();
 613
 614      return n;
 615 }
 616
 617 Int_t AliAnalysisTaskFastEmbedding::OpenAODfile(){
 618
 619     TDirectory *owd = gDirectory;
 620     if (fAODfile)
 621       fAODfile->Close();
 622     fAODfile = TFile::Open(fAODPath.Data());
 623     owd->cd();
 624     if(!fAODfile){
 625        AliError("Could not open AOD file.");
 626        return -1;
 627     }
 628
 629     fAODtree = (TTree*)fAODfile->Get("aodTree");
 630
 631     if(!fAODtree){
 632        AliError("AOD tree not found.");
 633        return -1;
 634     }
 635
 636     delete fAODevent;
 637     fAODevent = new AliAODEvent();
 638     fAODevent->ReadFromTree(fAODtree);
 639     return 1;
 640 }
 641