]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ANALYSIS/EventMixing/AliMixInputEventHandler.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Added Physiscs selection support to Event Mixing
[u/mrichter/AliRoot.git] / ANALYSIS / EventMixing / AliMixInputEventHandler.cxx
CommitLineData
b425275c 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
26ClassImp(AliMixInputEventHandler)
27
28AliMixInputEventHandler::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//_____________________________________________________________________________
53AliInputEventHandler *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//_____________________________________________________________________________
71void 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//_____________________________________________________________________________
87Bool_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 }
b425275c 107 AliDebug(AliLog::kDebug + 5, Form("->"));
108 return kTRUE;
109}
110//_____________________________________________________________________________
111Bool_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//_____________________________________________________________________________
126Bool_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//_____________________________________________________________________________
156Bool_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//_____________________________________________________________________________
170Bool_t AliMixInputEventHandler::GetEntry()
171{
172 //
173 // All mixed events are set
174 //
175 AliDebug(AliLog::kDebug + 5, Form("<-"));
62e756a5 176
b425275c 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//_____________________________________________________________________________
195Bool_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;
62e756a5 209
210 // check for PhysSelection
211 if (!IsEventCurrentSelected()) return kFALSE;
212
b425275c 213 // return in case of 0 entry in full chain
214 if (!fEntryCounter) {
215 AliDebug(AliLog::kDebug + 3, Form("-> fEntryCounter == 0"));
06aad8b5 216 // runs UserExecMix for all tasks, if needed
b425275c 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//_____________________________________________________________________________
257Bool_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;
62e756a5 271
272 // check for PhysSelection
273 if (!IsEventCurrentSelected()) return kFALSE;
274
b425275c 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"));
06aad8b5 292 // runs UserExecMix for all tasks, if needed
a86b14f8 293 if (el) UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
294 else UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
b425275c 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) {
a86b14f8 304 UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
b425275c 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);
a86b14f8 314 while ((eh = dynamic_cast<AliInputEventHandler *>(next()))) {
b425275c 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//_____________________________________________________________________________
350Bool_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;
62e756a5 364
365 // check for PhysSelection
366 if (!IsEventCurrentSelected()) return kFALSE;
367
b425275c 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) {
06aad8b5 383 // runs UserExecMix for all tasks, if needed
384 if (el) UserExecMixAllTasks(fEntryCounter, idEntryList, currentMainEntry, -1, 0);
a86b14f8 385 else UserExecMixAllTasks(fEntryCounter, -1, currentMainEntry, -1, 0);
b425275c 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//_____________________________________________________________________________
440Bool_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//_____________________________________________________________________________
450Bool_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//_____________________________________________________________________________
463void 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//_____________________________________________________________________________
473void 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));
a86b14f8 484 fCurrentEntry = entryCounter;
485 fCurrentEntryMain = entryMainReal;
486 fCurrentEntryMix = entryMixReal;
487 fCurrentBinIndex = idEntryList;
488 if (entryMixReal >= 0) mixTask->UserExecMix("");
b425275c 489 }
490 }
491}
492
493//_____________________________________________________________________________
494void 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}
62e756a5 520
521Bool_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}