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    // adds current file
 132    fMixIntupHandlerInfoTmp->AddTreeToChain(path);
 133    Int_t lastIndex = fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->GetEntries();
 134    TChainElement *che = (TChainElement *)fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->At(lastIndex - 1);
 135    AliMixInputHandlerInfo *mixIHI = 0;
 136    for (Int_t i = 0; i < fInputHandlers.GetEntries(); i++) {
 137       AliDebug(AliLog::kDebug + 5, Form("fInputHandlers[%d]", i));
 138       mixIHI = new AliMixInputHandlerInfo(fMixIntupHandlerInfoTmp->GetName(), fMixIntupHandlerInfoTmp->GetTitle());
 139       mixIHI->PrepareEntry(che, -1, (AliInputEventHandler*)InputEventHandler(i), fAnalysisType);
 140       AliDebug(AliLog::kDebug + 5, Form("chain[%d]->GetEntries() = %lld", i, mixIHI->GetChain()->GetEntries()));
 141       fMixTrees.Add(mixIHI);
 142    }
 143    AliDebug(AliLog::kDebug + 5, Form("fEntryCounter=%lld", fEntryCounter));
 144    if (fEventPool && fEventPool->NeedInit())
 145       fEventPool->Init();
 146    if (fUseDefautProcess) {
 147       AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
 148       return AliMultiInputEventHandler::Notify(path);
 149    }
 150    AliDebug(AliLog::kDebug + 5, Form("->"));
 151    return kTRUE;
 152 }
 153
 154 //_____________________________________________________________________________
 155 Bool_t AliMixInputEventHandler::BeginEvent(Long64_t entry)
 156 {
 157    //
 158    // BeginEvent(Long64_t entry) is called for all mix input handlers
 159    //
 160    AliDebug(AliLog::kDebug + 5, Form("-> %lld", entry));
 161    if (fUseDefautProcess) {
 162       AliDebug(AliLog::kDebug, Form("-> SKIPPED"));
 163       AliMultiInputEventHandler::BeginEvent(entry);/* return GetEntry();*/
 164    }
 165    AliDebug(AliLog::kDebug + 5, Form("->"));
 166    return kTRUE;
 167 }
 168 //_____________________________________________________________________________
 169 Bool_t AliMixInputEventHandler::GetEntry()
 170 {
 171    //
 172    // All mixed events are set
 173    //
 174    AliDebug(AliLog::kDebug + 5, Form("<-"));
 175
 176    if (!fEventPool) {
 177       MixStd();
 178    }
 179    // if buffer size is higher then 1
 180    else if (fBufferSize > 1) {
 181       MixBuffer();
 182    }
 183    // if mix number is higher then 0 and buffer size is 1
 184    else if (fMixNumber > 0) {
 185       MixEventsMoreTimesWithOneEvent();
 186    } else {
 187       AliWarning("Not supported Mixing !!!");
 188    }
 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 (fDoMixExtra) {
 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, (AliInputEventHandler*)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) LESS THEN BUFFER +++++++++++++++++++", 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, (AliInputEventHandler*)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 && fDoMixIfNotEnoughEvents) {
 385          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 386       } else {
 387          idEntryList = -1;
 388          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 389       }
 390       AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (fEntryCounter=0, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
 391       return kTRUE;
 392    }
 393    if (!el) {
 394       if (fEventPool) {
 395          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
 396          UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
 397          return kTRUE;
 398       }
 399    } else {
 400       elNum = el->GetN();
 401       if (elNum < fBufferSize + 1) {
 402          if (fDoMixIfNotEnoughEvents) {
 403             // include main event in to counter in this case (so idEntryList>0)
 404             UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 405          }  else {
 406             // dont include it in main event counter (idEntryList = -1)
 407             idEntryList = -1;
 408             UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 409          }
 410          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED [FIRST ENTRY in el] (elnum=%lld, idEntryList=%d) +++++++++++++++++++", fEntryCounter, elNum, idEntryList));
 411          return kTRUE;
 412       }
 413       if (!fDoMixIfNotEnoughEvents) {
 414          if (elNum <= fMixNumber + 1) {
 415             UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 416             AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (%lld) NOT ENOUGH EVENTS TO MIX => NEED=%d +++++++++++++++++++", fEntryCounter, elNum, fMixNumber + 1));
 417             return kTRUE;
 418          }
 419       }
 420    }
 421    // pre mix evetns
 422    Int_t mixNum = fMixNumber;
 423    if (fDoMixExtra) {
 424       if (elNum <= 2 * fMixNumber + 1) mixNum = elNum + 1;
 425    }
 426    AliMixInputHandlerInfo *mihi = 0;
 427    Long64_t entryMix = 0, entryMixReal = 0;
 428    Int_t counter = 0;
 429    mihi = (AliMixInputHandlerInfo *) fMixTrees.At(0);
 430    // fills num for main events
 431    for (counter = 0; counter < mixNum; counter++) {
 432       Long64_t entryInEntryList =  elNum - 2 - counter;
 433       AliDebug(AliLog::kDebug + 3, Form("entryInEntryList=%lld", entryInEntryList));
 434       if (entryInEntryList < 0) break;
 435       entryMix = el->GetEntry(entryInEntryList);
 436       AliDebug(AliLog::kDebug + 3, Form("entryMix=%lld", entryMix));
 437       if (entryMix < 0) break;
 438       entryMixReal = entryMix;
 439       TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
 440       if (!te) {
 441          AliError("te is null. this is error. tell to developer (#2)")
 442       } else {
 443          mihi->PrepareEntry(te, entryMix, (AliInputEventHandler*)InputEventHandler(0), fAnalysisType);
 444          // runs UserExecMix for all tasks
 445          fNumberMixed++;
 446          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, entryMixReal, fNumberMixed);
 447          InputEventHandler(0)->FinishEvent();
 448       }
 449    }
 450    AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
 451    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
 452    AliDebug(AliLog::kDebug + 5, Form("->"));
 453    AliDebug(AliLog::kDebug + 5, Form("->"));
 454    return kTRUE;
 455 }
 456
 457 //_____________________________________________________________________________
 458 Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithBuffer()
 459 {
 460    //
 461    // Mix more events in buffer with mixing with history
 462    //
 463    AliWarning("Not implemented");
 464    return kFALSE;
 465 }
 466
 467 //_____________________________________________________________________________
 468 Bool_t AliMixInputEventHandler::FinishEvent()
 469 {
 470    //
 471    // FinishEvent() is called for all mix input handlers
 472    //
 473    AliDebug(AliLog::kDebug + 5, Form("<-"));
 474    AliMultiInputEventHandler::FinishEvent();
 475    fEntryCounter++;
 476    AliDebug(AliLog::kDebug + 5, Form("->"));
 477    return kTRUE;
 478 }
 479
 480 //_____________________________________________________________________________
 481 void AliMixInputEventHandler::AddInputEventHandler(AliVEventHandler*)
 482 {
 483    //
 484    // AddInputEventHandler will not be used
 485    //
 486    AliWarning("Function AddInputEventHandler is disabled for AliMixEventInputHandler !!!");
 487    AliWarning("Use AliMixEventInputHandler::SetInputHandlerForMixing instead. Exiting ...");
 488 }
 489
 490 //_____________________________________________________________________________
 491 void AliMixInputEventHandler::UserExecMixAllTasks(Long64_t entryCounter, Int_t idEntryList, Long64_t entryMainReal, Long64_t entryMixReal, Int_t numMixed)
 492 {
 493    //
 494    // Execute all task and sets mixing parameters
 495    //
 496    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 497    AliAnalysisTaskSE *mixTask = 0;
 498    TObjArrayIter next(mgr->GetTasks());
 499    while ((mixTask = (AliAnalysisTaskSE *) next())) {
 500       if (dynamic_cast<AliAnalysisTaskSE *>(mixTask)) {
 501          AliDebug(AliLog::kDebug, Form("%s %lld %d [%lld,%lld] %d", mixTask->GetName(), entryCounter, numMixed, entryMainReal, entryMixReal, idEntryList));
 502          fCurrentEntry = entryCounter;
 503          fCurrentEntryMain = entryMainReal;
 504          fCurrentEntryMix = entryMixReal;
 505          fCurrentBinIndex = idEntryList;
 506          if (entryMixReal >= 0) mixTask->UserExecMix("");
 507       }
 508    }
 509 }
 510
 511 //_____________________________________________________________________________
 512 void AliMixInputEventHandler::SetMixNumber(const Int_t mixNum)
 513 {
 514    //
 515    // Sets mix number
 516    //
 517    if (fMixNumber > 1 && fBufferSize > 1) {
 518       AliWarning("Sleeping 10 sec to show Warning Message ...")
 519       AliWarning("=========================================================================================");
 520       AliWarning(Form("BufferSize(%d) higher > 1 and fMixNumber(%d) > 1, which is not supported", fBufferSize, mixNum));
 521       AliWarning("");
 522       AliWarning("\tBufferSize will be set to 1");
 523       AliWarning("");
 524       AliWarning("Hints:");
 525       AliWarning("");
 526       AliWarning("\t1.If you want to use buffer do:");
 527       AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(%d,1)", fBufferSize));
 528       AliWarning("");
 529       AliWarning("\t2.If you want to use mix more time with buffer size 1, then do:");
 530       AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(1,%d)", mixNum));
 531       AliWarning("");
 532       AliWarning("=========================================================================================");
 533       gSystem->Sleep(10000);
 534       fBufferSize = 1;
 535    }
 536    fMixNumber = mixNum;
 537 }
 538
 539 Bool_t AliMixInputEventHandler::IsEventCurrentSelected()
 540 {
 541    AliDebug(AliLog::kDebug + 5, Form("<-"));
 542    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 543    AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
 544    Bool_t isSelected = kTRUE;
 545    if (mh) {
 546       if (fOfflineTriggerMask && mh->GetEventSelection()) {
 547          isSelected = fOfflineTriggerMask & mh->IsEventSelected();
 548       }
 549    }
 550    AliDebug(AliLog::kDebug + 1, Form("isSelected=%d", isSelected));
 551    AliDebug(AliLog::kDebug + 5, Form("-> %d", isSelected));
 552    return isSelected;
 553 }