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