Fix for event mixing when running in local mode. Mix event inputhandler was calling...
[u/mrichter/AliRoot.git] / ANALYSIS / EventMixing / AliMixInputEventHandler.cxx
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
26 ClassImp(AliMixInputEventHandler)
27
28 AliMixInputEventHandler::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),
37    fDoMixExtra(kTRUE),
38    fDoMixIfNotEnoughEvents(kTRUE),
39    fCurrentEntry(0),
40    fCurrentEntryMain(0),
41    fCurrentEntryMix(0),
42    fCurrentBinIndex(-1),
43    fOfflineTriggerMask(0)
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
54 //_____________________________________________________________________________
55 void 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    }
67
68    AliDebug(AliLog::kDebug + 5, Form("->"));
69 }
70
71 //_____________________________________________________________________________
72 Bool_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    }
84
85    if (!fDoMixIfNotEnoughEvents) {
86       fDoMixExtra = kFALSE;
87       AliWarning("fDoMixIfNotEnoughEvents=kTRUE -> setting fDoMixExtra=kFALSE");
88    }
89
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    }
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
106    AliDebug(AliLog::kDebug + 5, Form("->"));
107    return kTRUE;
108 }
109 //_____________________________________________________________________________
110 Bool_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 //_____________________________________________________________________________
125 Bool_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));
131    
132    Bool_t firstRun=(fMixIntupHandlerInfoTmp->GetChain()->GetEntries()<=0);
133    // adds current file
134    fMixIntupHandlerInfoTmp->AddTreeToChain(path);
135    Int_t lastIndex = fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->GetEntries();
136    TChainElement *che = (TChainElement *)fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->At(lastIndex - 1);
137    AliMixInputHandlerInfo *mixIHI = 0;
138    for (Int_t i = 0; i < fInputHandlers.GetEntries(); i++) {
139       AliDebug(AliLog::kDebug + 5, Form("fInputHandlers[%d]", i));
140       mixIHI = new AliMixInputHandlerInfo(fMixIntupHandlerInfoTmp->GetName(), fMixIntupHandlerInfoTmp->GetTitle());
141       if (firstRun) mixIHI->PrepareEntry(che, -1, (AliInputEventHandler*)InputEventHandler(i), fAnalysisType);
142       AliDebug(AliLog::kDebug + 5, Form("chain[%d]->GetEntries() = %lld", i, mixIHI->GetChain()->GetEntries()));
143       fMixTrees.Add(mixIHI);
144    }
145    AliDebug(AliLog::kDebug + 5, Form("fEntryCounter=%lld", fEntryCounter));
146    if (fEventPool && fEventPool->NeedInit())
147       fEventPool->Init();
148    if (fUseDefautProcess) {
149       AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
150       return AliMultiInputEventHandler::Notify(path);
151    }
152    AliDebug(AliLog::kDebug + 5, Form("->"));
153    return kTRUE;
154 }
155
156 //_____________________________________________________________________________
157 Bool_t AliMixInputEventHandler::BeginEvent(Long64_t entry)
158 {
159    //
160    // BeginEvent(Long64_t entry) is called for all mix input handlers
161    //
162    AliDebug(AliLog::kDebug + 5, Form("-> %lld", entry));
163    if (fUseDefautProcess) {
164       AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
165       AliMultiInputEventHandler::BeginEvent(entry);/* return GetEntry();*/
166    }
167    AliDebug(AliLog::kDebug + 5, Form("->"));
168    return kTRUE;
169 }
170 //_____________________________________________________________________________
171 Bool_t AliMixInputEventHandler::GetEntry()
172 {
173    //
174    // All mixed events are set
175    //
176    AliDebug(AliLog::kDebug + 5, Form("<-"));
177
178    if (!fEventPool) {
179       MixStd();
180    }
181    // if buffer size is higher then 1
182    else if (fBufferSize > 1) {
183       MixBuffer();
184    }
185    // if mix number is higher then 0 and buffer size is 1
186    else if (fMixNumber > 0) {
187       MixEventsMoreTimesWithOneEvent();
188    } else {
189       AliWarning("Not supported Mixing !!!");
190    }
191
192    AliDebug(AliLog::kDebug + 5, Form("->"));
193    return kTRUE;
194 }
195
196 //_____________________________________________________________________________
197 Bool_t AliMixInputEventHandler::MixStd()
198 {
199    //
200    // Mix std - No event pool
201    //
202    AliDebug(AliLog::kDebug + 5, Form("<-"));
203    AliDebug(AliLog::kDebug + 1, "Mix method");
204    // get correct handler
205    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
206    AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
207    AliInputEventHandler *inEvHMain = 0;
208    if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
209    else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
210    if (!inEvHMain) return kFALSE;
211
212    // check for PhysSelection
213    if (!IsEventCurrentSelected()) return kFALSE;
214
215    // return in case of 0 entry in full chain
216    if (!fEntryCounter) {
217       AliDebug(AliLog::kDebug + 3, Form("-> fEntryCounter == 0"));
218       // runs UserExecMix for all tasks, if needed
219       UserExecMixAllTasks(fEntryCounter, 1, fEntryCounter, -1, 0);
220       return kTRUE;
221    }
222    // pre mix evetns
223    Int_t mixNum = fMixNumber;
224    if (fDoMixExtra) {
225       if (fEntryCounter <= 2 * fMixNumber) mixNum = 2 * fMixNumber + 2;
226    }
227    // start of
228    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
229    // reset mix number
230    fNumberMixed = 0;
231    AliMixInputHandlerInfo *mihi = 0;
232    Long64_t entryMix = 0, entryMixReal = 0;
233    Int_t counter = 0;
234    for (counter = 0; counter < mixNum; counter++) {
235       entryMix = fEntryCounter - 1 - counter ;
236       AliDebug(AliLog::kDebug + 5, Form("Handler[%d] entryMix %lld ", counter, entryMix));
237       if (entryMix < 0) break;
238       entryMixReal = entryMix;
239       mihi = (AliMixInputHandlerInfo *) fMixTrees.At(0);
240       TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
241       if (!te) {
242         AliError("te is null. this is error. tell to developer (#1)");
243       } else {
244          mihi->PrepareEntry(te, entryMix, (AliInputEventHandler*)InputEventHandler(0), fAnalysisType);
245          // runs UserExecMix for all tasks
246          fNumberMixed++;
247          UserExecMixAllTasks(fEntryCounter, 1, fEntryCounter, entryMixReal, fNumberMixed);
248          InputEventHandler(0)->FinishEvent();
249       }
250    }
251    AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
252    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
253    AliDebug(AliLog::kDebug + 5, Form("->"));
254    AliDebug(AliLog::kDebug + 5, Form("->"));
255    return kTRUE;
256 }
257
258 //_____________________________________________________________________________
259 Bool_t AliMixInputEventHandler::MixBuffer()
260 {
261    //
262    // Mix in event buffer
263    //
264    AliDebug(AliLog::kDebug + 5, Form("<-"));
265    AliDebug(AliLog::kDebug + 1, "Mix method");
266    // get correct handler
267    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
268    AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
269    AliInputEventHandler *inEvHMain = 0;
270    if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
271    else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
272    if (!inEvHMain) return kFALSE;
273
274    // check for PhysSelection
275    if (!IsEventCurrentSelected()) return kFALSE;
276
277    // find out zero chain entries
278    Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetTree()->GetEntries();
279    // fill entry
280    Long64_t currentMainEntry = inEvHMain->GetTree()->GetTree()->GetReadEntry() + zeroChainEntries;
281    // fills entry
282    if (fEventPool && inEvHMain) fEventPool->AddEntry(currentMainEntry, inEvHMain->GetEvent());
283    // start of
284    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
285    // reset mix number
286    fNumberMixed = 0;
287    Long64_t elNum = 0;
288    TEntryList *el = 0;
289    Int_t idEntryList = -1;
290    if (fEventPool) el = fEventPool->FindEntryList(inEvHMain->GetEvent(), idEntryList);
291    // return in case of 0 entry in full chain
292    if (!fEntryCounter) {
293       AliDebug(AliLog::kDebug + 3, Form("-> fEntryCounter == 0"));
294       // runs UserExecMix for all tasks, if needed
295       if (el) UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
296       else UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
297       return kTRUE;
298    }
299    if (!el) {
300       AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null) +++++++++++++++++++", fEntryCounter));
301       UserExecMixAllTasks(fEntryCounter, -1, fEntryCounter, -1, 0);
302       return kTRUE;
303    } else {
304       elNum = el->GetN();
305       if (elNum < fBufferSize + 1) {
306          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
307          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (%lld) LESS THEN BUFFER +++++++++++++++++++", fEntryCounter, elNum));
308          return kTRUE;
309       }
310    }
311    AliMixInputHandlerInfo *mihi = 0;
312    Long64_t entryMix = 0, entryMixReal = 0;
313    Int_t counter = 0;
314    AliInputEventHandler *eh = 0;
315    TObjArrayIter next(&fInputHandlers);
316    while ((eh = dynamic_cast<AliInputEventHandler *>(next()))) {
317       if (fEventPool && fEventPool->GetListOfEventCuts()->GetEntries() > 0) {
318          entryMix = -1;
319          if (elNum >= fBufferSize) {
320             Long64_t entryInEntryList =  elNum - 2 - counter;
321             if (entryInEntryList < 0) break;
322             entryMix = el->GetEntry(entryInEntryList);
323          }
324       }
325       AliDebug(AliLog::kDebug + 5, Form("Handler[%d] entryMix %lld ", counter, entryMix));
326       if (entryMix < 0) {
327          UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
328          break;
329       }
330       entryMixReal = entryMix;
331       mihi = (AliMixInputHandlerInfo *) fMixTrees.At(counter);
332       TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
333       if (!te) {
334         AliError("te is null. this is error. tell to developer (#1)");
335       } else {
336          AliDebug(AliLog::kDebug + 3, Form("Preparing InputEventHandler(%d)", counter));
337          mihi->PrepareEntry(te, entryMix, (AliInputEventHandler*)InputEventHandler(counter), fAnalysisType);
338          // runs UserExecMix for all tasks
339          UserExecMixAllTasks(fEntryCounter, idEntryList, fEntryCounter, entryMixReal, counter);
340          fNumberMixed++;
341       }
342       counter++;
343    }
344    AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
345    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
346    AliDebug(AliLog::kDebug + 5, Form("->"));
347    AliDebug(AliLog::kDebug + 5, Form("->"));
348    return kTRUE;
349 }
350
351 //_____________________________________________________________________________
352 Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithOneEvent()
353 {
354    //
355    // Mix in history with one event in buffer
356    //
357    AliDebug(AliLog::kDebug + 5, "<-");
358    AliDebug(AliLog::kDebug + 1, "Mix method");
359    // get correct handler
360    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
361    AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
362    AliInputEventHandler *inEvHMain = 0;
363    if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
364    else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
365    if (!inEvHMain) return kFALSE;
366
367    // check for PhysSelection
368    if (!IsEventCurrentSelected()) return kFALSE;
369
370    // find out zero chain entries
371    Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetTree()->GetEntries();
372    // fill entry
373    Long64_t currentMainEntry = inEvHMain->GetTree()->GetTree()->GetReadEntry() + zeroChainEntries;
374    if (fEventPool && inEvHMain) fEventPool->AddEntry(currentMainEntry, inEvHMain->GetEvent());
375    // start of
376    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
377    // reset mix number
378    fNumberMixed = 0;
379    Long64_t elNum = 0;
380    Int_t idEntryList = -1;
381    TEntryList *el = 0;
382    if (fEventPool) el = fEventPool->FindEntryList(inEvHMain->GetEvent(), idEntryList);
383    // return in case of 0 entry in full chain
384    if (!fEntryCounter) {
385       // runs UserExecMix for all tasks, if needed
386       if (el && fDoMixIfNotEnoughEvents) {
387          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
388       } else {
389          idEntryList = -1;
390          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
391       }
392       AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (fEntryCounter=0, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
393       return kTRUE;
394    }
395    if (!el) {
396       if (fEventPool) {
397          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
398          UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
399          return kTRUE;
400       }
401    } else {
402       elNum = el->GetN();
403       if (elNum < fBufferSize + 1) {
404          if (fDoMixIfNotEnoughEvents) {
405             // include main event in to counter in this case (so idEntryList>0)
406             UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
407          }  else {
408             // dont include it in main event counter (idEntryList = -1)
409             idEntryList = -1;
410             UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
411          }
412          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED [FIRST ENTRY in el] (elnum=%lld, idEntryList=%d) +++++++++++++++++++", fEntryCounter, elNum, idEntryList));
413          return kTRUE;
414       }
415       if (!fDoMixIfNotEnoughEvents) {
416          if (elNum <= fMixNumber + 1) {
417             UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
418             AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (%lld) NOT ENOUGH EVENTS TO MIX => NEED=%d +++++++++++++++++++", fEntryCounter, elNum, fMixNumber + 1));
419             return kTRUE;
420          }
421       }
422    }
423    // pre mix evetns
424    Int_t mixNum = fMixNumber;
425    if (fDoMixExtra) {
426       if (elNum <= 2 * fMixNumber + 1) mixNum = elNum + 1;
427    }
428    AliMixInputHandlerInfo *mihi = 0;
429    Long64_t entryMix = 0, entryMixReal = 0;
430    Int_t counter = 0;
431    mihi = (AliMixInputHandlerInfo *) fMixTrees.At(0);
432    // fills num for main events
433    for (counter = 0; counter < mixNum; counter++) {
434       Long64_t entryInEntryList =  elNum - 2 - counter;
435       AliDebug(AliLog::kDebug + 3, Form("entryInEntryList=%lld", entryInEntryList));
436       if (entryInEntryList < 0) break;
437       entryMix = el->GetEntry(entryInEntryList);
438       AliDebug(AliLog::kDebug + 3, Form("entryMix=%lld", entryMix));
439       if (entryMix < 0) break;
440       entryMixReal = entryMix;
441       TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
442       if (!te) {
443         AliError("te is null. this is error. tell to developer (#2)");
444       } else {
445          mihi->PrepareEntry(te, entryMix, (AliInputEventHandler*)InputEventHandler(0), fAnalysisType);
446          // runs UserExecMix for all tasks
447          fNumberMixed++;
448          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, entryMixReal, fNumberMixed);
449          InputEventHandler(0)->FinishEvent();
450       }
451    }
452    AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
453    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
454    AliDebug(AliLog::kDebug + 5, Form("->"));
455    AliDebug(AliLog::kDebug + 5, Form("->"));
456    return kTRUE;
457 }
458
459 //_____________________________________________________________________________
460 Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithBuffer()
461 {
462    //
463    // Mix more events in buffer with mixing with history
464    //
465    AliWarning("Not implemented");
466    return kFALSE;
467 }
468
469 //_____________________________________________________________________________
470 Bool_t AliMixInputEventHandler::FinishEvent()
471 {
472    //
473    // FinishEvent() is called for all mix input handlers
474    //
475    AliDebug(AliLog::kDebug + 5, Form("<-"));
476    AliMultiInputEventHandler::FinishEvent();
477    fEntryCounter++;
478    AliDebug(AliLog::kDebug + 5, Form("->"));
479    return kTRUE;
480 }
481
482 //_____________________________________________________________________________
483 void AliMixInputEventHandler::AddInputEventHandler(AliVEventHandler*)
484 {
485    //
486    // AddInputEventHandler will not be used
487    //
488    AliWarning("Function AddInputEventHandler is disabled for AliMixEventInputHandler !!!");
489    AliWarning("Use AliMixEventInputHandler::SetInputHandlerForMixing instead. Exiting ...");
490 }
491
492 //_____________________________________________________________________________
493 void AliMixInputEventHandler::UserExecMixAllTasks(Long64_t entryCounter, Int_t idEntryList, Long64_t entryMainReal, Long64_t entryMixReal, Int_t numMixed)
494 {
495    //
496    // Execute all task and sets mixing parameters
497    //
498    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
499    AliAnalysisTaskSE *mixTask = 0;
500    TObjArrayIter next(mgr->GetTasks());
501    while ((mixTask = (AliAnalysisTaskSE *) next())) {
502       if (dynamic_cast<AliAnalysisTaskSE *>(mixTask)) {
503          AliDebug(AliLog::kDebug, Form("%s %lld %d [%lld,%lld] %d", mixTask->GetName(), entryCounter, numMixed, entryMainReal, entryMixReal, idEntryList));
504          fCurrentEntry = entryCounter;
505          fCurrentEntryMain = entryMainReal;
506          fCurrentEntryMix = entryMixReal;
507          fCurrentBinIndex = idEntryList;
508          if (entryMixReal >= 0) mixTask->UserExecMix("");
509       }
510    }
511 }
512
513 //_____________________________________________________________________________
514 void AliMixInputEventHandler::SetMixNumber(const Int_t mixNum)
515 {
516    //
517    // Sets mix number
518    //
519    if (fMixNumber > 1 && fBufferSize > 1) {
520      AliWarning("Sleeping 10 sec to show Warning Message ...");
521      AliWarning("=========================================================================================");
522       AliWarning(Form("BufferSize(%d) higher > 1 and fMixNumber(%d) > 1, which is not supported", fBufferSize, mixNum));
523       AliWarning("");
524       AliWarning("\tBufferSize will be set to 1");
525       AliWarning("");
526       AliWarning("Hints:");
527       AliWarning("");
528       AliWarning("\t1.If you want to use buffer do:");
529       AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(%d,1)", fBufferSize));
530       AliWarning("");
531       AliWarning("\t2.If you want to use mix more time with buffer size 1, then do:");
532       AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(1,%d)", mixNum));
533       AliWarning("");
534       AliWarning("=========================================================================================");
535       gSystem->Sleep(10000);
536       fBufferSize = 1;
537    }
538    fMixNumber = mixNum;
539 }
540
541 Bool_t AliMixInputEventHandler::IsEventCurrentSelected()
542 {
543    AliDebug(AliLog::kDebug + 5, Form("<-"));
544    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
545    AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
546    Bool_t isSelected = kTRUE;
547    if (mh) {
548       if (fOfflineTriggerMask && mh->GetEventSelection()) {
549          isSelected = fOfflineTriggerMask & mh->IsEventSelected();
550       }
551    }
552    AliDebug(AliLog::kDebug + 1, Form("isSelected=%d", isSelected));
553    AliDebug(AliLog::kDebug + 5, Form("-> %d", isSelected));
554    return isSelected;
555 }