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