]>
Commit | Line | Data |
---|---|---|
1 | #include "AliBaseESDTask.h" | |
2 | #include "AliFMDEventInspector.h" | |
3 | #include "AliForwardCorrectionManager.h" | |
4 | #include "AliForwardUtil.h" | |
5 | #include "AliFMDCorrELossFit.h" | |
6 | #include <AliAnalysisManager.h> | |
7 | #include <AliAODHandler.h> | |
8 | #include <AliLog.h> | |
9 | #include <AliESDEvent.h> | |
10 | #include <TROOT.h> | |
11 | #include <TSystem.h> | |
12 | #include <iostream> | |
13 | #include <iomanip> | |
14 | ||
15 | //____________________________________________________________________ | |
16 | AliBaseESDTask::AliBaseESDTask() | |
17 | : AliAnalysisTaskSE(), | |
18 | fFirstEvent(true), | |
19 | fList(0), | |
20 | fResults(0), | |
21 | fNeededCorrections(0), | |
22 | fExtraCorrections(0), | |
23 | fCloneList(false), | |
24 | fCorrManager(0) | |
25 | {} | |
26 | ||
27 | //____________________________________________________________________ | |
28 | AliBaseESDTask::AliBaseESDTask(const char* name, const char* title, | |
29 | AliCorrectionManagerBase* manager) | |
30 | : AliAnalysisTaskSE(name), | |
31 | fFirstEvent(true), | |
32 | fList(0), | |
33 | fResults(0), | |
34 | fNeededCorrections(0), | |
35 | fExtraCorrections(0), | |
36 | fCloneList(false), | |
37 | fCorrManager(0) | |
38 | { | |
39 | SetTitle(title && title[0] != '\0' ? title : this->ClassName()); | |
40 | fCorrManager = manager; | |
41 | // if (!manager) | |
42 | // AliFatal("Must pass in a valid correction manager object!"); | |
43 | fBranchNames = | |
44 | "ESD:AliESDRun.,AliESDHeader.,AliMultiplicity.," | |
45 | "AliESDFMD.,SPDVertex.,PrimaryVertex."; | |
46 | ||
47 | DefineOutput(1, TList::Class()); | |
48 | DefineOutput(2, TList::Class()); | |
49 | } | |
50 | //____________________________________________________________________ | |
51 | Bool_t | |
52 | AliBaseESDTask::Connect(const char* sumFile, | |
53 | const char* resFile) | |
54 | { | |
55 | AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); | |
56 | if (!mgr) { | |
57 | Error("AddTaskForwardMult", "No analysis manager to connect to."); | |
58 | return false; | |
59 | } | |
60 | ||
61 | // Add to the manager | |
62 | mgr->AddTask(this); | |
63 | ||
64 | // Create and connect output containers | |
65 | TString sumOut; | |
66 | TString resOut; | |
67 | if (sumFile && sumFile[0] != '\0') sumOut = sumFile; | |
68 | if (resFile && resFile[0] != '\0') resOut = resFile; | |
69 | else if (sumFile && sumFile[0] != '\0') resOut = sumFile; | |
70 | // If the string is null or 'default' connect to standard output file | |
71 | if (sumOut.IsNull() || sumOut.EqualTo("default", TString::kIgnoreCase)) | |
72 | sumOut = AliAnalysisManager::GetCommonFileName(); | |
73 | // If the string is null or 'default' connect to standard output file | |
74 | if (resOut.IsNull() || resOut.EqualTo("default", TString::kIgnoreCase)) | |
75 | resOut = AliAnalysisManager::GetCommonFileName(); | |
76 | ||
77 | // Always connect input | |
78 | mgr->ConnectInput(this, 0, mgr->GetCommonInputContainer()); | |
79 | ||
80 | // Connect sum list unless the output 'none' is specified | |
81 | if (!sumOut.EqualTo("none", TString::kIgnoreCase)) { | |
82 | AliAnalysisDataContainer* sumCon = | |
83 | mgr->CreateContainer(Form("%sSums", GetName()), TList::Class(), | |
84 | AliAnalysisManager::kOutputContainer, sumOut); | |
85 | mgr->ConnectOutput(this, 1, sumCon); | |
86 | } | |
87 | // Connect the result list unless the output 'none' is specified | |
88 | if (!resOut.EqualTo("none", TString::kIgnoreCase)) { | |
89 | AliAnalysisDataContainer* resCon = | |
90 | mgr->CreateContainer(Form("%sResults", GetName()), TList::Class(), | |
91 | AliAnalysisManager::kParamContainer, resOut); | |
92 | mgr->ConnectOutput(this, 2, resCon); | |
93 | } | |
94 | ||
95 | return true; | |
96 | } | |
97 | ||
98 | //____________________________________________________________________ | |
99 | TAxis* | |
100 | AliBaseESDTask::DefaultEtaAxis() const | |
101 | { | |
102 | static TAxis* a = new TAxis(200, -4, 6); | |
103 | return a; | |
104 | } | |
105 | //____________________________________________________________________ | |
106 | TAxis* | |
107 | AliBaseESDTask::DefaultVertexAxis() const | |
108 | { | |
109 | static TAxis* a = AliForwardUtil::MakeFullIpZAxis(20); | |
110 | return a; | |
111 | } | |
112 | //____________________________________________________________________ | |
113 | void | |
114 | AliBaseESDTask::SetDebug(Int_t dbg) | |
115 | { | |
116 | // | |
117 | // Set debug level | |
118 | // | |
119 | // Parameters: | |
120 | // dbg debug level | |
121 | // | |
122 | GetEventInspector().SetDebug(dbg); | |
123 | } | |
124 | ||
125 | ||
126 | //____________________________________________________________________ | |
127 | Bool_t | |
128 | AliBaseESDTask::Configure(const char* macro) | |
129 | { | |
130 | // --- Configure the task ------------------------------------------ | |
131 | TString macroPath(gROOT->GetMacroPath()); | |
132 | if (!macroPath.Contains("$(ALICE_ROOT)/PWGLF/FORWARD/analysis2")) { | |
133 | macroPath.Append(":$(ALICE_ROOT)/PWGLF/FORWARD/analysis2"); | |
134 | gROOT->SetMacroPath(macroPath); | |
135 | } | |
136 | TString mac(macro); | |
137 | if (mac.EqualTo("-default-")) | |
138 | mac = "$(ALICE_ROOT)/PWGLF/FORWARD/analysis2/ForwardAODConfig.C"; | |
139 | const char* config = gSystem->Which(gROOT->GetMacroPath(), mac.Data()); | |
140 | if (!config) { | |
141 | AliWarningF("%s not found in %s", mac.Data(), gROOT->GetMacroPath()); | |
142 | return false; | |
143 | } | |
144 | ||
145 | AliInfoF("Loading configuration of '%s' from %s", ClassName(), config); | |
146 | gROOT->Macro(Form("%s((%s*)%p)", config, GetTitle(), this)); | |
147 | delete config; | |
148 | ||
149 | return true; | |
150 | } | |
151 | ||
152 | //____________________________________________________________________ | |
153 | void | |
154 | AliBaseESDTask::LocalInit() | |
155 | { | |
156 | fFirstEvent = true; | |
157 | Setup(); | |
158 | } | |
159 | ||
160 | //____________________________________________________________________ | |
161 | void | |
162 | AliBaseESDTask::UserCreateOutputObjects() | |
163 | { | |
164 | // | |
165 | // Create output objects | |
166 | // | |
167 | // | |
168 | DGUARD(fDebug,1,"Create user ouput"); | |
169 | fList = new TList; | |
170 | fList->SetName(Form("%sSums", GetName())); | |
171 | fList->SetOwner(); | |
172 | ||
173 | AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager(); | |
174 | AliAODHandler* ah = | |
175 | dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler()); | |
176 | //if (!ah) AliFatal("No AOD output handler set in analysis manager"); | |
177 | if (ah) CreateBranches(ah); | |
178 | ||
179 | GetEventInspector().CreateOutputObjects(fList); | |
180 | ||
181 | if (!Book()) AliFatalF("Failed to book output objects for %s", GetName()); | |
182 | ||
183 | // gSystem->Exec("root-config --version --prefix"); | |
184 | PostData(1, fList); | |
185 | } | |
186 | ||
187 | //____________________________________________________________________ | |
188 | void | |
189 | AliBaseESDTask::UserExec(Option_t*) | |
190 | { | |
191 | // Call pre-event setup | |
192 | PreEvent(); | |
193 | ||
194 | // Read in selected branches | |
195 | LoadBranches(); | |
196 | ||
197 | // Get the input data | |
198 | AliESDEvent* esd = GetESDEvent(); | |
199 | if (!esd) return; | |
200 | ||
201 | // Call the user code with our event passed in | |
202 | Event(*esd); | |
203 | // if (!Event(*esd)) { | |
204 | // AliWarningF("Failed to process the event for %s", GetName()); | |
205 | // return; | |
206 | // } | |
207 | ||
208 | // Post data | |
209 | PostData(1, fList); | |
210 | ||
211 | // Call post-event processing | |
212 | PostEvent(); | |
213 | } | |
214 | ||
215 | //____________________________________________________________________ | |
216 | void | |
217 | AliBaseESDTask::Terminate(Option_t*) | |
218 | { | |
219 | TList* list = dynamic_cast<TList*>(GetOutputData(1)); | |
220 | if (!list) { | |
221 | AliError(Form("No output list defined (%p)", GetOutputData(1))); | |
222 | if (GetOutputData(1)) GetOutputData(1)->Print(); | |
223 | return; | |
224 | } | |
225 | ||
226 | // Assign to our internal variable for use by sub-classes | |
227 | fList = list; | |
228 | ||
229 | // Create our output container | |
230 | TString resName(Form("%sResults", GetName())); | |
231 | if (fCloneList) | |
232 | fResults = static_cast<TList*>(fList->Clone(resName)); | |
233 | else { | |
234 | fResults = new TList; | |
235 | fResults->SetName(resName); | |
236 | } | |
237 | fResults->SetOwner(); | |
238 | ||
239 | // Now call user defined routines | |
240 | if (!Finalize()) { | |
241 | AliErrorF("Failed to finalize this task (%s)", GetName()); | |
242 | return; | |
243 | } | |
244 | ||
245 | PostData(2, fResults); | |
246 | } | |
247 | ||
248 | //____________________________________________________________________ | |
249 | Bool_t | |
250 | AliBaseESDTask::PreData(const TAxis&, const TAxis&) | |
251 | { | |
252 | return true; | |
253 | } | |
254 | ||
255 | ||
256 | //____________________________________________________________________ | |
257 | Bool_t | |
258 | AliBaseESDTask::CheckCorrections(UInt_t what) const | |
259 | { | |
260 | // | |
261 | // Check if all needed corrections are there and accounted for. If not, | |
262 | // do a Fatal exit | |
263 | // | |
264 | // Parameters: | |
265 | // what Which corrections is needed | |
266 | // | |
267 | // Return: | |
268 | // true if all present, false otherwise | |
269 | // | |
270 | DGUARD(fDebug,1,"Checking corrections 0x%x", what); | |
271 | if (what == 0) return true; | |
272 | ||
273 | AliCorrectionManagerBase* cm = GetManager(); | |
274 | if (!cm) { | |
275 | AliErrorF("Check corrections=0x%x not null, " | |
276 | "but no correction manager defined!", | |
277 | what); | |
278 | return false; | |
279 | } | |
280 | Bool_t ret = cm->CheckCorrections(what); | |
281 | return ret; | |
282 | } | |
283 | //____________________________________________________________________ | |
284 | Bool_t | |
285 | AliBaseESDTask::ReadCorrections(const TAxis*& pe, | |
286 | const TAxis*& pv, | |
287 | Bool_t mc, | |
288 | Bool_t sat) | |
289 | { | |
290 | // | |
291 | // Read corrections | |
292 | // | |
293 | // | |
294 | UInt_t what = fNeededCorrections|fExtraCorrections; | |
295 | ||
296 | DGUARD(fDebug,1,"Read corrections 0x%x", what); | |
297 | ||
298 | AliCorrectionManagerBase* cm = GetManager(); | |
299 | if (!cm && fNeededCorrections) { | |
300 | AliErrorF("Needed/extra corrections=0x%x/0x%x not null, " | |
301 | "but no correction manager defined!", | |
302 | fNeededCorrections, fExtraCorrections); | |
303 | return false; | |
304 | } | |
305 | if (!cm || !what) { | |
306 | // In case we have no needed corrections, we can return here | |
307 | if (!pe) pe = DefaultEtaAxis(); | |
308 | if (!pv) pv = DefaultVertexAxis(); | |
309 | return true; | |
310 | } | |
311 | cm->EnableCorrections(what); | |
312 | if (!cm->InitCorrections(GetEventInspector().GetRunNumber(), | |
313 | GetEventInspector().GetCollisionSystem(), | |
314 | GetEventInspector().GetEnergy(), | |
315 | GetEventInspector().GetField(), | |
316 | mc, | |
317 | sat, | |
318 | false)) { | |
319 | AliWarning("Failed to read in some corrections, making task zombie"); | |
320 | return false; | |
321 | } | |
322 | if (!CheckCorrections(fNeededCorrections)) return false; | |
323 | ||
324 | // Sett our persistency pointer | |
325 | // fCorrManager = &fcm; | |
326 | ||
327 | // Get the eta axis from the secondary maps - if read in | |
328 | if (!pe) { | |
329 | pe = cm->GetEtaAxis(); | |
330 | if (!pe) pe = DefaultEtaAxis(); | |
331 | } | |
332 | // Get the vertex axis from the secondary maps - if read in | |
333 | if (!pv) { | |
334 | pv = cm->GetVertexAxis(); | |
335 | if (!pv) pv = DefaultVertexAxis(); | |
336 | } | |
337 | ||
338 | return true; | |
339 | } | |
340 | //____________________________________________________________________ | |
341 | AliESDEvent* | |
342 | AliBaseESDTask::GetESDEvent() | |
343 | { | |
344 | // | |
345 | // Get the ESD event. IF this is the first event, initialise | |
346 | // | |
347 | DGUARD(fDebug,1,"Get the ESD event"); | |
348 | ||
349 | // If we're marked as a zombie, do nothing and return a null | |
350 | if (IsZombie()) return 0; | |
351 | ||
352 | // Try to get the ESD event | |
353 | AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent()); | |
354 | if (!esd) { | |
355 | AliWarning("No ESD event found for input event"); | |
356 | return 0; | |
357 | } | |
358 | ||
359 | // --- Load the data ----------------------------------------------- | |
360 | LoadBranches(); | |
361 | ||
362 | if (!fFirstEvent || !esd->GetESDRun()) return esd; | |
363 | ||
364 | // On the first event, initialize the parameters | |
365 | GetEventInspector().SetMC(MCEvent()); | |
366 | GetEventInspector().ReadRunDetails(esd); | |
367 | ||
368 | AliInfoF("Initializing with parameters from the ESD:\n" | |
369 | " AliESDEvent::GetBeamEnergy() ->%f\n" | |
370 | " AliESDEvent::GetBeamType() ->%s\n" | |
371 | " AliESDEvent::GetCurrentL3() ->%f\n" | |
372 | " AliESDEvent::GetMagneticField()->%f\n" | |
373 | " AliESDEvent::GetRunNumber() ->%d", | |
374 | esd->GetBeamEnergy(), | |
375 | esd->GetBeamType(), | |
376 | esd->GetCurrentL3(), | |
377 | esd->GetMagneticField(), | |
378 | esd->GetRunNumber()); | |
379 | ||
380 | fFirstEvent = false; | |
381 | ||
382 | const TAxis* pe = 0; | |
383 | const TAxis* pv = 0; | |
384 | Bool_t mc = IsMC(); | |
385 | Bool_t sat = false; | |
386 | Bool_t ret = ReadCorrections(pe, pv, mc, sat); | |
387 | if (!ret) { | |
388 | AliError("Failed to read corrections, making this a zombie"); | |
389 | SetZombie(true); | |
390 | return 0; | |
391 | } | |
392 | Printf("Vertex axis: %p Eta axis: %p", pv, pe); | |
393 | if (!pv) AliFatal("No vertex axis defined"); | |
394 | if (!pe) AliFatal("No eta axis defined"); | |
395 | ||
396 | // Initialize the event inspector | |
397 | GetEventInspector().SetupForData(*pv); | |
398 | ||
399 | // Initialize the remaining stuff | |
400 | if (!PreData(*pv, *pe)) { | |
401 | AliError("Failed to initialize sub-algorithms, making this a zombie"); | |
402 | SetZombie(true); | |
403 | return 0; | |
404 | } | |
405 | ||
406 | this->Print("R"); | |
407 | ||
408 | return esd; | |
409 | } | |
410 | ||
411 | //____________________________________________________________________ | |
412 | void | |
413 | AliBaseESDTask::MarkEventForStore() const | |
414 | { | |
415 | // Make sure the AOD tree is filled | |
416 | DGUARD(fDebug,3,"Mark AOD event for storage"); | |
417 | AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager(); | |
418 | AliAODHandler* ah = | |
419 | dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler()); | |
420 | if (ah) ah->SetFillAOD(kTRUE); | |
421 | } | |
422 | #define PF(N,V,...) \ | |
423 | AliForwardUtil::PrintField(N,V, ## __VA_ARGS__) | |
424 | #define PFB(N,FLAG) \ | |
425 | do { \ | |
426 | AliForwardUtil::PrintName(N); \ | |
427 | std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \ | |
428 | } while(false) | |
429 | #define PFV(N,VALUE) \ | |
430 | do { \ | |
431 | AliForwardUtil::PrintName(N); \ | |
432 | std::cout << (VALUE) << std::endl; } while(false) | |
433 | ||
434 | //____________________________________________________________________ | |
435 | void | |
436 | AliBaseESDTask::Print(Option_t* option) const | |
437 | { | |
438 | // | |
439 | // Print information | |
440 | // | |
441 | // Parameters: | |
442 | // option Not used | |
443 | // | |
444 | std::cout << std::setfill('=') << std::setw(75) << "=" | |
445 | << std::setfill(' ') << std::endl; | |
446 | AliForwardUtil::PrintTask(*this); | |
447 | gROOT->IncreaseDirLevel(); | |
448 | PF("Off-line trigger mask", "0x%0x", fOfflineTriggerMask); | |
449 | if (GetManager()) GetManager()->Print(option); | |
450 | else PF("No correction manager",""); | |
451 | ||
452 | GetEventInspector().Print(option); | |
453 | gROOT->DecreaseDirLevel(); | |
454 | } | |
455 | // | |
456 | // EOF | |
457 | // |