Changes to compile with Root6 on macosx64
[u/mrichter/AliRoot.git] / 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<AliJConst::kRangeTriggerTableAlice;i++)   fActiveTriggers[i]=" ";
117   for(Int_t i=0;i<AliJConst::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<AliJConst::kRangeTriggerTableAlice;i++)   fActiveTriggers[i]=" ";
160   for(Int_t i=0;i<AliJConst::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 < AliJConst::kRangeTriggerTableAlice; k++)
202     fActiveTriggers[k] = ap.fActiveTriggers[k];
203
204   for(int j=0; j < AliJConst::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[AliJConst::kMinBiasTriggerBitJCorran]="Minimum Bias";//minimum bias occupies first trigger bit
331     fTriggerTableJCorran[AliJConst::kHighMultTriggerBitJCorran]="High Multiplicity";//high multiplicity trigger => second trigger bit
332     //=========== Fill Run header object ===============
333     fAliRunHeader->SetRunNumber(runId);
334     fAliRunHeader->SetActiveTriggersJCorran(fTriggerTableJCorran,AliJConst::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<AliJConst::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(AliJConst::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(AliJConst::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(AliJConst::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<<AliJConst::kMinBiasTriggerBitJCorran); 
774   }
775
776   if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))
777      ->IsEventSelected() & AliVEvent::kHighMult){
778     //high multiplicity trigger TBit 1 
779     triggerMaskJC += (1<<AliJConst::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 }