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