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