]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ANALYSIS/EventMixing/AliMixInputEventHandler.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
replacing AliHLTTPCRootTypes.h by Rtypes.h
[u/mrichter/AliRoot.git] / ANALYSIS / EventMixing / AliMixInputEventHandler.cxx
CommitLineData
b425275c 1//
2// Class AliMixEventInputHandler
3//
4// Mixing input handler prepare N events before UserExec
5// TODO example
6// author:
7// Martin Vala (martin.vala@cern.ch)
8//
9
10#include <TFile.h>
11#include <TChain.h>
12#include <TEntryList.h>
13#include <TChainElement.h>
14#include <TSystem.h>
15
16#include "AliLog.h"
17#include "AliAnalysisManager.h"
18#include "AliInputEventHandler.h"
19
20#include "AliMixEventPool.h"
21#include "AliMixInputEventHandler.h"
22#include "AliMixInputHandlerInfo.h"
23
24#include "AliAnalysisTaskSE.h"
25
26ClassImp(AliMixInputEventHandler)
27
28AliMixInputEventHandler::AliMixInputEventHandler(const Int_t size, const Int_t mixNum): AliMultiInputEventHandler(size),
29 fMixTrees(),
30 fTreeMap(size > 0 ? size : 1),
31 fMixIntupHandlerInfoTmp(0),
32 fEntryCounter(0),
33 fEventPool(0),
34 fNumberMixed(0),
35 fMixNumber(mixNum),
36 fUseDefautProcess(kFALSE),
917b33da 37 fDoMixExtra(kTRUE),
38 fDoMixIfNotEnoughEvents(kTRUE),
b425275c 39 fCurrentEntry(0),
40 fCurrentEntryMain(0),
41 fCurrentEntryMix(0),
522016cc 42 fCurrentBinIndex(-1),
43 fOfflineTriggerMask(0)
b425275c 44{
45 //
46 // Default constructor.
47 //
48 AliDebug(AliLog::kDebug + 10, "<-");
49 fMixTrees.SetOwner(kTRUE);
50 SetMixNumber(mixNum);
51 AliDebug(AliLog::kDebug + 10, "->");
52}
53
b425275c 54//_____________________________________________________________________________
55void AliMixInputEventHandler::SetInputHandlerForMixing(const AliInputEventHandler *const inHandler)
56{
57 //
58 // Create N (fBufferSize) copies of input handler
59 //
60 AliDebug(AliLog::kDebug + 5, Form("<-"));
61 fInputHandlers.Clear();
62 AliDebug(AliLog::kDebug + 5, Form("Creating %d input event handlers ...", fBufferSize));
63 for (Int_t i = 0; i < fBufferSize; i++) {
64 AliDebug(AliLog::kDebug + 5, Form("Adding %d ...", i));
65 fInputHandlers.Add((AliInputEventHandler *) inHandler->Clone());
66 }
917b33da 67
b425275c 68 AliDebug(AliLog::kDebug + 5, Form("->"));
69}
70
71//_____________________________________________________________________________
72Bool_t AliMixInputEventHandler::Init(TTree *tree, Option_t *opt)
73{
74 //
75 // Init(const char*path) is called for all mix input handlers.
76 // Create event pool if needed
77 //
78 AliDebug(AliLog::kDebug + 5, Form("<- %p %s", (void *)tree, opt));
79 fAnalysisType = opt;
80 if (!tree) {
81 AliDebug(AliLog::kDebug + 5, Form("->"));
82 return kFALSE;
83 }
917b33da 84
85 if (!fDoMixIfNotEnoughEvents) {
86 fDoMixExtra = kFALSE;
87 AliWarning("fDoMixIfNotEnoughEvents=kTRUE -> setting fDoMixExtra=kFALSE");
88 }
89
b425275c 90 // clears array of input handlers
91 fMixTrees.Clear();
92 // create AliMixInputHandlerInfo
93 if (!fMixIntupHandlerInfoTmp) {
94 // loads first file TChain (tree)
95 tree->LoadTree(0);
96 fMixIntupHandlerInfoTmp = new AliMixInputHandlerInfo(tree->GetName());
97 }
7c42594d 98
99 AliInputEventHandler *ih = 0;
100 for (Int_t i = 0; i < fInputHandlers.GetEntries(); i++) {
101 ih = (AliInputEventHandler *) fInputHandlers.At(i);
102 ih->SetParentHandler(this);
103// ih->Init(tree,opt);
104 }
105
b425275c 106 AliDebug(AliLog::kDebug + 5, Form("->"));
107 return kTRUE;
108}
109//_____________________________________________________________________________
110Bool_t AliMixInputEventHandler::Notify()
111{
112 //
113 // Notify() is called for all mix input handlers
114 //
115 AliDebug(AliLog::kDebug + 5, Form("<-"));
116 if (fUseDefautProcess) {
117 AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
118 return AliMultiInputEventHandler::Notify();
119 }
120 AliDebug(AliLog::kDebug + 5, Form("->"));
121 return kTRUE;
122}
123
124//_____________________________________________________________________________
125Bool_t AliMixInputEventHandler::Notify(const char *path)
126{
127 //
128 // Notify(const char*path) is called for all mix input handlers
129 //
130 AliDebug(AliLog::kDebug + 5, Form("<- %s", path));
3bcab622 131
132 Bool_t doPrepareEntry=kTRUE;
133 TString anType = fAnalysisType;
134
135 // in case of local doPrepareEntry only first time
136 if (anType.CompareTo("proof")) doPrepareEntry = (fMixIntupHandlerInfoTmp->GetChain()->GetEntries()<=0);
137
b425275c 138 // adds current file
139 fMixIntupHandlerInfoTmp->AddTreeToChain(path);
140 Int_t lastIndex = fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->GetEntries();
141 TChainElement *che = (TChainElement *)fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->At(lastIndex - 1);
142 AliMixInputHandlerInfo *mixIHI = 0;
143 for (Int_t i = 0; i < fInputHandlers.GetEntries(); i++) {
144 AliDebug(AliLog::kDebug + 5, Form("fInputHandlers[%d]", i));
145 mixIHI = new AliMixInputHandlerInfo(fMixIntupHandlerInfoTmp->GetName(), fMixIntupHandlerInfoTmp->GetTitle());
3bcab622 146// mixIHI->PrepareEntry(che, -1, (AliInputEventHandler *)InputEventHandler(i), fAnalysisType);
147 if (doPrepareEntry) mixIHI->PrepareEntry(che, -1, (AliInputEventHandler *)InputEventHandler(i), fAnalysisType);
b425275c 148 AliDebug(AliLog::kDebug + 5, Form("chain[%d]->GetEntries() = %lld", i, mixIHI->GetChain()->GetEntries()));
149 fMixTrees.Add(mixIHI);
150 }
151 AliDebug(AliLog::kDebug + 5, Form("fEntryCounter=%lld", fEntryCounter));
152 if (fEventPool && fEventPool->NeedInit())
153 fEventPool->Init();
154 if (fUseDefautProcess) {
155 AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
156 return AliMultiInputEventHandler::Notify(path);
157 }
158 AliDebug(AliLog::kDebug + 5, Form("->"));
159 return kTRUE;
160}
161
162//_____________________________________________________________________________
163Bool_t AliMixInputEventHandler::BeginEvent(Long64_t entry)
164{
165 //
166 // BeginEvent(Long64_t entry) is called for all mix input handlers
167 //
168 AliDebug(AliLog::kDebug + 5, Form("-> %lld", entry));
169 if (fUseDefautProcess) {
170 AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
171 AliMultiInputEventHandler::BeginEvent(entry);/* return GetEntry();*/
172 }
173 AliDebug(AliLog::kDebug + 5, Form("->"));
174 return kTRUE;
175}
176//_____________________________________________________________________________
177Bool_t AliMixInputEventHandler::GetEntry()
178{
179 //
180 // All mixed events are set
181 //
182 AliDebug(AliLog::kDebug + 5, Form("<-"));
62e756a5 183
b425275c 184 if (!fEventPool) {
185 MixStd();
186 }
187 // if buffer size is higher then 1
188 else if (fBufferSize > 1) {
189 MixBuffer();
190 }
191 // if mix number is higher then 0 and buffer size is 1
192 else if (fMixNumber > 0) {
193 MixEventsMoreTimesWithOneEvent();
194 } else {
195 AliWarning("Not supported Mixing !!!");
196 }
7c42594d 197
b425275c 198 AliDebug(AliLog::kDebug + 5, Form("->"));
199 return kTRUE;
200}
201
202//_____________________________________________________________________________
203Bool_t AliMixInputEventHandler::MixStd()
204{
205 //
206 // Mix std - No event pool
207 //
208 AliDebug(AliLog::kDebug + 5, Form("<-"));
209 AliDebug(AliLog::kDebug + 1, "Mix method");
210 // get correct handler
211 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
212 AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
213 AliInputEventHandler *inEvHMain = 0;
214 if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
215 else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
216 if (!inEvHMain) return kFALSE;
62e756a5 217
218 // check for PhysSelection
219 if (!IsEventCurrentSelected()) return kFALSE;
220
b425275c 221 // return in case of 0 entry in full chain
222 if (!fEntryCounter) {
223 AliDebug(AliLog::kDebug + 3, Form("-> fEntryCounter == 0"));
06aad8b5 224 // runs UserExecMix for all tasks, if needed
b425275c 225 UserExecMixAllTasks(fEntryCounter, 1, fEntryCounter, -1, 0);
226 return kTRUE;
227 }
228 // pre mix evetns
229 Int_t mixNum = fMixNumber;
917b33da 230 if (fDoMixExtra) {
b425275c 231 if (fEntryCounter <= 2 * fMixNumber) mixNum = 2 * fMixNumber + 2;
232 }
233 // start of
234 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
235 // reset mix number
236 fNumberMixed = 0;
237 AliMixInputHandlerInfo *mihi = 0;
238 Long64_t entryMix = 0, entryMixReal = 0;
239 Int_t counter = 0;
240 for (counter = 0; counter < mixNum; counter++) {
241 entryMix = fEntryCounter - 1 - counter ;
242 AliDebug(AliLog::kDebug + 5, Form("Handler[%d] entryMix %lld ", counter, entryMix));
243 if (entryMix < 0) break;
244 entryMixReal = entryMix;
245 mihi = (AliMixInputHandlerInfo *) fMixTrees.At(0);
246 TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
247 if (!te) {
3bcab622 248 AliError("te is null. this is error. tell to developer (#1)");
b425275c 249 } else {
3bcab622 250 mihi->PrepareEntry(te, entryMix, (AliInputEventHandler *)InputEventHandler(0), fAnalysisType);
b425275c 251 // runs UserExecMix for all tasks
252 fNumberMixed++;
253 UserExecMixAllTasks(fEntryCounter, 1, fEntryCounter, entryMixReal, fNumberMixed);
254 InputEventHandler(0)->FinishEvent();
255 }
256 }
257 AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
258 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
259 AliDebug(AliLog::kDebug + 5, Form("->"));
260 AliDebug(AliLog::kDebug + 5, Form("->"));
261 return kTRUE;
262}
263
264//_____________________________________________________________________________
265Bool_t AliMixInputEventHandler::MixBuffer()
266{
267 //
268 // Mix in event buffer
269 //
270 AliDebug(AliLog::kDebug + 5, Form("<-"));
271 AliDebug(AliLog::kDebug + 1, "Mix method");
272 // get correct handler
273 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
274 AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
275 AliInputEventHandler *inEvHMain = 0;
276 if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
277 else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
278 if (!inEvHMain) return kFALSE;
62e756a5 279
280 // check for PhysSelection
281 if (!IsEventCurrentSelected()) return kFALSE;
282
b425275c 283 // find out zero chain entries
284 Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetTree()->GetEntries();
285 // fill entry
286 Long64_t currentMainEntry = inEvHMain->GetTree()->GetTree()->GetReadEntry() + zeroChainEntries;
287 // fills entry
288 if (fEventPool && inEvHMain) fEventPool->AddEntry(currentMainEntry, inEvHMain->GetEvent());
289 // start of
290 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
291 // reset mix number
292 fNumberMixed = 0;
293 Long64_t elNum = 0;
294 TEntryList *el = 0;
295 Int_t idEntryList = -1;
296 if (fEventPool) el = fEventPool->FindEntryList(inEvHMain->GetEvent(), idEntryList);
297 // return in case of 0 entry in full chain
298 if (!fEntryCounter) {
299 AliDebug(AliLog::kDebug + 3, Form("-> fEntryCounter == 0"));
06aad8b5 300 // runs UserExecMix for all tasks, if needed
a86b14f8 301 if (el) UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
302 else UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
b425275c 303 return kTRUE;
304 }
305 if (!el) {
306 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null) +++++++++++++++++++", fEntryCounter));
307 UserExecMixAllTasks(fEntryCounter, -1, fEntryCounter, -1, 0);
308 return kTRUE;
309 } else {
310 elNum = el->GetN();
311 if (elNum < fBufferSize + 1) {
a86b14f8 312 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
917b33da 313 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (%lld) LESS THEN BUFFER +++++++++++++++++++", fEntryCounter, elNum));
b425275c 314 return kTRUE;
315 }
316 }
317 AliMixInputHandlerInfo *mihi = 0;
318 Long64_t entryMix = 0, entryMixReal = 0;
319 Int_t counter = 0;
320 AliInputEventHandler *eh = 0;
321 TObjArrayIter next(&fInputHandlers);
a86b14f8 322 while ((eh = dynamic_cast<AliInputEventHandler *>(next()))) {
b425275c 323 if (fEventPool && fEventPool->GetListOfEventCuts()->GetEntries() > 0) {
324 entryMix = -1;
325 if (elNum >= fBufferSize) {
326 Long64_t entryInEntryList = elNum - 2 - counter;
327 if (entryInEntryList < 0) break;
328 entryMix = el->GetEntry(entryInEntryList);
329 }
330 }
331 AliDebug(AliLog::kDebug + 5, Form("Handler[%d] entryMix %lld ", counter, entryMix));
332 if (entryMix < 0) {
333 UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
334 break;
335 }
336 entryMixReal = entryMix;
337 mihi = (AliMixInputHandlerInfo *) fMixTrees.At(counter);
338 TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
339 if (!te) {
3bcab622 340 AliError("te is null. this is error. tell to developer (#1)");
b425275c 341 } else {
342 AliDebug(AliLog::kDebug + 3, Form("Preparing InputEventHandler(%d)", counter));
3bcab622 343 mihi->PrepareEntry(te, entryMix, (AliInputEventHandler *)InputEventHandler(counter), fAnalysisType);
b425275c 344 // runs UserExecMix for all tasks
345 UserExecMixAllTasks(fEntryCounter, idEntryList, fEntryCounter, entryMixReal, counter);
346 fNumberMixed++;
347 }
348 counter++;
349 }
350 AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
351 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
352 AliDebug(AliLog::kDebug + 5, Form("->"));
353 AliDebug(AliLog::kDebug + 5, Form("->"));
354 return kTRUE;
355}
356
357//_____________________________________________________________________________
358Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithOneEvent()
359{
360 //
361 // Mix in history with one event in buffer
362 //
363 AliDebug(AliLog::kDebug + 5, "<-");
364 AliDebug(AliLog::kDebug + 1, "Mix method");
365 // get correct handler
366 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
367 AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
368 AliInputEventHandler *inEvHMain = 0;
369 if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
370 else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
371 if (!inEvHMain) return kFALSE;
62e756a5 372
373 // check for PhysSelection
374 if (!IsEventCurrentSelected()) return kFALSE;
375
b425275c 376 // find out zero chain entries
377 Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetTree()->GetEntries();
378 // fill entry
379 Long64_t currentMainEntry = inEvHMain->GetTree()->GetTree()->GetReadEntry() + zeroChainEntries;
380 if (fEventPool && inEvHMain) fEventPool->AddEntry(currentMainEntry, inEvHMain->GetEvent());
381 // start of
382 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
383 // reset mix number
384 fNumberMixed = 0;
385 Long64_t elNum = 0;
386 Int_t idEntryList = -1;
387 TEntryList *el = 0;
388 if (fEventPool) el = fEventPool->FindEntryList(inEvHMain->GetEvent(), idEntryList);
389 // return in case of 0 entry in full chain
390 if (!fEntryCounter) {
06aad8b5 391 // runs UserExecMix for all tasks, if needed
917b33da 392 if (el && fDoMixIfNotEnoughEvents) {
393 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
394 } else {
395 idEntryList = -1;
396 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
397 }
b425275c 398 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (fEntryCounter=0, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
399 return kTRUE;
400 }
401 if (!el) {
402 if (fEventPool) {
403 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
404 UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
405 return kTRUE;
406 }
407 } else {
408 elNum = el->GetN();
409 if (elNum < fBufferSize + 1) {
917b33da 410 if (fDoMixIfNotEnoughEvents) {
411 // include main event in to counter in this case (so idEntryList>0)
412 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
413 } else {
414 // dont include it in main event counter (idEntryList = -1)
415 idEntryList = -1;
416 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
417 }
b425275c 418 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED [FIRST ENTRY in el] (elnum=%lld, idEntryList=%d) +++++++++++++++++++", fEntryCounter, elNum, idEntryList));
419 return kTRUE;
420 }
917b33da 421 if (!fDoMixIfNotEnoughEvents) {
422 if (elNum <= fMixNumber + 1) {
423 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
424 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (%lld) NOT ENOUGH EVENTS TO MIX => NEED=%d +++++++++++++++++++", fEntryCounter, elNum, fMixNumber + 1));
425 return kTRUE;
426 }
427 }
b425275c 428 }
429 // pre mix evetns
430 Int_t mixNum = fMixNumber;
917b33da 431 if (fDoMixExtra) {
b425275c 432 if (elNum <= 2 * fMixNumber + 1) mixNum = elNum + 1;
433 }
434 AliMixInputHandlerInfo *mihi = 0;
435 Long64_t entryMix = 0, entryMixReal = 0;
436 Int_t counter = 0;
437 mihi = (AliMixInputHandlerInfo *) fMixTrees.At(0);
438 // fills num for main events
439 for (counter = 0; counter < mixNum; counter++) {
440 Long64_t entryInEntryList = elNum - 2 - counter;
441 AliDebug(AliLog::kDebug + 3, Form("entryInEntryList=%lld", entryInEntryList));
442 if (entryInEntryList < 0) break;
443 entryMix = el->GetEntry(entryInEntryList);
444 AliDebug(AliLog::kDebug + 3, Form("entryMix=%lld", entryMix));
445 if (entryMix < 0) break;
446 entryMixReal = entryMix;
447 TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
448 if (!te) {
3bcab622 449 AliError("te is null. this is error. tell to developer (#2)");
b425275c 450 } else {
3bcab622 451 mihi->PrepareEntry(te, entryMix, (AliInputEventHandler *)InputEventHandler(0), fAnalysisType);
b425275c 452 // runs UserExecMix for all tasks
453 fNumberMixed++;
454 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, entryMixReal, fNumberMixed);
455 InputEventHandler(0)->FinishEvent();
456 }
457 }
458 AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
459 AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
460 AliDebug(AliLog::kDebug + 5, Form("->"));
461 AliDebug(AliLog::kDebug + 5, Form("->"));
462 return kTRUE;
463}
464
465//_____________________________________________________________________________
466Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithBuffer()
467{
468 //
469 // Mix more events in buffer with mixing with history
470 //
471 AliWarning("Not implemented");
472 return kFALSE;
473}
474
475//_____________________________________________________________________________
476Bool_t AliMixInputEventHandler::FinishEvent()
477{
478 //
479 // FinishEvent() is called for all mix input handlers
480 //
481 AliDebug(AliLog::kDebug + 5, Form("<-"));
482 AliMultiInputEventHandler::FinishEvent();
483 fEntryCounter++;
484 AliDebug(AliLog::kDebug + 5, Form("->"));
485 return kTRUE;
486}
487
488//_____________________________________________________________________________
3bcab622 489void AliMixInputEventHandler::AddInputEventHandler(AliVEventHandler *)
b425275c 490{
491 //
492 // AddInputEventHandler will not be used
493 //
494 AliWarning("Function AddInputEventHandler is disabled for AliMixEventInputHandler !!!");
495 AliWarning("Use AliMixEventInputHandler::SetInputHandlerForMixing instead. Exiting ...");
496}
497
498//_____________________________________________________________________________
499void AliMixInputEventHandler::UserExecMixAllTasks(Long64_t entryCounter, Int_t idEntryList, Long64_t entryMainReal, Long64_t entryMixReal, Int_t numMixed)
500{
501 //
502 // Execute all task and sets mixing parameters
503 //
504 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
505 AliAnalysisTaskSE *mixTask = 0;
506 TObjArrayIter next(mgr->GetTasks());
3bcab622 507 while ((mixTask = dynamic_cast<AliAnalysisTaskSE *>(next()))) {
b425275c 508 AliDebug(AliLog::kDebug, Form("%s %lld %d [%lld,%lld] %d", mixTask->GetName(), entryCounter, numMixed, entryMainReal, entryMixReal, idEntryList));
a86b14f8 509 fCurrentEntry = entryCounter;
510 fCurrentEntryMain = entryMainReal;
511 fCurrentEntryMix = entryMixReal;
512 fCurrentBinIndex = idEntryList;
513 if (entryMixReal >= 0) mixTask->UserExecMix("");
b425275c 514 }
515}
516
517//_____________________________________________________________________________
518void AliMixInputEventHandler::SetMixNumber(const Int_t mixNum)
519{
520 //
521 // Sets mix number
522 //
523 if (fMixNumber > 1 && fBufferSize > 1) {
3bcab622 524 AliWarning("Sleeping 10 sec to show Warning Message ...");
525 AliWarning("=========================================================================================");
b425275c 526 AliWarning(Form("BufferSize(%d) higher > 1 and fMixNumber(%d) > 1, which is not supported", fBufferSize, mixNum));
527 AliWarning("");
528 AliWarning("\tBufferSize will be set to 1");
529 AliWarning("");
530 AliWarning("Hints:");
531 AliWarning("");
532 AliWarning("\t1.If you want to use buffer do:");
533 AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(%d,1)", fBufferSize));
534 AliWarning("");
535 AliWarning("\t2.If you want to use mix more time with buffer size 1, then do:");
536 AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(1,%d)", mixNum));
537 AliWarning("");
538 AliWarning("=========================================================================================");
539 gSystem->Sleep(10000);
540 fBufferSize = 1;
541 }
542 fMixNumber = mixNum;
543}
62e756a5 544
545Bool_t AliMixInputEventHandler::IsEventCurrentSelected()
546{
547 AliDebug(AliLog::kDebug + 5, Form("<-"));
548 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
549 AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
550 Bool_t isSelected = kTRUE;
ddec4399 551 if (mh) {
552 if (fOfflineTriggerMask && mh->GetEventSelection()) {
553 isSelected = fOfflineTriggerMask & mh->IsEventSelected();
554 }
62e756a5 555 }
556 AliDebug(AliLog::kDebug + 1, Form("isSelected=%d", isSelected));
557 AliDebug(AliLog::kDebug + 5, Form("-> %d", isSelected));
558 return isSelected;
559}