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 (kFALSE means that UserExecMix is not called)
 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 (kFALSE means that UserExecMix is not called)
 302       UserExecMixAllTasks(fEntryCounter, idEntryList, fEntryCounter, -1, 0);
 303       return kTRUE;
 304    }
 305    if (!el) {
 306       AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null) +++++++++++++++++++", fEntryCounter));
 307       UserExecMixAllTasks(fEntryCounter, -1, fEntryCounter, -1, 0);
 308       return kTRUE;
 309    } else {
 310       elNum = el->GetN();
 311       if (elNum < fBufferSize + 1) {
 312          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (%lld) +++++++++++++++++++", fEntryCounter, elNum));
 313          return kTRUE;
 314       }
 315    }
 316    AliMixInputHandlerInfo *mihi = 0;
 317    Long64_t entryMix = 0, entryMixReal = 0;
 318    Int_t counter = 0;
 319    AliInputEventHandler *eh = 0;
 320    TObjArrayIter next(&fInputHandlers);
 321    while ((eh = (AliInputEventHandler *) next())) {
 322       if (fEventPool && fEventPool->GetListOfEventCuts()->GetEntries() > 0) {
 323          entryMix = -1;
 324          if (elNum >= fBufferSize) {
 325             Long64_t entryInEntryList =  elNum - 2 - counter;
 326             if (entryInEntryList < 0) break;
 327             entryMix = el->GetEntry(entryInEntryList);
 328          }
 329       }
 330       AliDebug(AliLog::kDebug + 5, Form("Handler[%d] entryMix %lld ", counter, entryMix));
 331       if (entryMix < 0) {
 332          UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
 333          break;
 334       }
 335       entryMixReal = entryMix;
 336       mihi = (AliMixInputHandlerInfo *) fMixTrees.At(counter);
 337       TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
 338       if (!te) {
 339          AliError("te is null. this is error. tell to developer (#1)")
 340       } else {
 341          AliDebug(AliLog::kDebug + 3, Form("Preparing InputEventHandler(%d)", counter));
 342          mihi->PrepareEntry(te, entryMix, InputEventHandler(counter), fAnalysisType);
 343          // runs UserExecMix for all tasks
 344          UserExecMixAllTasks(fEntryCounter, idEntryList, fEntryCounter, entryMixReal, counter);
 345          fNumberMixed++;
 346       }
 347       counter++;
 348    }
 349    AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
 350    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
 351    AliDebug(AliLog::kDebug + 5, Form("->"));
 352    AliDebug(AliLog::kDebug + 5, Form("->"));
 353    return kTRUE;
 354 }
 355
 356 //_____________________________________________________________________________
 357 Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithOneEvent()
 358 {
 359    //
 360    // Mix in history with one event in buffer
 361    //
 362    AliDebug(AliLog::kDebug + 5, "<-");
 363    AliDebug(AliLog::kDebug + 1, "Mix method");
 364    // get correct handler
 365    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 366    AliMultiInputEventHandler *mh = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
 367    AliInputEventHandler *inEvHMain = 0;
 368    if (mh) inEvHMain = dynamic_cast<AliInputEventHandler *>(mh->GetFirstInputEventHandler());
 369    else inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
 370    if (!inEvHMain) return kFALSE;
 371    // find out zero chain entries
 372    Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetTree()->GetEntries();
 373    // fill entry
 374    Long64_t currentMainEntry = inEvHMain->GetTree()->GetTree()->GetReadEntry() + zeroChainEntries;
 375    if (fEventPool && inEvHMain) fEventPool->AddEntry(currentMainEntry, inEvHMain->GetEvent());
 376    // start of
 377    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
 378    // reset mix number
 379    fNumberMixed = 0;
 380    Long64_t elNum = 0;
 381    Int_t idEntryList = -1;
 382    TEntryList *el = 0;
 383    if (fEventPool) el = fEventPool->FindEntryList(inEvHMain->GetEvent(), idEntryList);
 384    // return in case of 0 entry in full chain
 385    if (!fEntryCounter) {
 386       // runs UserExecMix for all tasks (kFALSE means that UserExecMix is not called)
 387       UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 388       AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (fEntryCounter=0, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
 389       return kTRUE;
 390    }
 391    if (!el) {
 392       if (fEventPool) {
 393          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED (el null, idEntryList=%d) +++++++++++++++++++", fEntryCounter, idEntryList));
 394          UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
 395          return kTRUE;
 396       }
 397    } else {
 398       elNum = el->GetN();
 399       if (elNum < fBufferSize + 1) {
 400          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
 401          AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld SKIPPED [FIRST ENTRY in el] (elnum=%lld, idEntryList=%d) +++++++++++++++++++", fEntryCounter, elNum, idEntryList));
 402          return kTRUE;
 403       }
 404    }
 405    // pre mix evetns
 406    Int_t mixNum = fMixNumber;
 407    if (fUsePreMixEvents) {
 408       if (elNum <= 2 * fMixNumber + 1) mixNum = elNum + 1;
 409    }
 410    AliMixInputHandlerInfo *mihi = 0;
 411    Long64_t entryMix = 0, entryMixReal = 0;
 412    Int_t counter = 0;
 413    mihi = (AliMixInputHandlerInfo *) fMixTrees.At(0);
 414    // fills num for main events
 415    for (counter = 0; counter < mixNum; counter++) {
 416       Long64_t entryInEntryList =  elNum - 2 - counter;
 417       AliDebug(AliLog::kDebug + 3, Form("entryInEntryList=%lld", entryInEntryList));
 418       if (entryInEntryList < 0) break;
 419       entryMix = el->GetEntry(entryInEntryList);
 420       AliDebug(AliLog::kDebug + 3, Form("entryMix=%lld", entryMix));
 421       if (entryMix < 0) break;
 422       entryMixReal = entryMix;
 423       TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
 424       if (!te) {
 425          AliError("te is null. this is error. tell to developer (#2)")
 426       } else {
 427          mihi->PrepareEntry(te, entryMix, InputEventHandler(0), fAnalysisType);
 428          // runs UserExecMix for all tasks
 429          fNumberMixed++;
 430          UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, entryMixReal, fNumberMixed);
 431          InputEventHandler(0)->FinishEvent();
 432       }
 433    }
 434    AliDebug(AliLog::kDebug + 3, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fNumberMixed));
 435    AliDebug(AliLog::kDebug + 3, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
 436    AliDebug(AliLog::kDebug + 5, Form("->"));
 437    AliDebug(AliLog::kDebug + 5, Form("->"));
 438    return kTRUE;
 439 }
 440
 441 //_____________________________________________________________________________
 442 Bool_t AliMixInputEventHandler::MixEventsMoreTimesWithBuffer()
 443 {
 444    //
 445    // Mix more events in buffer with mixing with history
 446    //
 447    AliWarning("Not implemented");
 448    return kFALSE;
 449 }
 450
 451 //_____________________________________________________________________________
 452 Bool_t AliMixInputEventHandler::FinishEvent()
 453 {
 454    //
 455    // FinishEvent() is called for all mix input handlers
 456    //
 457    AliDebug(AliLog::kDebug + 5, Form("<-"));
 458    AliMultiInputEventHandler::FinishEvent();
 459    fEntryCounter++;
 460    AliDebug(AliLog::kDebug + 5, Form("->"));
 461    return kTRUE;
 462 }
 463
 464 //_____________________________________________________________________________
 465 void AliMixInputEventHandler::AddInputEventHandler(AliVEventHandler*)
 466 {
 467    //
 468    // AddInputEventHandler will not be used
 469    //
 470    AliWarning("Function AddInputEventHandler is disabled for AliMixEventInputHandler !!!");
 471    AliWarning("Use AliMixEventInputHandler::SetInputHandlerForMixing instead. Exiting ...");
 472 }
 473
 474 //_____________________________________________________________________________
 475 void AliMixInputEventHandler::UserExecMixAllTasks(Long64_t entryCounter, Int_t idEntryList, Long64_t entryMainReal, Long64_t entryMixReal, Int_t numMixed)
 476 {
 477    //
 478    // Execute all task and sets mixing parameters
 479    //
 480    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 481    AliAnalysisTaskSE *mixTask = 0;
 482    TObjArrayIter next(mgr->GetTasks());
 483    while ((mixTask = (AliAnalysisTaskSE *) next())) {
 484       if (dynamic_cast<AliAnalysisTaskSE *>(mixTask)) {
 485          AliDebug(AliLog::kDebug, Form("%s %lld %d [%lld,%lld] %d", mixTask->GetName(), entryCounter, numMixed, entryMainReal, entryMixReal, idEntryList));
 486 //          mixTask->SetCurrentBinIndex(idEntryList);
 487 //          mixTask->SetCurrentEntry(entryCounter);
 488 //          mixTask->SetCurrentEntryMain(entryMainReal);
 489 //          mixTask->SetCurrentEntryMix(entryMixReal);
 490 //          mixTask->SetNumberMixed(numMixed);
 491          fCurrentEntry = idEntryList;
 492          fCurrentEntryMain = entryCounter;
 493          fCurrentEntryMix = entryMainReal;
 494          fCurrentBinIndex = entryMixReal;
 495
 496          if (entryMixReal > -1) mixTask->UserExecMix("");
 497       }
 498    }
 499 }
 500
 501 //_____________________________________________________________________________
 502 void AliMixInputEventHandler::SetMixNumber(const Int_t mixNum)
 503 {
 504    //
 505    // Sets mix number
 506    //
 507    if (fMixNumber > 1 && fBufferSize > 1) {
 508       AliWarning("Sleeping 10 sec to show Warning Message ...")
 509       AliWarning("=========================================================================================");
 510       AliWarning(Form("BufferSize(%d) higher > 1 and fMixNumber(%d) > 1, which is not supported", fBufferSize, mixNum));
 511       AliWarning("");
 512       AliWarning("\tBufferSize will be set to 1");
 513       AliWarning("");
 514       AliWarning("Hints:");
 515       AliWarning("");
 516       AliWarning("\t1.If you want to use buffer do:");
 517       AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(%d,1)", fBufferSize));
 518       AliWarning("");
 519       AliWarning("\t2.If you want to use mix more time with buffer size 1, then do:");
 520       AliWarning(Form("\t\tAliMixInputEventHandler *mixH = new AliMixInputEventHandler(1,%d)", mixNum));
 521       AliWarning("");
 522       AliWarning("=========================================================================================");
 523       gSystem->Sleep(10000);
 524       fBufferSize = 1;
 525    }
 526    fMixNumber = mixNum;
 527 }