Make the macros run for PROOF and PROOFLite
[u/mrichter/AliRoot.git] / PWG2 / FEMTOSCOPY / AliFemto / AliAnalysisTaskFemto.cxx
1 //------------------------------------------------------\r
2 // AliAnalysisTaskFemto - A task for the analysis framework\r
3 // from the FEMTOSCOPY analysis of PWG2. Creates the necessary\r
4 // connection between the ESD or AOD input and the femtoscopic\r
5 // code.\r
6 // Author: Adam Kisiel, OSU; Adam.Kisiel@cern.ch\r
7 //------------------------------------------------------\r
8 #include "TROOT.h"\r
9 #include "TChain.h"\r
10 #include "TH1.h"\r
11 #include "TCanvas.h"\r
12 #include "TSystem.h"\r
13 #include "TFile.h"\r
14 #include "TInterpreter.h"\r
15 \r
16 #include "AliAnalysisTask.h"\r
17 \r
18 #include "AliESDEvent.h"\r
19 \r
20 #include "AliFemtoAnalysis.h"\r
21 #include "AliAnalysisTaskFemto.h"\r
22 #include "AliVHeader.h"\r
23 #include "AliGenEventHeader.h"\r
24 #include "AliGenHijingEventHeader.h"\r
25 #include "AliGenCocktailEventHeader.h"\r
26 \r
27 ClassImp(AliAnalysisTaskFemto)\r
28 \r
29 // Default name for the setup macro of femto analysis  \r
30 // This function MUST be defined in the separate file !!!\r
31 // extern AliFemtoManager *ConfigFemtoAnalysis();\r
32 \r
33 //________________________________________________________________________\r
34   AliAnalysisTaskFemto::AliAnalysisTaskFemto(const char *name): \r
35     AliAnalysisTask(name,""), \r
36     fESD(0), \r
37     fAOD(0),\r
38     fStack(0),\r
39     fOutputList(0), \r
40     fReader(0x0),\r
41     fManager(0x0),\r
42     fAnalysisType(0)\r
43 {\r
44   // Constructor.\r
45   // Input slot #0 works with an Ntuple\r
46   DefineInput(0, TChain::Class());\r
47   // Output slot #0 writes into a TH1 container\r
48   DefineOutput(0, TList::Class());\r
49 }\r
50 \r
51 AliAnalysisTaskFemto::AliAnalysisTaskFemto(const AliAnalysisTaskFemto& aFemtoTask):\r
52     AliAnalysisTask(aFemtoTask), \r
53     fESD(0), \r
54     fAOD(0),\r
55     fStack(0),\r
56     fOutputList(0), \r
57     fReader(0x0),\r
58     fManager(0x0),\r
59     fAnalysisType(0)\r
60 {\r
61   // copy constructor\r
62   fESD = aFemtoTask.fESD; \r
63   fAOD = aFemtoTask.fAOD; \r
64   fStack = aFemtoTask.fStack;\r
65   fOutputList = aFemtoTask.fOutputList;   \r
66   fReader = aFemtoTask.fReader;       \r
67   fManager = aFemtoTask.fManager;      \r
68   fAnalysisType = aFemtoTask.fAnalysisType; \r
69 }\r
70 \r
71 \r
72 AliAnalysisTaskFemto& AliAnalysisTaskFemto::operator=(const AliAnalysisTaskFemto& aFemtoTask){\r
73   // assignment operator\r
74   if (this == &aFemtoTask)\r
75     return *this;\r
76 \r
77   fESD = aFemtoTask.fESD; \r
78   fAOD = aFemtoTask.fAOD; \r
79   fStack = aFemtoTask.fStack;\r
80   fOutputList = aFemtoTask.fOutputList;   \r
81   fReader = aFemtoTask.fReader;       \r
82   fManager = aFemtoTask.fManager;      \r
83   fAnalysisType = aFemtoTask.fAnalysisType; \r
84 \r
85   return *this;\r
86 }\r
87 \r
88 //________________________________________________________________________\r
89 void AliAnalysisTaskFemto::ConnectInputData(Option_t *) {\r
90   printf("   ConnectInputData %s\n", GetName());\r
91 \r
92   fESD = 0;\r
93   fAOD = 0;\r
94   fAnalysisType = 0;\r
95 \r
96   TTree* tree = dynamic_cast<TTree*> (GetInputData(0));\r
97   if (!tree) {\r
98     Printf("ERROR: Could not read chain from input slot 0");\r
99   } \r
100   else {\r
101     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
102     \r
103     if(esdH) {\r
104       cout << "Selected ESD analysis" << endl;\r
105       fAnalysisType = 1;\r
106       \r
107       if (!esdH) {\r
108         Printf("ERROR: Could not get ESDInputHandler");\r
109       } \r
110       else {\r
111         fESD = esdH->GetEvent();\r
112       }\r
113     }\r
114     else {\r
115       AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
116       \r
117       if (!aodH) {\r
118         Printf("ERROR: Could not get AODInputHandler");\r
119       } \r
120       else {\r
121         cout << "Selected AOD analysis" << endl;\r
122         fAnalysisType = 2;\r
123 \r
124         fAOD = aodH->GetEvent();\r
125       }\r
126     }\r
127     if ((!fAOD) && (!fESD)) {\r
128       Printf("Wrong analysis type: Only ESD and AOD types are allowed!");\r
129     }\r
130   }\r
131   \r
132   \r
133 }\r
134 \r
135 //________________________________________________________________________\r
136 void AliAnalysisTaskFemto::CreateOutputObjects() {\r
137   printf("Creating Femto Analysis objects\n");\r
138 \r
139   gROOT->LoadMacro("ConfigFemtoAnalysis.C");\r
140   //  fJetFinder = (AliJetFinder*) gInterpreter->ProcessLine("ConfigJetAnalysis()");\r
141   SetFemtoManager((AliFemtoManager *) gInterpreter->ProcessLine("ConfigFemtoAnalysis()"));\r
142 \r
143   TList *tOL;\r
144   fOutputList = fManager->Analysis(0)->GetOutputList();\r
145 \r
146   for (unsigned int ian = 1; ian<fManager->AnalysisCollection()->size(); ian++) {\r
147     tOL = fManager->Analysis(ian)->GetOutputList();\r
148 \r
149     TIter nextListCf(tOL);\r
150     while (TObject *obj = nextListCf()) {\r
151       fOutputList->Add(obj);\r
152     }\r
153 \r
154     delete tOL;\r
155   }\r
156 }\r
157 \r
158 //________________________________________________________________________\r
159 void AliAnalysisTaskFemto::Exec(Option_t *) {\r
160   // Task making a femtoscopic analysis.\r
161 \r
162   if (fAnalysisType==1) {\r
163     if (!fESD) {\r
164       Printf("ERROR: fESD not available");\r
165       return;\r
166     }\r
167 \r
168     //Get MC data\r
169     AliMCEventHandler*    mctruth = (AliMCEventHandler*) \r
170       ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());\r
171     \r
172     AliGenHijingEventHeader *hdh = 0;\r
173     if(mctruth) {\r
174       fStack = mctruth->MCEvent()->Stack();\r
175 \r
176       AliGenCocktailEventHeader *hd = dynamic_cast<AliGenCocktailEventHeader *> (mctruth->MCEvent()->GenEventHeader());\r
177       \r
178       if (hd) {\r
179         \r
180         printf ("Got MC cocktail event header %p\n", (void *) hd);\r
181         TList *lhd = hd->GetHeaders();\r
182         printf ("Got list of headers %d\n", lhd->GetEntries());\r
183         \r
184         for (int iterh=0; iterh<lhd->GetEntries(); iterh++) \r
185           {\r
186             hdh = dynamic_cast<AliGenHijingEventHeader *> (lhd->At(iterh));\r
187             printf ("HIJING header at %i is %p\n", iterh, (void *) hdh);\r
188           }\r
189       }    \r
190     }\r
191 \r
192     // Get ESD\r
193     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
194     \r
195     if (!esdH) {\r
196       Printf("ERROR: Could not get ESDInputHandler");\r
197       return;\r
198     } \r
199     else {\r
200       fESD = esdH->GetEvent();\r
201     }\r
202 \r
203     printf("Tracks in ESD: %d \n",fESD->GetNumberOfTracks());\r
204 \r
205     if (fESD->GetNumberOfTracks() >= 0) {\r
206     \r
207       if (!fReader) {\r
208         printf("ERROR: No ESD reader for ESD analysis !\n");\r
209       }\r
210       \r
211       AliFemtoEventReaderESDChain* fesdc = dynamic_cast<AliFemtoEventReaderESDChain *> (fReader);\r
212       if (fesdc)\r
213         {\r
214           // Process the event with no Kine information\r
215           fesdc->SetESDSource(fESD);\r
216           fManager->ProcessEvent();\r
217         }\r
218       AliFemtoEventReaderESDChainKine* fesdck = dynamic_cast<AliFemtoEventReaderESDChainKine *> (fReader);\r
219       if (fesdck) \r
220         {\r
221           // Process the event with Kine information\r
222           fesdck->SetESDSource(fESD);\r
223           fesdck->SetStackSource(fStack);\r
224           \r
225           fesdck->SetGenEventHeader(hdh);\r
226           fManager->ProcessEvent();\r
227         }\r
228     } \r
229 \r
230     // Post the output histogram list\r
231     PostData(0, fOutputList);\r
232   }\r
233   \r
234   if (fAnalysisType==2) {    \r
235     if (!fAOD) {\r
236       Printf("ERROR: fAOD not available");\r
237       return;\r
238     }\r
239 \r
240     // Get AOD\r
241     AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
242       \r
243     if (!aodH) {\r
244       Printf("ERROR: Could not get AODInputHandler");\r
245       return;\r
246     } \r
247     else {\r
248 \r
249       fAOD = aodH->GetEvent();\r
250     }\r
251 \r
252     printf("Tracks in AOD: %d \n",fAOD->GetNumberOfTracks());\r
253     \r
254     if (fAOD->GetNumberOfTracks() > 0) {\r
255       if (!fReader) {\r
256         printf("ERROR: No AOD reader for AOD analysis! \n");\r
257       }\r
258       else {\r
259         AliFemtoEventReaderAODChain* faodc = dynamic_cast<AliFemtoEventReaderAODChain *> (fReader);\r
260 \r
261         if (faodc) {\r
262           // Process the event\r
263           faodc->SetAODSource(fAOD);\r
264           fManager->ProcessEvent();\r
265         }\r
266       }\r
267     } \r
268 \r
269     // Post the output histogram list\r
270     PostData(0, fOutputList);\r
271   }\r
272 }      \r
273 \r
274 //________________________________________________________________________\r
275 void AliAnalysisTaskFemto::Terminate(Option_t *) {\r
276   // Do the final processing\r
277   if (fManager) {\r
278     fManager->Finish();\r
279   }\r
280 }\r
281 //________________________________________________________________________\r
282 void AliAnalysisTaskFemto:: FinishTaskOutput() {\r
283   // Do the final processing\r
284   if (fManager) {\r
285     fManager->Finish();\r
286   }\r
287 }\r
288 //________________________________________________________________________\r
289 void AliAnalysisTaskFemto::SetFemtoReaderESD(AliFemtoEventReaderESDChain *aReader)\r
290 {\r
291   printf("Selectring Femto reader for ESD\n");\r
292   fReader = aReader;\r
293 }\r
294 //________________________________________________________________________\r
295 void AliAnalysisTaskFemto::SetFemtoReaderESDKine(AliFemtoEventReaderESDChainKine *aReader)\r
296 {\r
297   printf("Selectring Femto reader for ESD with Kinematics information\n");\r
298   fReader = aReader;\r
299 }\r
300 //________________________________________________________________________\r
301 void AliAnalysisTaskFemto::SetFemtoReaderAOD(AliFemtoEventReaderAODChain *aReader)\r
302 {\r
303   printf("Selecting Femto reader for AOD\n");\r
304   fReader = aReader;\r
305 }\r
306 //________________________________________________________________________\r
307 void AliAnalysisTaskFemto::SetFemtoManager(AliFemtoManager *aManager)\r
308 {\r
309   fManager = aManager;\r
310   printf("Got reader %p\n", (void *) aManager->EventReader());\r
311   AliFemtoEventReaderESDChain     *tReaderESDChain     = dynamic_cast<AliFemtoEventReaderESDChain *> (aManager->EventReader());\r
312   AliFemtoEventReaderESDChainKine *tReaderESDChainKine = dynamic_cast<AliFemtoEventReaderESDChainKine *> (aManager->EventReader());\r
313   AliFemtoEventReaderAODChain     *tReaderAODChain     = dynamic_cast<AliFemtoEventReaderAODChain *> (aManager->EventReader());\r
314 \r
315   if ((!tReaderESDChain) && (!tReaderESDChainKine) && (!tReaderAODChain)) {\r
316     printf("No AliFemto event reader created. Will not run femto analysis.\n");\r
317     return;\r
318   }\r
319   if (tReaderESDChain) SetFemtoReaderESD(tReaderESDChain);\r
320   if (tReaderESDChainKine) SetFemtoReaderESDKine(tReaderESDChainKine);\r
321   if (tReaderAODChain) SetFemtoReaderAOD(tReaderAODChain);\r
322 }\r
323 \r