]>
Commit | Line | Data |
---|---|---|
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 | /* $Id$ */ | |
17 | ||
18 | #include <TROOT.h> | |
19 | #include <TSystem.h> | |
20 | #include <TInterpreter.h> | |
21 | #include <TChain.h> | |
22 | #include <TFile.h> | |
23 | #include <TList.h> | |
24 | ||
25 | #include "AliAnalysisTaskSE.h" | |
26 | #include "AliAnalysisManager.h" | |
27 | #include "AliESDEvent.h" | |
28 | #include "AliESD.h" | |
29 | #include "AliAODEvent.h" | |
30 | #include "AliAODHeader.h" | |
31 | #include "AliVEvent.h" | |
32 | #include "AliAODHandler.h" | |
33 | #include "AliAODInputHandler.h" | |
34 | #include "AliMCEventHandler.h" | |
35 | #include "AliInputEventHandler.h" | |
36 | #include "AliMCEvent.h" | |
37 | #include "AliStack.h" | |
38 | #include "AliLog.h" | |
39 | ||
40 | ||
41 | ClassImp(AliAnalysisTaskSE) | |
42 | ||
43 | //////////////////////////////////////////////////////////////////////// | |
44 | Bool_t AliAnalysisTaskSE::fgHeaderCopied = kFALSE; | |
45 | AliAODHeader* AliAnalysisTaskSE::fgAODHeader = NULL; | |
46 | ||
47 | AliAnalysisTaskSE::AliAnalysisTaskSE(): | |
48 | AliAnalysisTask(), | |
49 | fDebug(0), | |
50 | fEntry(0), | |
51 | fInputEvent(0x0), | |
52 | fInputHandler(0x0), | |
53 | fOutputAOD(0x0), | |
54 | fMCEvent(0x0), | |
55 | fTreeA(0x0) | |
56 | { | |
57 | // Default constructor | |
58 | } | |
59 | ||
60 | AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name): | |
61 | AliAnalysisTask(name, "AnalysisTaskSE"), | |
62 | fDebug(0), | |
63 | fEntry(0), | |
64 | fInputEvent(0x0), | |
65 | fInputHandler(0x0), | |
66 | fOutputAOD(0x0), | |
67 | fMCEvent(0x0), | |
68 | fTreeA(0x0) | |
69 | { | |
70 | // Default constructor | |
71 | DefineInput (0, TChain::Class()); | |
72 | DefineOutput(0, TTree::Class()); | |
73 | } | |
74 | ||
75 | AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj): | |
76 | AliAnalysisTask(obj), | |
77 | fDebug(0), | |
78 | fEntry(0), | |
79 | fInputEvent(0x0), | |
80 | fInputHandler(0x0), | |
81 | fOutputAOD(0x0), | |
82 | fMCEvent(0x0), | |
83 | fTreeA(0x0) | |
84 | { | |
85 | // Copy constructor | |
86 | fDebug = obj.fDebug; | |
87 | fEntry = obj.fEntry; | |
88 | fInputEvent = obj.fInputEvent; | |
89 | fInputHandler = obj.fInputHandler; | |
90 | fOutputAOD = obj.fOutputAOD; | |
91 | fMCEvent = obj.fMCEvent; | |
92 | fTreeA = obj.fTreeA; | |
93 | printf("Constructor (3) \n"); | |
94 | } | |
95 | ||
96 | ||
97 | AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other) | |
98 | { | |
99 | // Assignment | |
100 | AliAnalysisTask::operator=(other); | |
101 | fDebug = other.fDebug; | |
102 | fEntry = other.fEntry; | |
103 | fInputEvent = other.fInputEvent; | |
104 | fInputHandler = other.fInputHandler; | |
105 | fOutputAOD = other.fOutputAOD; | |
106 | fMCEvent = other.fMCEvent; | |
107 | fTreeA = other.fTreeA; | |
108 | return *this; | |
109 | } | |
110 | ||
111 | ||
112 | void AliAnalysisTaskSE::ConnectInputData(Option_t* /*option*/) | |
113 | { | |
114 | // Connect the input data | |
115 | if (fDebug > 1) printf("AnalysisTaskSE::ConnectInputData() \n"); | |
116 | // | |
117 | // ESD | |
118 | // | |
119 | fInputHandler = (AliInputEventHandler*) | |
120 | ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler()); | |
121 | // | |
122 | // Monte Carlo | |
123 | // | |
124 | AliMCEventHandler* mcH = 0; | |
125 | mcH = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()); | |
126 | if (mcH) fMCEvent = mcH->MCEvent(); | |
127 | ||
128 | ||
129 | if (fInputHandler) { | |
130 | fInputEvent = fInputHandler->GetEvent(); | |
131 | } else if( fMCEvent ) { | |
132 | AliWarning("No Input Event Handler connected, only MC Truth Event Handler") ; | |
133 | } else { | |
134 | AliError("No Input Event Handler connected") ; | |
135 | return ; | |
136 | } | |
137 | } | |
138 | ||
139 | void AliAnalysisTaskSE::CreateOutputObjects() | |
140 | { | |
141 | // Create the output container | |
142 | // | |
143 | // Default AOD | |
144 | if (fDebug > 1) printf("AnalysisTaskSE::CreateOutPutData() \n"); | |
145 | ||
146 | AliAODHandler* handler = (AliAODHandler*) | |
147 | ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); | |
148 | ||
149 | if (handler) { | |
150 | fOutputAOD = handler->GetAOD(); | |
151 | fTreeA = handler->GetTree(); | |
152 | fTreeA->Print(); | |
153 | ||
154 | // Check if AOD Header replication has been required | |
155 | if (!(handler->IsStandard()) && | |
156 | (handler->NeedsHeaderReplication()) && | |
157 | !(fgAODHeader)) | |
158 | { | |
159 | fgAODHeader = new AliAODHeader; | |
160 | handler->AddBranch("AliAODHeader", &fgAODHeader); | |
161 | } | |
162 | } else { | |
163 | AliWarning("No AOD Event Handler connected.") ; | |
164 | } | |
165 | UserCreateOutputObjects(); | |
166 | } | |
167 | ||
168 | void AliAnalysisTaskSE::Exec(Option_t* option) | |
169 | { | |
170 | // | |
171 | // Exec analysis of one event | |
172 | if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n"); | |
173 | if( fInputHandler ) | |
174 | fEntry = fInputHandler->GetReadEntry(); | |
175 | else if( fMCEvent ) | |
176 | fEntry = fMCEvent->Header()->GetEvent(); | |
177 | if ( !((Entry()-1)%100) && fDebug > 0) | |
178 | AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry())); | |
179 | ||
180 | AliAODHandler* handler = (AliAODHandler*) | |
181 | ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); | |
182 | ||
183 | if (!(handler->IsStandard()) && | |
184 | (handler->NeedsHeaderReplication()) && | |
185 | (fgAODHeader)) | |
186 | { | |
187 | // Header should be replicated | |
188 | AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler); | |
189 | if (aodH) { | |
190 | // Input is AOD | |
191 | fgAODHeader = dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()); | |
192 | fgHeaderCopied = kTRUE; | |
193 | } | |
194 | } | |
195 | ||
196 | // Call the user analysis | |
197 | UserExec(option); | |
198 | PostData(0, fTreeA); | |
199 | ||
200 | } | |
201 | ||
202 | const char* AliAnalysisTaskSE::CurrentFileName() | |
203 | { | |
204 | // Returns the current file name | |
205 | if( fInputHandler ) | |
206 | return fInputHandler->GetTree()->GetCurrentFile()->GetName(); | |
207 | else if( fMCEvent ) | |
208 | return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName(); | |
209 | else return ""; | |
210 | } | |
211 | ||
212 | void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj) | |
213 | { | |
214 | // Add a new branch to the aod tree | |
215 | AliAODHandler* handler = (AliAODHandler*) | |
216 | ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); | |
217 | if (handler) { | |
218 | handler->AddBranch(cname, addobj); | |
219 | } | |
220 | } |