PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 //______________________________________________________________________________
  17 // Analysis task for high pt particle correlations
  18 // author: R.Diaz, J. Rak,  D.J. Kim
  19 // ALICE Group University of Jyvaskyla
  20 // Finland
  21 // Fill the analysis containers for ESD or AOD
  22 // Adapted for AliAnalysisTaskSE and AOD objects
  23 //////////////////////////////////////////////////////////////////////////////
  24
  25
  26 #include <Riostream.h>
  27 #include <TChain.h>
  28 #include <TVectorT.h>
  29 #include <TVector3.h>
  30 #include <TFile.h>
  31 #include <TH1.h>
  32 #include <TClonesArray.h>
  33 #include <TObjArray.h>
  34 #include <TObjString.h>
  35 #include <TFormula.h>
  36 #include <TString.h>
  37 #include <TRefArray.h>
  38 #include <TNtuple.h>
  39
  40 #include "AliAnalysisTaskSE.h"
  41 #include "AliAODHandler.h"
  42
  43 #include "AliJCORRANTask.h"
  44 #include "AliAnalysisManager.h"
  45 #include "AliESDEvent.h"
  46 #include "AliMCEvent.h"
  47 #include "AliStack.h"
  48 #include "AliGenEventHeader.h"
  49 #include "AliGenCocktailEventHeader.h"
  50 #include "AliGenPythiaEventHeader.h"
  51 #include "AliInputEventHandler.h"
  52 #include "AliESDCaloCluster.h"
  53 #include "AliAODEvent.h"
  54 #include "AliAODHeader.h"
  55 #include "AliLog.h"
  56 #include "AliESDVertex.h"
  57 #include "AliESDtrack.h"
  58 #include "AliAODTrack.h"
  59 #include "AliAnalysisFilter.h"
  60 #include "AliESDtrackCuts.h"
  61 #include "AliAODVertex.h"
  62 #include "AliAODTracklets.h"
  63 #include "AliAODPid.h"
  64 #include "AliESDUtils.h"
  65 //#include "AliESDVZERO.h"
  66 #include "AliCentrality.h"
  67 #include "AliAODTracklets.h"
  68 #include "AliMultiplicity.h"
  69 #include "AliJConst.h"
  70 #include "AliESDRun.h"
  71 #include "AliESDVZERO.h"
  72 #include "AliExternalTrackParam.h"
  73 //== EMCAL
  74 #include "AliESDCaloCluster.h"
  75 #include "AliEMCALGeometry.h"
  76 #include "AliVCluster.h"
  77 #include "AliVCaloCells.h"
  78 #include "AliEMCALRecoUtils.h"
  79 #include "AliEMCALPIDUtils.h"
  80
  81 #include "AliJTrack.h"
  82 #include "AliJMCTrack.h"
  83 #include "AliJPhoton.h"
  84 #include "AliJEventHeader.h"
  85 #include "AliJRunHeader.h"
  86
  87 //______________________________________________________________________________
  88 AliJCORRANTask::AliJCORRANTask() :
  89     AliAnalysisTaskSE("PWG4JCORRAN"),
  90     fRunType("LHC10h"), // enable filling EP info
  91     fInputFormat("ESD"),
  92     fEsdTrackCuts(0x0),
  93     fESDFilter(0x0),
  94     fIsRealOrMC(),
  95     fAODName("jcorran.root"),
  96     fStoreEventPlaneSource(false),
  97     fStoreTPCTrack(false),
  98     fOADBPath(),
  99     fTrackList(0),
 100     fMCTrackList(0x0),
 101     fPhotonList(0x0),
 102     fHeaderList(0x0),
 103     fRunInfoList(0x0),
 104     fPIDesd(0x0),
 105     fPIDResponse(0x0),
 106     fPIDCombined(0x0),
 107     fVZEROData(0x0),
 108     fTZEROData(0x0),
 109     //fFMDData(0x0),
 110     fZDCData(0x0),
 111     fAliRunHeader(0x0),
 112     fEMCALGeoUtils(0x0),
 113     fPHOSGeom(0x0)
 114 {
 115   //Default constructor
 116   for(Int_t i=0;i<kRangeTriggerTableAlice;i++)   fActiveTriggers[i]=" ";
 117   for(Int_t i=0;i<kRangeTriggerTableJCorran;i++) fTriggerTableJCorran[i]=" ";
 118
 119   fIsRealOrMC.ResizeTo(1);
 120   fIsRealOrMC[0]=0;
 121
 122   DefineInput (0, TChain::Class());
 123   DefineInput (1, TList::Class());
 124   DefineOutput (1, TList::Class());
 125   //  DefineOutput (2, TList::Class());
 126 }
 127
 128 //______________________________________________________________________________
 129 AliJCORRANTask::AliJCORRANTask(const char *name, TString inputformat):
 130     AliAnalysisTaskSE(name),
 131     fRunType("LHC10h"), // enable filling EP info
 132     fInputFormat(inputformat),
 133     fEsdTrackCuts(0x0),
 134     fESDFilter(0x0),
 135     fIsRealOrMC(),
 136     fAODName("jcorran.root"),
 137     fStoreEventPlaneSource(false),
 138     fStoreTPCTrack(false),
 139     fOADBPath(),
 140     fTrackList(0),
 141     fMCTrackList(0x0),
 142     fPhotonList(0x0),
 143     fHeaderList(0x0),
 144     fRunInfoList(0x0),
 145     fPIDesd(0x0),
 146     fPIDResponse(0x0),
 147     fPIDCombined(0x0),
 148     fVZEROData(0x0),
 149     fTZEROData(0x0),
 150     //fFMDData(0x0),
 151     fZDCData(0x0),
 152     fAliRunHeader(0x0),
 153     fEMCALGeoUtils(0x0),
 154     fPHOSGeom(0x0)
 155 {
 156   // Constructor
 157   if(fDebug > 5) cout << "---- AliJCORRANTask Constructor ----"<<endl;
 158
 159   for(Int_t i=0;i<kRangeTriggerTableAlice;i++)   fActiveTriggers[i]=" ";
 160   for(Int_t i=0;i<kRangeTriggerTableJCorran;i++) fTriggerTableJCorran[i]=" ";
 161
 162   fIsRealOrMC.ResizeTo(1);
 163
 164   fIsRealOrMC[0]=0;
 165
 166   DefineInput (0, TChain::Class());
 167   //  DefineInput (1, TList::Class());
 168   DefineOutput (1, TList::Class());
 169   //  DefineOutput (2, TList::Class());
 170 }
 171
 172 //____________________________________________________________________________
 173 AliJCORRANTask::AliJCORRANTask(const AliJCORRANTask& ap) :
 174     AliAnalysisTaskSE(ap.GetName()),
 175     fRunType(ap.fRunType),
 176     fInputFormat(ap.fInputFormat),
 177     fEsdTrackCuts(ap.fEsdTrackCuts),
 178     fESDFilter(ap.fESDFilter),
 179     fIsRealOrMC(ap.fIsRealOrMC),
 180     fAODName(ap.fAODName),
 181     fStoreEventPlaneSource(ap.fStoreEventPlaneSource),
 182     fStoreTPCTrack(ap.fStoreTPCTrack),
 183     fOADBPath(ap.fOADBPath),
 184     fTrackList(ap.fTrackList),
 185     fMCTrackList(ap.fMCTrackList),
 186     fPhotonList(ap.fPhotonList),
 187     fHeaderList(ap.fHeaderList),
 188     fRunInfoList(ap.fRunInfoList),
 189     fPIDesd(ap.fPIDesd),
 190     fPIDResponse(ap.fPIDResponse),
 191     fPIDCombined(ap.fPIDCombined),
 192     fVZEROData(ap.fVZEROData),
 193     fTZEROData(ap.fTZEROData),
 194     //fFMDData(ap.fFMDData),
 195     fZDCData(ap.fZDCData),
 196     fAliRunHeader(ap.fAliRunHeader),
 197     fEMCALGeoUtils(ap.fEMCALGeoUtils),
 198     fPHOSGeom(ap.fPHOSGeom)
 199 {
 200   // cpy ctor
 201   for(int k=0; k < kRangeTriggerTableAlice; k++)
 202     fActiveTriggers[k] = ap.fActiveTriggers[k];
 203
 204   for(int j=0; j < kRangeTriggerTableJCorran; j++)
 205     fTriggerTableJCorran[j] = ap.fTriggerTableJCorran[j];
 206
 207   fIsRealOrMC.ResizeTo(1);
 208
 209   fIsRealOrMC[0]                    = ap.fIsRealOrMC[0];
 210
 211 }
 212
 213 //_____________________________________________________________________________
 214 AliJCORRANTask& AliJCORRANTask::operator = (const AliJCORRANTask& ap)
 215 {
 216   // assignment operator
 217
 218   this->~AliJCORRANTask();
 219   new(this) AliJCORRANTask(ap);
 220   return *this;
 221 }
 222
 223 //______________________________________________________________________________
 224 AliJCORRANTask::~AliJCORRANTask()
 225 {
 226   // destructor
 227   delete fTrackList;
 228   delete fMCTrackList;
 229   delete fPhotonList;
 230   delete fHeaderList;
 231   delete fAliRunHeader;
 232   delete fRunInfoList;
 233   delete fPIDesd;
 234   delete fOADBPath;
 235   delete fPIDResponse;
 236   delete fPIDCombined;
 237   delete fEMCALGeoUtils;
 238   delete fPHOSGeom;
 239   delete fVZEROData;
 240   delete fTZEROData;
 241   delete fZDCData;
 242   //  delete fFMDData;
 243
 244
 245 }
 246
 247 //________________________________________________________________________
 248
 249 void AliJCORRANTask::UserCreateOutputObjects()
 250 {
 251   //=== create the jcorran outputs objects
 252   if(fDebug > 1) printf("AliJCORRANTask::UserCreateOutPutData() \n");
 253
 254   //=== Get AnalysisManager
 255   AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager();
 256   if(!man->GetOutputEventHandler()) {
 257     Fatal("UserCreateOutputObjects", "This task needs an AOD handler");
 258     return;
 259   }
 260   man->RegisterExtraFile(fAODName.Data());
 261
 262   //=== Other Objects
 263   fEMCALGeoUtils = AliEMCALGeometry::GetInstance("EMCAL_COMPLETE");
 264   fPHOSGeom = new AliPHOSGeoUtils();
 265
 266   //=== Set Tree and TClonesArray
 267   //== TRACKS
 268   AddListAODBranch("AliJTrackList", "AliJTrack", &fTrackList, 1000);
 269   AddListAODBranch("AliJPhotonList", "AliJPhoton", &fPhotonList, 1000);
 270   if((bool)fIsRealOrMC[0])
 271     AddListAODBranch("AliJTMCrackList", "AliJMCTrack", &fMCTrackList, 1000);
 272   //== Event Header
 273   AddListAODBranch("AliJEventHeaderList", "AliJEventHeader", &fHeaderList, 1000);
 274   //== RUN HEADER
 275   fAliRunHeader = new AliJRunHeader();
 276   fRunInfoList  = new TList();
 277   fRunInfoList->SetName("RunInfoList");
 278   fRunInfoList->SetOwner();
 279   fRunInfoList->Clear();
 280   fRunInfoList->Add(fAliRunHeader);
 281   //== EventPlane SRC
 282   if( fStoreEventPlaneSource ){
 283     fVZEROData = new AliESDVZERO;
 284     fTZEROData = new AliESDTZERO;
 285     fZDCData   = new AliESDZDC;
 286     AddAODBranch("AliESDVZERO", &fVZEROData,  fAODName.Data());
 287     AddAODBranch("AliESDTZERO", &fTZEROData,  fAODName.Data());
 288     AddAODBranch("AliESDZDC",   &fZDCData,    fAODName.Data());
 289   }
 290   //== PID
 291   fPIDesd = new AliESDpid;
 292   fPIDCombined = new AliPIDCombined;
 293   fPIDCombined->SetDefaultTPCPriors();
 294   fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF);
 295   fPIDResponse = ((AliInputEventHandler*) (man->GetInputEventHandler()))->GetPIDResponse();
 296   fPIDResponse->SetOADBPath(AliAnalysisManager::GetOADBPath());
 297   if (!fOADBPath.IsNull()) fPIDResponse->SetOADBPath(fOADBPath.Data());
 298
 299   cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl;
 300   PostData(1,fRunInfoList);
 301
 302 }
 303
 304 //______________________________________________________________________________
 305 void AliJCORRANTask::UserExec(Option_t* /*option*/)
 306 {
 307
 308   // Processing of one event
 309   if(fDebug > 5) cout << "------- AliJCORRANTask Exec-------"<<endl;
 310   if(!((Entry()-1)%100))  AliInfo(Form(" Processing event # %lld",  Entry()));
 311
 312   //=== Init Variables
 313   fTrackList->Clear();
 314   if((bool)fIsRealOrMC[0]) fMCTrackList->Clear();
 315   fPhotonList->Clear();
 316   fHeaderList->Clear();
 317
 318   //=== COMMON for ESD and AOD
 319   static int runId=-1;
 320   AliVEvent *event = InputEvent();
 321   if(!event) return;
 322   AliMCEvent* mcEvent = NULL;
 323   if((bool)fIsRealOrMC[0])  mcEvent = MCEvent();
 324   // RUN Header
 325   if(event->GetRunNumber() != runId){ //new run has started
 326     runId = event->GetRunNumber();
 327     //Polarity of magnetic field in L3 solenoid
 328     Short_t l3MgFieldPolarity=0; // (LHC convention: +current -> +Bz)
 329     //Create internal JCorran trigger mask.  Mapping between trigger and trigger bit
 330     fTriggerTableJCorran[kMinBiasTriggerBitJCorran]="Minimum Bias";//minimum bias occupies first trigger bit
 331     fTriggerTableJCorran[kHighMultTriggerBitJCorran]="High Multiplicity";//high multiplicity trigger => second trigger bit
 332     //=========== Fill Run header object ===============
 333     fAliRunHeader->SetRunNumber(runId);
 334     fAliRunHeader->SetActiveTriggersJCorran(fTriggerTableJCorran,kRangeTriggerTableJCorran);
 335     SetAliceTriggerDef(fAliRunHeader);//TODO for AOD
 336     SetAliceFilterMapDef(fAliRunHeader);// TODO for AOD
 337     //FOR ESD
 338     if(fInputFormat=="ESD"){
 339       AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
 340       if(!esd) return;
 341       if(esd->GetCurrentL3() >0) l3MgFieldPolarity =  1;
 342       if(esd->GetCurrentL3() <0) l3MgFieldPolarity = -1;
 343       fAliRunHeader->SetL3Field(l3MgFieldPolarity, esd->GetMagneticField());
 344       const AliESDRun* esdRun = esd->GetESDRun();
 345       for(Int_t triggerBit=0; triggerBit<kRangeTriggerTableAlice; triggerBit++){
 346         fActiveTriggers[triggerBit] = esdRun->GetTriggerClass(triggerBit);
 347       }
 348       fAliRunHeader->SetActiveTriggersAlice(fActiveTriggers);
 349     }
 350     fRunInfoList->Add(fAliRunHeader);
 351     cout << "Add(fAliRunHeader) is done =============" << endl;
 352   }
 353
 354   //=== If ESD or AOD
 355   if(fInputFormat=="ESD"){   //Reading ESD
 356     if(fDebug > 5) cout << "\t------- Start ESD "<<endl;
 357     AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
 358     if(!esd) return;
 359     ReadESDHeader(esd);
 360     ReadESDTracks(esd);
 361     //ReadESDCaloClusters(esd);
 362     if((bool)fIsRealOrMC[0]) ReadMCTracks(mcEvent);
 363   }else if( fInputFormat == "AOD") {
 364     if(fDebug > 5) cout << "\t------- Start AOD "<<endl;
 365     AliAODEvent* aod = dynamic_cast<AliAODEvent*>(event);
 366     if(!aod) return;
 367     ReadAODHeader(aod);
 368     ReadAODTracks(aod);
 369     //ReadAODCaloClusters(aod);
 370   }else{
 371     cout << "Error: Not correct InputDataFormat especified " << endl;
 372     return;
 373   }
 374
 375   //=== TODO : need this?
 376   AliAODHandler* outputHandler =
 377       (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
 378   outputHandler->SetFillAOD(kTRUE);
 379   outputHandler->SetFillExtension(kTRUE);
 380   PostData(1,fRunInfoList);
 381
 382   if(fDebug > 5) cout << "\t------- End UserExec "<<endl;
 383 }
 384
 385 //______________________________________________________________________________
 386 void AliJCORRANTask::Init()
 387 {
 388   // Intialisation of parameters
 389   AliInfo("Doing initialization") ;
 390
 391   TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep());
 392   if(formula.Length()>0){ // momentum dep DCA cut for AOD
 393     formula.ReplaceAll("pt","x");
 394   }
 395 }
 396
 397 //______________________________________________________________________________
 398 void AliJCORRANTask::Terminate(Option_t *)
 399 {
 400   // Processing when the event loop is ended
 401   cout<<"PWG4JCORRAN Analysis DONE !!"<<endl;
 402   // Printout fRunInfoList here
 403   fRunInfoList = dynamic_cast<TList*> (GetOutputData(1));
 404   if(fRunInfoList)
 405   {
 406     fAliRunHeader = dynamic_cast<AliJRunHeader*> (fRunInfoList->FindObject("AliJRunHeader"));
 407     if(fAliRunHeader) {fAliRunHeader->Print();}
 408   }
 409   else
 410   {
 411     cout << "WARNING : Run Information List is empty" << endl;
 412   }
 413
 414 }
 415
 416 //______________________________________________________________________________
 417 void AliJCORRANTask::ReadESDTracks(AliESDEvent * esd)
 418   //void AliJCORRANTask::ReadESDTracks(const AliESDEvent * esd)
 419 {
 420   // Read the AliESDtrack and fill the list of AliJTrack containers
 421   Int_t nt = esd->GetNumberOfTracks();
 422   if(fDebug > 5) cout << "ESD::NumberOfTracks = " << nt << endl;
 423   Short_t ntrk = 0;
 424
 425   //loop over tracks
 426   for(Int_t it = 0; it < nt; it++) {
 427
 428     AliESDtrack *track = esd->GetTrack(it);
 429     if( !track ) continue;
 430     if(! fEsdTrackCuts->IsSelected(track)) continue; // apply track selection criteria
 431     UInt_t filterMap = fESDFilter->IsSelected( track );
 432     //------------ T P C ------------
 433     Float_t tpcDca[2], tpcCov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z
 434     track->GetImpactParametersTPC(tpcDca,tpcCov);
 435
 436     Int_t nClust         = track->GetTPCclusters(0);
 437     Int_t nFindableClust = track->GetTPCNclsF();
 438     Float_t tpcChi2PerCluster = 0.;
 439     if(nClust>0.) tpcChi2PerCluster = track->GetTPCchi2()/Float_t(nClust);
 440
 441     Float_t tpcClustPerFindClust = 0.;
 442     if(nFindableClust>0.) tpcClustPerFindClust = Float_t(nClust)/nFindableClust;
 443     //--------------------------------
 444
 445     //create a new AliJTrack and fill the track info
 446     AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack;
 447     ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 );
 448     ctrack->SetTPCdEdx( track->GetTPCsignal()  );
 449     if( fStoreTPCTrack ){
 450       AliESDtrack *tpcTrack = AliESDtrackCuts::GetTPCOnlyTrack( esd,  it );
 451       if( !tpcTrack ) continue;
 452       ctrack->SetTPCTrack( tpcTrack->Px(),  tpcTrack->Py(),  tpcTrack->Pz());
 453     }
 454     ReadESDPID( track, ctrack );
 455     ctrack->SetParticleType(kNone);
 456     ctrack->SetCharge(track->Charge());
 457     ctrack->SetFilterMap( filterMap );
 458
 459     if(fDebug > 5 && track->P()>1 ) cout << "P = " << track->P() << endl;
 460
 461     ++ntrk;
 462   } // end tracks loop
 463 }
 464
 465 //_________________________________________________________________________________-
 466 void AliJCORRANTask::ReadESDPID(AliESDtrack *track, AliJTrack *ctrack)
 467 {
 468   // Probability calculation for PID
 469   Double_t probTPC[AliPID::kSPECIES]={0.};
 470   Double_t probTOF[AliPID::kSPECIES]={0.};
 471   Double_t probTPCTOF[AliPID::kSPECIES]={0.};
 472   //
 473   fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC);
 474   UInt_t detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPC);
 475   if (detUsed != 0) {  // TPC is available
 476     for (Int_t ispec=0; ispec<AliPID::kSPECIES; ++ispec) {
 477       Double_t nSigmaTPC = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType)ispec);
 478       ctrack->SetTPCsigma(AliJTrack::AliJTrkPID(ispec), nSigmaTPC);
 479     }
 480
 481     // compute priors for TPC+TOF, even if we ask just TOF for PID
 482     fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF);
 483     detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTOF);
 484     if (detUsed != 0) {  // TOF is available
 485       for (Int_t ispec=0; ispec<AliPID::kSPECIES; ++ispec) {
 486         Double_t nSigmaTOF = fPIDResponse->NumberOfSigmasTOF(track,(AliPID::EParticleType)ispec);
 487         ctrack->SetTOFsigma(AliJTrack::AliJTrkPID(ispec), nSigmaTOF);
 488       }
 489     }
 490
 491     fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF|AliPIDResponse::kDetTPC);
 492     detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPCTOF);
 493   }
 494
 495   for (int ip=0 ; ip < (AliPID::kSPECIES); ip++) {
 496     ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTOF[ip], AliJTrack::kTOF);
 497     ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTPC[ip], AliJTrack::kTPC);
 498     ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTPCTOF[ip], AliJTrack::kTPCTOF);
 499   }
 500
 501   // TOF beta and expected beta
 502   Float_t beta = -1;  Float_t minP = 0.2; Float_t minTPCsignal = 40; Float_t minTOFLength = 365.; Float_t minTOFsignal = 12000;
 503   Double_t inttimes[10];  Float_t betaTh[10]; Double_t dEdxTh[10];
 504   track->GetIntegratedTimes(inttimes);
 505   for(int i=0;i<10;i++) {
 506     betaTh[i] = -1.; // initialize expected beta = -1
 507     dEdxTh[i] = -1.; // initialize expected dEdx = -1
 508   }
 509   if(track->P() > minP && track->GetTPCsignal() > minTPCsignal && (track->GetStatus() & AliESDtrack::kTOFout)
 510      && (track->GetStatus() & AliESDtrack::kTIME) && (track->GetIntegratedLength() > minTOFLength)&& track->GetTOFsignal() > minTOFsignal) {
 511     Double_t consCal = 33.3564095198152043;
 512     beta = track->GetIntegratedLength() / (track->GetTOFsignal() - fPIDesd->GetTOFResponse().GetStartTime(track->P())) * consCal;
 513     for(int i=0; i<10; i++) {
 514       betaTh[i] = track->GetIntegratedLength() / ( inttimes[i] ) * consCal;
 515     }
 516   }
 517   ctrack->SetTOFbeta(beta);
 518
 519   Double_t ptpc[3];
 520   track->GetInnerPxPyPz(ptpc);
 521   Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]);
 522   for(int ip=0; ip < (AliJTrack::kNAliJTrkPID); ip++) {
 523     ctrack->SetExpectedTOFbeta(AliJTrack::AliJTrkPID(ip), betaTh[ip]);
 524     // expected dEdx
 525     dEdxTh[ip] = fPIDesd->GetTPCResponse().GetExpectedSignal(momtpc, AliPID::EParticleType(ip));
 526     ctrack->SetExpectedTPCdEdx(AliJTrack::AliJTrkPID(ip), dEdxTh[ip]);
 527   }
 528
 529
 530
 531 }
 532
 533 //______________________________________________________________________________
 534 void AliJCORRANTask::ReadAODTracks(const AliAODEvent * aod)
 535 {
 536   // Read the AliAODtrack and fill the list of AliJTrack containers
 537   Int_t nt = aod->GetNumberOfTracks();
 538   if(fDebug > 5) cout << "AOD::NumberOfTracks = " << nt << endl;
 539   cout << "AOD::NumberOfTracks = " << nt << endl;
 540   //Short_t ntrk = 0;
 541   //loop over tracks
 542   for(Int_t it = 0; it < nt; it++) {
 543
 544     AliAODTrack *track = aod->GetTrack(it);
 545     //if(!AcceptAODTrack(track)) continue;
 546     //if(! fEsdTrackCuts->IsSelected(track)) continue; //apply loose selection criteria
 547     //FK//if(track->GetType() != AliAODTrack::kPrimary) continue; // only primaries
 548
 549     AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack;
 550     ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 );
 551     //TODO if( fStoreTPCTrack )
 552     ctrack->SetParticleType(kNone);
 553     ctrack->SetCharge(track->Charge());
 554     ctrack->SetStatus(track->GetStatus());//
 555     ctrack->SetFlags( track->GetFlags() );
 556     ctrack->SetLabel( track->GetLabel() );
 557     //FilterMap
 558     UInt_t filterMap=0;
 559     for( unsigned int i=0;i<sizeof(filterMap)*8;i++ ){
 560       filterMap |= track->TestFilterBit( 1UL<<i );
 561     }
 562     ctrack->SetFilterMap( filterMap );
 563
 564     //PID TODO
 565     double const * pid = track->PID();
 566     ctrack->SetPID(AliJTrack::kElectronAliJ,pid[AliAODTrack::kElectron],AliJTrack::kTOF);
 567     ctrack->SetPID(AliJTrack::kMuonAliJ,    pid[AliAODTrack::kMuon],    AliJTrack::kTOF);
 568     ctrack->SetPID(AliJTrack::kPionAliJ,    pid[AliAODTrack::kPion],    AliJTrack::kTOF);
 569     ctrack->SetPID(AliJTrack::kKaonAliJ,    pid[AliAODTrack::kKaon],    AliJTrack::kTOF);
 570     ctrack->SetPID(AliJTrack::kProtonAliJ,  pid[AliAODTrack::kProton],  AliJTrack::kTOF);
 571     //TPC
 572     ctrack->SetTPCnClust(track->GetTPCNcls());
 573     ctrack->SetTPCdEdx( track->GetTPCsignal()  );
 574
 575     if((bool) fIsRealOrMC[0]){
 576       //Int_t  label = track->GetLabel();
 577       //ctrack->SetITSLabel(label);
 578       //ctrack->SetTPCLabel(label);
 579     }
 580
 581
 582     if(fDebug > 5 && track->P()>1 ) cout << "P = " << track->P() << endl;
 583   } // end tracks loop
 584 }
 585
 586 //______________________________________________________________________________
 587 void AliJCORRANTask::ReadESDCaloClusters(const AliESDEvent* esd)
 588 {
 589   //AliVEvent * event = InputEvent();
 590   AliVEvent * event = (AliVEvent*)esd;
 591   TRefArray *caloClustersArr=new TRefArray();
 592   event->GetEMCALClusters(caloClustersArr);
 593   Double_t v[3];
 594   event->GetPrimaryVertex()->GetXYZ(v);
 595
 596   AliEMCALRecoUtils * fRecoUtils = new AliEMCALRecoUtils;
 597
 598   //const Int_t kNumberOfEMCALClusters =caloClustersArr->GetEntries();
 599   Int_t numberOfCaloClusters = caloClustersArr->GetEntries() ;
 600   if(fDebug > 5) cout << "ESD::number of ESD caloclusters " << numberOfCaloClusters << endl;
 601
 602   AliVCaloCells *emCells =event->GetEMCALCells();
 603
 604   int nPhotons = 0;
 605   for(Int_t icluster=0; icluster<numberOfCaloClusters; icluster++){
 606     AliVCluster *c1 = (AliVCluster*) caloClustersArr->At(icluster);
 607     if( !c1 ) continue;
 608     //== remove bad channels
 609     if(fRecoUtils->ClusterContainsBadChannel(fEMCALGeoUtils, c1->GetCellsAbsId(), c1->GetNCells())) continue;
 610     //== check energy and position
 611     if(fRecoUtils->IsRecalibrationOn()){
 612       fRecoUtils->RecalibrateClusterEnergy(fEMCALGeoUtils, c1, emCells);
 613       fRecoUtils->RecalculateClusterShowerShapeParameters(fEMCALGeoUtils, emCells, c1);
 614       fRecoUtils->RecalculateClusterPID(c1);
 615     }
 616     //== correct non linearity
 617     c1->SetE(fRecoUtils->CorrectClusterEnergyLinearity(c1));
 618
 619     //== corrected clusters
 620     if(c1->E() < 0.8 || c1->E() > 30) continue; //TODO
 621     //fRecoUtils->GetMaxEnergyCell(fEMCALGeo, emCells, c1, absID1, iSM, ieta1, iphi1, shared);
 622
 623     AliJPhoton *pht = new( (*fPhotonList)[nPhotons++] ) AliJPhoton;
 624     pht->SetParticleType(kNone);//kPhoton);
 625     pht->SetChi2(c1->Chi2());
 626     pht->SetPID(c1->GetPID());
 627     Float_t pos[3];
 628     TLorentzVector p1;
 629     c1->GetPosition(pos);
 630     c1->GetMomentum(p1, v);
 631     //TODO
 632     pht->SetPositionX(pos[0]);
 633     pht->SetPositionY(pos[1]);
 634     pht->SetPositionZ(pos[2]);
 635     pht->SetPxPyPzE( p1.Px(), p1.Py(), p1.Pz(), p1.E());
 636     pht->SetTrackDx( c1->GetTrackDx() );
 637     pht->SetTrackDz( c1->GetTrackDz() );
 638     pht->SetCharge(0);
 639     if(c1->IsEMCAL()) pht->SetCaloType(AliJPhoton::kEMCALCalo);
 640     if(c1->IsPHOS())  pht->SetCaloType(AliJPhoton::kPHOSCalo);
 641     pht->SetDistToBadChannel(c1->GetDistanceToBadChannel());
 642     pht->SetDispersion(c1->GetDispersion());
 643     pht->SetM20(c1->GetM20());
 644     pht->SetM02(c1->GetM02());
 645     pht->SetEmcCpvDist(c1->GetEmcCpvDistance());
 646     pht->SetNCells(c1->GetNCells());
 647     pht->SetCellsAmplitudeFraction( c1->GetCellsAmplitudeFraction() );
 648     pht->SetCellsAbsId(c1->GetCellsAbsId());
 649     Int_t imoduleID = GetSuperModuleNumber(c1->IsEMCAL(), c1->GetCellAbsId(0));
 650     pht->SetSuperModuleID(imoduleID);
 651   }
 652   delete fRecoUtils;
 653   delete caloClustersArr;
 654
 655 }
 656
 657 //______________________________________________________________________________
 658 void AliJCORRANTask::ReadAODCaloClusters(const AliAODEvent* aod)
 659 {
 660   if( !aod ) aod=0;
 661   // Read the AliAODCaloClusters and fill the list of AliJPhoton containers
 662 }
 663
 664 //______________________________________________________________________________
 665 AliJEventHeader* AliJCORRANTask::ReadCommonHeader(AliVEvent *event){
 666   //Read the AliVEvent and fill the list of AliJEventHeader containers
 667   //create a header and fill it
 668   AliJEventHeader *hdr = new( (*fHeaderList)[fHeaderList->GetEntriesFast()] ) AliJEventHeader;
 669
 670   AliVVZERO *v0 = event->GetVZEROData();
 671   if( v0 ) hdr->SetV0Mult(v0->GetMTotV0A() + v0->GetMTotV0C());
 672   // Get Centrality as a percent from 0% to 100%
 673   AliCentrality *cent = event->GetCentrality();
 674   if( cent ){
 675     hdr->SetCentrality( cent->GetCentralityPercentile("V0M"));
 676     hdr->SetCentralityArray(AliJEventHeader::kcV0M, cent->GetCentralityPercentile("V0M"));
 677     hdr->SetCentralityArray(AliJEventHeader::kcFMD, cent->GetCentralityPercentile("FMD"));
 678     hdr->SetCentralityArray(AliJEventHeader::kcTRK, cent->GetCentralityPercentile("TRK"));
 679     hdr->SetCentralityArray(AliJEventHeader::kcTKL, cent->GetCentralityPercentile("TKL"));
 680     hdr->SetCentralityArray(AliJEventHeader::kcCL0, cent->GetCentralityPercentile("CL0"));
 681     hdr->SetCentralityArray(AliJEventHeader::kcCL1, cent->GetCentralityPercentile("CL1"));
 682     hdr->SetCentralityArray(AliJEventHeader::kcV0MvsFMD, cent->GetCentralityPercentile("V0MvsFMD"));
 683     hdr->SetCentralityArray(AliJEventHeader::kcTKLvsV0, cent->GetCentralityPercentile("TKLvsV0"));
 684     hdr->SetCentralityArray(AliJEventHeader::kcZEMvsZDC, cent->GetCentralityPercentile("ZEMvsZDC"));
 685   }
 686   hdr->SetTriggerMaskAlice(event->GetTriggerMask()); //ULong64_t
 687   hdr->SetTriggerMaskJCorran(ConvertTriggerMask()); //UInt_t
 688   hdr->SetEventType(event->GetEventType());
 689   int ncontributors = 0;
 690   const AliVVertex * vtxESD = event->GetPrimaryVertex();
 691   if(vtxESD){
 692     hdr->SetXVertex(vtxESD->GetX()); //FK// EFF
 693     hdr->SetYVertex(vtxESD->GetY()); //FK// EFF
 694     hdr->SetZVertex(vtxESD->GetZ());
 695     //hdr->SetZVertexErr(vtxESD->GetZRes());
 696     double covMat[6];
 697     vtxESD->GetCovarianceMatrix(covMat);
 698     hdr->SetZVertexErr(TMath::Sqrt(covMat[5])); // GetZRes := TMath::Sqrt(fCovZZ)
 699     ncontributors = vtxESD->GetNContributors(); // get number of contributors to vertex
 700     hdr->SetVtxMult( vtxESD->GetNContributors() );
 701   }else{
 702     hdr->SetZVertex(9999);
 703     hdr->SetZVertexErr(9999);
 704   }
 705   hdr->SetVtxMult(ncontributors); //FK// EFF contrib to vertex
 706   return hdr;
 707 }
 708 //______________________________________________________________________________
 709 void AliJCORRANTask::ReadESDHeader(AliESDEvent *esd)
 710 {
 711   // Read the AliESDEvent and fill the list of AliJEventHeader containers
 712   if(!esd) return;
 713   AliESDUtils::RefitESDVertexTracks( esd ); // TODO only for LHC11a right?
 714   AliJEventHeader *hdr = ReadCommonHeader( esd );
 715   //create a header and fill it
 716   AliMultiplicity *fSPDMult =(AliMultiplicity *) esd->GetMultiplicity();
 717   if(fSPDMult) hdr->SetSPDTrackletMult(fSPDMult->GetNumberOfTracklets());
 718
 719   //TODO  Store Detector data
 720   if( fStoreEventPlaneSource ){
 721     *fVZEROData = *esd->GetVZEROData();
 722     *fTZEROData = AliESDTZERO(*esd->GetESDTZERO());
 723     *fZDCData  = *esd->GetESDZDC();
 724   }
 725   hdr->SetEventID( esd->GetEventNumberInFile());
 726   const AliESDVertex * vtxESD = esd->GetPrimaryVertex();
 727   if( vtxESD->GetStatus() == 0 ) hdr->SetVtxMult( 0 );
 728   // if fNcontributes > 0 then status is always true. do we need this?
 729 }
 730
 731 //______________________________________________________________________________
 732 void AliJCORRANTask::ReadAODHeader(AliAODEvent *aod)
 733 {
 734   //Read the AliAODEvent and fill the list of AliJEventHeader containers
 735   AliJEventHeader *hdr = ReadCommonHeader( aod );
 736
 737   const AliAODTracklets *trackletsSPD = aod->GetTracklets();
 738   if(trackletsSPD){
 739     hdr->SetSPDTrackletMult(trackletsSPD->GetNumberOfTracklets());
 740   }
 741   //TODO hdr->SetEventID( esd->GetEventNumberInFile());
 742 }
 743
 744 //______________________________________________________________________________
 745 Int_t AliJCORRANTask::GetSuperModuleNumber(bool isemcal, Int_t absId)
 746 {
 747   //get super module number
 748   if(isemcal){
 749     //    return GetEMCALGeoUtils()->GetSuperModuleNumber(absId) ;
 750     return fEMCALGeoUtils->GetSuperModuleNumber(absId) ;
 751
 752   } else {
 753     Int_t    relId[4];
 754     if ( absId >= 0) {
 755       fPHOSGeom->AbsToRelNumbering(absId,relId);
 756       fPHOSGeom->AbsToRelNumbering(absId,relId);
 757       return relId[0]-1;
 758     } else return -1;
 759   }//PHOS
 760
 761   return -1;
 762 }
 763
 764 //_____________________________________________________________________________
 765
 766 UInt_t AliJCORRANTask::ConvertTriggerMask(){
 767
 768   //convert alice trigger mask to jcorran trigger mask
 769   UInt_t triggerMaskJC=0;
 770   if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
 771      ->IsEventSelected() & AliVEvent::kMB){
 772     // minimum bias TBit 0
 773     triggerMaskJC += (1<<kMinBiasTriggerBitJCorran);
 774   }
 775
 776   if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
 777      ->IsEventSelected() & AliVEvent::kHighMult){
 778     //high multiplicity trigger TBit 1
 779     triggerMaskJC += (1<<kHighMultTriggerBitJCorran);
 780   }
 781
 782   return triggerMaskJC;
 783 }
 784
 785
 786 //______________________________________________________________________________
 787
 788 void AliJCORRANTask::ReadMCTracks(AliMCEvent *fMC){
 789   //store MC information from AliStack
 790   AliStack *stack = fMC->Stack();
 791   Int_t np    = fMC->GetNumberOfTracks();
 792
 793   //  AliGenEventHeader* genHeader = fMC->GenEventHeader();
 794   //  AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
 795   //  Double_t ptHard = 0;
 796   //  Double_t nTrials = 1; // Trials for MC trigger weigth for real data
 797   //  nTrials = pythiaGenHeader->Trials();
 798   //  ptHard  = pythiaGenHeader->GetPtHard();
 799   //  Int_t nprim = stack->GetNtrack();
 800
 801   Short_t ntrack = 0;
 802
 803   for(Int_t iTrack = 0; iTrack < np; iTrack++){
 804     AliMCParticle *track = (AliMCParticle*) fMC->GetTrack(iTrack);
 805     if(!track){
 806       Printf("ERROR: Could not receive track %d", iTrack);
 807       continue;
 808     }
 809     Bool_t isPrimary = fMC->Stack()->IsPhysicalPrimary(iTrack);
 810     if(isPrimary){
 811       //create a new JMCTrack and fill the track info
 812       AliJMCTrack *ctrack = new( (*fMCTrackList)[ntrack++] ) AliJMCTrack;;
 813
 814       TParticle *partStack = stack->Particle(iTrack);
 815       Int_t   pdg  = partStack->GetPdgCode();
 816       // BS unused : Float_t engy = partStack->Energy();
 817       // BS unused : Float_t pt   = partStack->Pt();
 818       // BS unused : Float_t ptot = partStack->P();
 819       // BS unused : Float_t eta  = partStack->Eta();
 820       // BS unused : Float_t theta  = partStack->Theta();
 821       // BS unused : Float_t phi    = atan2(sin( partStack->Phi()), cos(partStack->Phi()));
 822       // BS unused : Short_t ch     = (Short_t) partStack->GetPDG()->Charge();
 823       Int_t label    = track->GetLabel();
 824
 825       ctrack->SetLabel(label);
 826       ctrack->SetPdgCode(pdg);
 827       ctrack->SetPxPyPzE( partStack->Px(), partStack->Py(), partStack->Pz(), partStack->Energy());
 828       //ctrack->SetCharge(ch);
 829       ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary);
 830
 831       ctrack->SetProductionVertex(partStack->Vx(),partStack->Vy(),partStack->Vz());
 832       /*
 833          Int_t   status  = partStack->GetStatusCode();
 834          ctrack->SetStatusCode(status);
 835
 836       //ctrack->SetPtHard(ptHard);
 837
 838       //bool isInc = (status ==  1 && icode ==  22); //Inclusive
 839       bool ispi0 = (status == 11 && pdg == 111); //kPizero
 840       bool isDgamma = (status == 6 || status == 7) && pdg == 22; // Direct photon
 841       bool inPHOS  = (ispi0||isDgamma)&&fabs(eta)<0.12;
 842       bool inEMCAL = (ispi0||isDgamma)&&fabs(eta)<0.7;
 843       bool inTPC   = fabs(eta)<0.9;
 844       ctrack->SetMother(0,partStack->GetFirstMother());
 845       ctrack->SetMother(1,partStack->GetSecondMother());
 846       ctrack->SetDaughter(0,partStack->GetFirstDaughter());
 847       ctrack->SetDaughter(1,partStack->GetLastDaughter());
 848       ctrack->SetIsInPHOS(inPHOS);
 849       ctrack->SetIsInEMCAL(inEMCAL);
 850       ctrack->SetIsInTPC(inTPC);
 851       */
 852     }// loop for al primary tracks
 853   }
 854 }
 855
 856 //--------------------------------------------------------------------
 857 bool AliJCORRANTask::AcceptAODTrack(AliAODTrack* aodTrack){
 858   //This function mimics for the AliAODTracks object the AliESDtrackCut function IsSelected
 859   //Cuts are taken from fEsdTrackCuts object
 860   if(fEsdTrackCuts->GetMinNClusterTPC() > aodTrack->GetTPCNcls()) return kFALSE;
 861
 862   //if(fEsdTrackCuts->GetMaxChi2PerClusterTPC() <    );//<-------- how to check?
 863   //      ctrack->SetChi2perNDF(track->Chi2perNDF());
 864
 865   //         C h e c k    r e f i t
 866
 867   /*
 868      if(fEsdTrackCuts->GetRequireTPCRefit()  &&
 869      ((aodTrack->GetStatus() & AliJTrack::kTPCrefit) == 0)) return kFALSE;
 870      if(fEsdTrackCuts->GetRequireITSRefit()  &&
 871      ((aodTrack->GetStatus() & AliJTrack::kITSrefit) == 0)) return kFALSE;
 872      */
 873
 874   //            C u t s   o n    D C A
 875   Float_t impactDCA[3];
 876   if( aodTrack->GetPosition(impactDCA)){
 877     if((fEsdTrackCuts->GetMaxDCAToVertexXY()>0) &&
 878        (fEsdTrackCuts->GetMaxDCAToVertexXY() < sqrt(impactDCA[0]*impactDCA[0] + impactDCA[1]*impactDCA[1]))) return kFALSE;
 879     if((fEsdTrackCuts->GetMaxDCAToVertexZ()>0) &&
 880        (fEsdTrackCuts->GetMaxDCAToVertexZ() < TMath::Abs(impactDCA[2]))) return kFALSE;
 881   } else return kFALSE;
 882
 883
 884
 885   // if(fEsdTrackCuts->GetAcceptKinkDaughters()) //<--------how to check ?
 886   //  esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
 887
 888
 889   return kTRUE;
 890 }
 891
 892 bool AliJCORRANTask::SetAliceTriggerDef(AliJRunHeader *RunInfo){
 893   RunInfo->AddAliceTriggerDef( "kMB", AliVEvent::kMB );
 894   if( fRunType == "LHC10h" )
 895   {
 896     RunInfo->AddAliceTriggerDef( "kINT7", AliVEvent::kINT7 );
 897     RunInfo->AddAliceTriggerDef( "kMUON", AliVEvent::kMUON );
 898     RunInfo->AddAliceTriggerDef( "kHighMult", AliVEvent::kHighMult );
 899     RunInfo->AddAliceTriggerDef( "kEMC1", AliVEvent::kEMC1 );
 900     RunInfo->AddAliceTriggerDef( "kCINT5", AliVEvent::kCINT5 );
 901     RunInfo->AddAliceTriggerDef( "kCMUS5", AliVEvent::kCMUS5 );
 902     RunInfo->AddAliceTriggerDef( "kMUSH7", AliVEvent::kMUSH7 );
 903     RunInfo->AddAliceTriggerDef( "kMUL7", AliVEvent::kMUL7 );
 904     RunInfo->AddAliceTriggerDef( "kMUU7", AliVEvent::kMUU7 );
 905     RunInfo->AddAliceTriggerDef( "kEMC7", AliVEvent::kEMC7 );
 906     RunInfo->AddAliceTriggerDef( "kMUS7", AliVEvent::kMUS7 );
 907     RunInfo->AddAliceTriggerDef( "kPHI1", AliVEvent::kPHI1 );
 908     RunInfo->AddAliceTriggerDef( "kPHI7", AliVEvent::kPHI7 );
 909     RunInfo->AddAliceTriggerDef( "kUserDefined", AliVEvent::kUserDefined );
 910     RunInfo->AddAliceTriggerDef( "kFastOnly", AliVEvent::kFastOnly );
 911     RunInfo->AddAliceTriggerDef( "kAny", AliVEvent::kAny );
 912     RunInfo->AddAliceTriggerDef( "kAnyINT", AliVEvent::kAnyINT );
 913   }
 914   else{
 915     // Default
 916     RunInfo->AddAliceTriggerDef( "kINT7", AliVEvent::kINT7 );
 917     RunInfo->AddAliceTriggerDef( "kMUON", AliVEvent::kMUON );
 918     RunInfo->AddAliceTriggerDef( "kHighMult", AliVEvent::kHighMult );
 919     RunInfo->AddAliceTriggerDef( "kEMC1", AliVEvent::kEMC1 );
 920     RunInfo->AddAliceTriggerDef( "kCINT5", AliVEvent::kCINT5 );
 921     RunInfo->AddAliceTriggerDef( "kCMUS5", AliVEvent::kCMUS5 );
 922     RunInfo->AddAliceTriggerDef( "kMUSH7", AliVEvent::kMUSH7 );
 923     RunInfo->AddAliceTriggerDef( "kMUL7", AliVEvent::kMUL7 );
 924     RunInfo->AddAliceTriggerDef( "kMUU7", AliVEvent::kMUU7 );
 925     RunInfo->AddAliceTriggerDef( "kEMC7", AliVEvent::kEMC7 );
 926     RunInfo->AddAliceTriggerDef( "kMUS7", AliVEvent::kMUS7 );
 927     RunInfo->AddAliceTriggerDef( "kPHI1", AliVEvent::kPHI1 );
 928     RunInfo->AddAliceTriggerDef( "kPHI7", AliVEvent::kPHI7 );
 929     RunInfo->AddAliceTriggerDef( "kUserDefined", AliVEvent::kUserDefined );
 930     RunInfo->AddAliceTriggerDef( "kFastOnly", AliVEvent::kFastOnly );
 931     RunInfo->AddAliceTriggerDef( "kAny", AliVEvent::kAny );
 932     RunInfo->AddAliceTriggerDef( "kAnyINT", AliVEvent::kAnyINT );
 933   }
 934   return true;
 935 }
 936
 937 bool AliJCORRANTask::SetAliceFilterMapDef(AliJRunHeader *RunInfo) {
 938   if( fRunType == "LHC10h" )
 939   {
 940     RunInfo->AddAliceFilterMapDef("EsdTrackCutsL",BIT(0));
 941     RunInfo->AddAliceFilterMapDef("EsdTrackCutsITsa",BIT(1));
 942     RunInfo->AddAliceFilterMapDef("ItsStrong",BIT(2));
 943     RunInfo->AddAliceFilterMapDef("ElectronID",BIT(3));
 944     RunInfo->AddAliceFilterMapDef("EsdTrackCutsH",BIT(4));
 945     RunInfo->AddAliceFilterMapDef("EsdTrackCutsH2",BIT(5));
 946     RunInfo->AddAliceFilterMapDef("EsdTrackCutsH3",BIT(6));
 947     RunInfo->AddAliceFilterMapDef("EsdTrackCutsTPCOnly",BIT(7));
 948     RunInfo->AddAliceFilterMapDef("EsdTrackCutsRaa",BIT(8));
 949   }
 950   else
 951   {
 952     // Default
 953     RunInfo->AddAliceFilterMapDef("EsdTrackCutsL",BIT(0));
 954     RunInfo->AddAliceFilterMapDef("EsdTrackCutsITsa",BIT(1));
 955     RunInfo->AddAliceFilterMapDef("ItsStrong",BIT(2));
 956     RunInfo->AddAliceFilterMapDef("ElectronID",BIT(3));
 957     RunInfo->AddAliceFilterMapDef("EsdTrackCutsH",BIT(4));
 958     RunInfo->AddAliceFilterMapDef("EsdTrackCutsH2",BIT(5));
 959     RunInfo->AddAliceFilterMapDef("EsdTrackCutsH3",BIT(6));
 960     RunInfo->AddAliceFilterMapDef("EsdTrackCutsTPCOnly",BIT(7));
 961     RunInfo->AddAliceFilterMapDef("EsdTrackCutsRaa",BIT(8));
 962   }
 963   return true;
 964 }
 965
 966 void AliJCORRANTask::PrintOut() {
 967   AliJRunHeader * RunInfo = fAliRunHeader;
 968   cout << "===== TriggerDef =====" << endl;
 969   cout << RunInfo->GetAliceTriggerDef("kMB") << endl;
 970   cout << RunInfo->GetAliceTriggerDef("kINT7") << endl;
 971   cout << RunInfo->GetAliceTriggerDef("kMUON") << endl;
 972   cout << RunInfo->GetAliceTriggerDef("kHighMult") << endl;
 973   cout << RunInfo->GetAliceTriggerDef("kEMC1") << endl;
 974   cout << RunInfo->GetAliceTriggerDef("kCINT5") << endl;
 975   cout << RunInfo->GetAliceTriggerDef("kCMUS5") << endl;
 976   cout << RunInfo->GetAliceTriggerDef("kMUSH7") << endl;
 977   cout << RunInfo->GetAliceTriggerDef("kMUL7") << endl;
 978   cout << RunInfo->GetAliceTriggerDef("kMUU7") << endl;
 979   cout << RunInfo->GetAliceTriggerDef("kEMC7") << endl;
 980   cout << RunInfo->GetAliceTriggerDef("kMUS7") << endl;
 981   cout << RunInfo->GetAliceTriggerDef("kPHI1") << endl;
 982   cout << RunInfo->GetAliceTriggerDef("kPHI7") << endl;
 983   cout << RunInfo->GetAliceTriggerDef("kUserDefined") << endl;
 984   cout << RunInfo->GetAliceTriggerDef("kFastOnly") << endl;
 985   cout << RunInfo->GetAliceTriggerDef("kAny") << endl;
 986   cout << RunInfo->GetAliceTriggerDef("kAnyINT") << endl;
 987   cout << "===== FilterMapDef =====" << endl;
 988   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsL") << endl;
 989   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsITsa") << endl;
 990   cout << RunInfo->GetAliceFilterMapDef("ItsStrong") << endl;
 991   cout << RunInfo->GetAliceFilterMapDef("ElectronID") << endl;
 992   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH") << endl;
 993   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH2") << endl;
 994   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH3") << endl;
 995   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsTPCOnly") << endl;
 996   cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsRaa") << endl;
 997 }
 998
 999
1000 //********************************************
1001 //    UTILS
1002 //********************************************
1003 void AliJCORRANTask::AddListAODBranch(const char* aname, const char* cname, TClonesArray **obj, int nlist){
1004   *obj = new TClonesArray(cname, nlist);
1005   (*obj)->SetName(aname);
1006   AddAODBranch("TClonesArray", obj, fAODName.Data() );
1007 }