]>
Commit | Line | Data |
---|---|---|
76ce4b5b | 1 | /////////////////////////////////////////////////////////////////////////// |
2 | // // | |
3 | // AliFemtoCutMonitorHandler: a handler for cut monitors // | |
4 | // You add cut monitors to the collection which are stored in two // | |
5 | // separate collections - one which stores characteristics of the // | |
6 | // entities (tracks, particles, pairs, events) that pass the respective // | |
7 | // cuts and the other for the ones that fail the cut. // | |
8 | // // | |
9 | /////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | #include <TList.h> | |
12 | #include "AliFemtoCutMonitorHandler.h" | |
13 | #include "AliFemtoTypes.h" | |
14 | ||
15 | #ifdef __ROOT__ | |
16 | ClassImp(AliFemtoCutMonitorHandler) | |
17 | #endif | |
18 | // --------------------------------------------------------------------------- | |
19 | AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler(): | |
20 | fCollectionsEmpty(0), fPassColl(0), fFailColl(0) | |
21 | { | |
22 | // Default constructor | |
23 | cout << " *** AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler() " << endl; | |
24 | fCollectionsEmpty = 0; | |
25 | fPassColl = new AliFemtoCutMonitorCollection(); | |
26 | fFailColl = new AliFemtoCutMonitorCollection(); | |
27 | } | |
28 | // --------------------------------------------------------------------------- | |
29 | AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler(const AliFemtoCutMonitorHandler& aHan): | |
30 | fCollectionsEmpty(0), fPassColl(0), fFailColl(0) | |
31 | { | |
32 | // Copy constructor | |
33 | fCollectionsEmpty = aHan.fCollectionsEmpty; | |
34 | fPassColl = new AliFemtoCutMonitorCollection(); | |
35 | AliFemtoCutMonitorIterator iter; | |
36 | for (iter=aHan.fPassColl->begin(); iter!=aHan.fPassColl->end(); iter++){ | |
37 | fPassColl->push_back(*iter); | |
38 | } | |
39 | fFailColl = new AliFemtoCutMonitorCollection(); | |
40 | for (iter=aHan.fFailColl->begin(); iter!=aHan.fFailColl->end(); iter++){ | |
41 | fFailColl->push_back(*iter); | |
42 | } | |
43 | } | |
44 | ||
45 | // --------------------------------------------------------------------------- | |
46 | AliFemtoCutMonitorHandler::~AliFemtoCutMonitorHandler() { | |
47 | // Default destructor | |
48 | delete fPassColl; | |
49 | delete fFailColl; | |
50 | } | |
51 | //__________________________ | |
52 | AliFemtoCutMonitorHandler& AliFemtoCutMonitorHandler::operator=(const AliFemtoCutMonitorHandler& aHan) | |
53 | { | |
54 | // assignment operator | |
55 | if (this == &aHan) | |
56 | return *this; | |
57 | ||
58 | AliFemtoCutMonitorIterator iter; | |
59 | if (fPassColl) { | |
60 | fPassColl->clear(); | |
61 | delete fPassColl; | |
62 | } | |
63 | if (fFailColl) { | |
64 | fFailColl->clear(); | |
65 | delete fFailColl; | |
66 | } | |
67 | fPassColl = new AliFemtoCutMonitorCollection(); | |
68 | for (iter=aHan.fPassColl->begin(); iter!=aHan.fPassColl->end(); iter++){ | |
69 | fPassColl->push_back(*iter); | |
70 | } | |
71 | fFailColl = new AliFemtoCutMonitorCollection(); | |
72 | for (iter=aHan.fFailColl->begin(); iter!=aHan.fFailColl->end(); iter++){ | |
73 | fFailColl->push_back(*iter); | |
74 | } | |
75 | return *this; | |
76 | } | |
77 | ||
78 | // --------------------------------------------------------------------------- | |
79 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoEvent* event, bool pass) { | |
80 | // fill event cut monitors | |
81 | if (fCollectionsEmpty) return; | |
82 | AliFemtoCutMonitorIterator iter; | |
83 | AliFemtoCutMonitor* tCM; | |
84 | if ( pass) { | |
85 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
86 | tCM = *iter; | |
87 | tCM->Fill(event); | |
88 | } | |
89 | } else { | |
90 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
91 | tCM = *iter; | |
92 | tCM->Fill(event); | |
93 | } | |
94 | } | |
95 | } | |
96 | // --------------------------------------------------------------------------- | |
97 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoTrack* track, bool pass) { | |
98 | // Fill track cut monitors | |
99 | if (fCollectionsEmpty) return; | |
100 | AliFemtoCutMonitorIterator iter; | |
101 | AliFemtoCutMonitor* tCM; | |
102 | if ( pass) { | |
103 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
104 | tCM = *iter; | |
105 | tCM->Fill(track); | |
106 | } | |
107 | } else { | |
108 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
109 | tCM = *iter; | |
110 | tCM->Fill(track); | |
111 | } | |
112 | } | |
113 | } | |
114 | // --------------------------------------------------------------------------- | |
115 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoV0* v0, bool pass) { | |
116 | // fill V0 cut monitors | |
117 | if (fCollectionsEmpty) return; | |
118 | AliFemtoCutMonitorIterator iter; | |
119 | AliFemtoCutMonitor* tCM; | |
120 | if ( pass) { | |
121 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
122 | tCM = *iter; | |
123 | tCM->Fill(v0); | |
124 | } | |
125 | } else { | |
126 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
127 | tCM = *iter; | |
128 | tCM->Fill(v0); | |
129 | } | |
130 | } | |
131 | } | |
132 | // --------------------------------------------------------------------------- | |
133 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoKink* kink, bool pass) { | |
134 | // fill kink cut monitors | |
135 | if (fCollectionsEmpty) return; | |
136 | AliFemtoCutMonitorIterator iter; | |
137 | AliFemtoCutMonitor* tCM; | |
138 | if ( pass) { | |
139 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
140 | tCM = *iter; | |
141 | tCM->Fill(kink); | |
142 | } | |
143 | } else { | |
144 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
145 | tCM = *iter; | |
146 | tCM->Fill(kink); | |
147 | } | |
148 | } | |
149 | } | |
150 | // ---------------------------------Gael/12/04/02----------------------------- | |
151 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoPair* pair, bool pass) { | |
152 | // fill pair cut monitors | |
153 | if (fCollectionsEmpty) return; | |
154 | AliFemtoCutMonitorIterator iter; | |
155 | AliFemtoCutMonitor* tCM; | |
156 | if ( pass) { | |
157 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
158 | tCM = *iter; | |
159 | tCM->Fill(pair); | |
160 | } | |
161 | } else { | |
162 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
163 | tCM = *iter; | |
164 | tCM->Fill(pair); | |
165 | } | |
166 | } | |
167 | } | |
168 | // ---------------------------------Gael/19/06/02----------------------------- | |
169 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoParticleCollection* partColl) { | |
170 | // fill particle collection cut monitor | |
171 | if (fCollectionsEmpty) return; | |
172 | AliFemtoCutMonitorIterator iter; | |
173 | AliFemtoCutMonitor* tCM; | |
174 | ||
175 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
176 | tCM = *iter; | |
177 | tCM->Fill(partColl); | |
178 | } | |
179 | } | |
180 | // ------------------------------------Gael/19/06/02------------------------- | |
181 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoEvent* event,const AliFemtoParticleCollection* partColl) { | |
182 | // Fill event particle collection | |
973a91f8 | 183 | //cout<<"In AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoEvent* event, AliFemtoPicoEvent* picoEvent)"<<endl; |
76ce4b5b | 184 | if (fCollectionsEmpty) return; |
185 | AliFemtoCutMonitorIterator iter; | |
186 | AliFemtoCutMonitor* tCM; | |
187 | ||
188 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
189 | tCM = *iter; | |
190 | tCM->Fill(event,partColl); | |
191 | } | |
192 | } | |
973a91f8 | 193 | |
194 | void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoParticleCollection* partColl1, const AliFemtoParticleCollection* partColl2) { | |
195 | // Fill event particle collection | |
196 | //cout<<"***In AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoEvent* event, AliFemtoPicoEvent* picoEvent)"<<endl; | |
197 | if (fCollectionsEmpty) return; | |
198 | AliFemtoCutMonitorIterator iter; | |
199 | AliFemtoCutMonitor* tCM; | |
200 | ||
201 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
202 | tCM = *iter; | |
203 | tCM->Fill(partColl1,partColl2); | |
204 | } | |
205 | } | |
206 | ||
76ce4b5b | 207 | // --------------------------------------------------------------------------- |
208 | void AliFemtoCutMonitorHandler::Finish() { | |
209 | // Perform finish operations on cut monitors | |
210 | AliFemtoCutMonitorIterator iter; | |
211 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
212 | (*iter)->Finish(); | |
213 | } | |
214 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
215 | (*iter)->Finish(); | |
216 | } | |
217 | } | |
218 | // --------------------------------------------------------------------------- | |
219 | void AliFemtoCutMonitorHandler::AddCutMonitor(AliFemtoCutMonitor* cutMoni1, AliFemtoCutMonitor* cutMoni2) { | |
220 | // Add cut monitors to collections | |
221 | fPassColl->push_back(cutMoni1); | |
222 | fFailColl->push_back(cutMoni2); | |
223 | fCollectionsEmpty=false; | |
224 | } | |
225 | // --------------------------------------------------------------------------- | |
226 | void AliFemtoCutMonitorHandler::AddCutMonitor(AliFemtoCutMonitor* cutMoni) { | |
227 | // make a copy of the cut monitor | |
228 | cout << " make a copy of the cutmonitor and push both into the collections " << endl; | |
229 | cout << " not yet implemented" << endl; | |
230 | fPassColl->push_back(cutMoni); | |
231 | cout << " only pass collection pushed" << endl; | |
232 | fCollectionsEmpty=false; | |
233 | } | |
234 | // --------------------------------------------------------------------------- | |
235 | void AliFemtoCutMonitorHandler::AddCutMonitorPass(AliFemtoCutMonitor* cutMoni) { | |
236 | // add monitors to pass | |
237 | fPassColl->push_back(cutMoni); | |
238 | fCollectionsEmpty=false; | |
239 | } | |
240 | // --------------------------------------------------------------------------- | |
241 | void AliFemtoCutMonitorHandler::AddCutMonitorFail(AliFemtoCutMonitor* cutMoni) { | |
242 | // add monitors to fail | |
243 | fFailColl->push_back(cutMoni); | |
244 | fCollectionsEmpty=false; | |
245 | } | |
246 | // --------------------------------------------------------------------------- | |
247 | AliFemtoCutMonitor* AliFemtoCutMonitorHandler::PassMonitor(int n) { | |
248 | // return pass monitor number n | |
249 | AliFemtoCutMonitorIterator iter = fPassColl->begin(); | |
250 | if ( (int)fPassColl->size() <= n ) return NULL; | |
251 | for ( int i=0; i<n; i++) | |
252 | iter++; | |
253 | return *iter; | |
254 | } | |
255 | // --------------------------------------------------------------------------- | |
256 | AliFemtoCutMonitor* AliFemtoCutMonitorHandler::FailMonitor(int n) { | |
257 | // return fail monitor number n | |
258 | AliFemtoCutMonitorIterator iter = fFailColl->begin(); | |
259 | if ( (int)fFailColl->size() <= n ) return NULL; | |
260 | for ( int i=0; i<n; i++) | |
261 | iter++; | |
262 | return *iter; | |
263 | } | |
264 | //_____________________________________________________________________________ | |
265 | TList *AliFemtoCutMonitorHandler::GetOutputList() | |
266 | { | |
267 | TList *tOutputList = new TList(); | |
268 | ||
269 | for (unsigned int ipass=0; ipass<fPassColl->size(); ipass++) { | |
270 | TList *tLp = PassMonitor(ipass)->GetOutputList(); | |
271 | ||
272 | TIter nextLp(tLp); | |
273 | while (TObject *obj = nextLp()) { | |
274 | tOutputList->Add(obj); | |
275 | } | |
276 | ||
277 | delete tLp; | |
278 | } | |
279 | ||
280 | for (unsigned int ipass=0; ipass<fFailColl->size(); ipass++) { | |
281 | TList *tLf = FailMonitor(ipass)->GetOutputList(); | |
282 | ||
283 | TIter nextLf(tLf); | |
284 | while (TObject *obj = nextLf()) { | |
285 | tOutputList->Add(obj); | |
286 | } | |
287 | ||
288 | delete tLf; | |
289 | } | |
290 | ||
291 | return tOutputList; | |
292 | } | |
293 | //_____________________________________________________________________________ | |
294 | void AliFemtoCutMonitorHandler::EventBegin(const AliFemtoEvent* aEvent) | |
295 | { | |
296 | if (fCollectionsEmpty) return; | |
297 | ||
298 | AliFemtoCutMonitorIterator iter; | |
299 | AliFemtoCutMonitor* tCM; | |
300 | ||
301 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
302 | tCM = *iter; | |
303 | tCM->EventBegin(aEvent); | |
304 | } | |
305 | ||
306 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
307 | tCM = *iter; | |
308 | tCM->EventBegin(aEvent); | |
309 | } | |
310 | } | |
311 | //_____________________________________________________________________________ | |
312 | void AliFemtoCutMonitorHandler::EventEnd(const AliFemtoEvent* aEvent) | |
313 | { | |
314 | if (fCollectionsEmpty) return; | |
315 | ||
316 | AliFemtoCutMonitorIterator iter; | |
317 | AliFemtoCutMonitor* tCM; | |
318 | ||
319 | for (iter=fPassColl->begin(); iter!=fPassColl->end(); iter++){ | |
320 | tCM = *iter; | |
321 | tCM->EventEnd(aEvent); | |
322 | } | |
323 | ||
324 | for (iter=fFailColl->begin(); iter!=fFailColl->end(); iter++){ | |
325 | tCM = *iter; | |
326 | tCM->EventEnd(aEvent); | |
327 | } | |
328 | } | |
329 | ||
330 | ||
331 | ||
332 |