Martin Valas fast mixing classes.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Nov 2010 16:50:47 +0000 (16:50 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Nov 2010 16:50:47 +0000 (16:50 +0000)
ANALYSIS/EventMixing/AliMixEventCutObj.cxx [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixEventCutObj.h [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixEventInputHandler.cxx [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixEventInputHandler.h [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixEventPool.cxx [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixEventPool.h [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixInputHandlerInfo.cxx [new file with mode: 0644]
ANALYSIS/EventMixing/AliMixInputHandlerInfo.h [new file with mode: 0644]
ANALYSIS/EventMixingLinkDef.h [new file with mode: 0644]
ANALYSIS/libEventMixing.pkg [new file with mode: 0644]

diff --git a/ANALYSIS/EventMixing/AliMixEventCutObj.cxx b/ANALYSIS/EventMixing/AliMixEventCutObj.cxx
new file mode 100644 (file)
index 0000000..55bc5cb
--- /dev/null
@@ -0,0 +1,188 @@
+//
+// Class AliMixEventCutObj
+//
+// AliMixEventCutObj object contains information about one cut on for event mixing
+// used by AliMixEventPool class
+//
+// authors: 
+//          Martin Vala (martin.vala@cern.ch)
+//
+
+#include "AliLog.h"
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
+#include "AliMultiplicity.h"
+
+#include "AliMixEventCutObj.h"
+
+ClassImp(AliMixEventCutObj)
+
+//_________________________________________________________________________________________________
+AliMixEventCutObj::AliMixEventCutObj(EEPAxis_t type, Float_t min, Float_t max, Float_t step) : TObject(),
+    fCutType((Short_t)type),
+    fCutMin(min),
+    fCutMax(max),
+    fCutStep(step),
+    fCutSmallVal((max - min) / (step*1e6)),
+    fCurrentVal(min),
+    fNoMore(kFALSE) {
+  //
+  // Default constructor.
+  //
+
+  AliDebug(AliLog::kDebug + 2, "<-");
+
+  AliDebug(AliLog::kDebug + 2, "->");
+}
+//_________________________________________________________________________________________________
+AliMixEventCutObj::AliMixEventCutObj(const AliMixEventCutObj& obj) : TObject(obj),
+    fCutType(obj.fCutType),
+    fCutMin(obj.fCutMin),
+    fCutMax(obj.fCutMax),
+    fCutStep(obj.fCutStep),
+    fCutSmallVal(obj.fCutSmallVal),
+    fCurrentVal(obj.fCurrentVal),
+    fNoMore(obj.fNoMore) {
+  //
+  // Copy constructor.
+  //
+}
+
+//_________________________________________________________________________________________________
+void AliMixEventCutObj::Reset() {
+  //
+  // Reset cut.
+  //
+
+  AliDebug(AliLog::kDebug + 2, "<-");
+  fCurrentVal = fCutMin - fCutStep;
+  fNoMore = kFALSE;
+  AliDebug(AliLog::kDebug + 2, "->");
+}
+//_________________________________________________________________________________________________
+Bool_t AliMixEventCutObj::HasMore() const {
+  //
+  // Return kTRUE when fCurrentVal is in interval of cut range
+  //
+  
+  return ((fCurrentVal + fCutStep) < fCutMax);
+}
+
+//_________________________________________________________________________________________________
+void AliMixEventCutObj::AddStep() {
+  //
+  // Adds step
+  //
+  
+  fCurrentVal += fCutStep;
+}
+
+//_________________________________________________________________________________________________
+void AliMixEventCutObj::Print(const Option_t *) const {
+  //
+  // Prints cut information
+  //
+  
+  AliInfo(Form("%d %f %f %f", fCutType, fCutMin, fCutMax, fCutStep));
+}
+//_________________________________________________________________________________________________
+void AliMixEventCutObj::PrintCurrentInterval() {
+  //
+  // Prints current cut interval information
+  //
+  
+  AliInfo(Form("%s <%f,%f>", GetNameOfCut(fCutType), GetMin(), GetMax()));
+}
+
+//_________________________________________________________________________________________________
+Int_t AliMixEventCutObj::GetNumberOfBins() const {
+  //
+  // Returns number of bins
+  //
+  
+  if (!fCutStep) return -1;
+  return (Int_t)((fCutMax -fCutMin) / fCutStep);
+}
+
+//_________________________________________________________________________________________________
+Int_t AliMixEventCutObj::GetBinNumber(Float_t num) const {
+  //
+  // Returns bin (index) number in current cut.
+  // Returns -1 in case of out of range
+  //
+  
+  Int_t binNum = 0;
+  for (Float_t i = fCutMin;i <= fCutMax - fCutSmallVal;i += fCutStep) {
+    binNum++;
+    if ((num >= i) && (num <= i + fCutStep - fCutSmallVal)) return binNum;
+
+  }
+  return -1;
+}
+
+//_________________________________________________________________________________________________
+Int_t AliMixEventCutObj::GetIndex(AliVEvent* ev) {
+  //
+  // Finds bin (index) in current cut from event information.
+  //
+  
+  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(ev);
+  if (esd) return GetIndex(esd);
+  AliAODEvent *aod = dynamic_cast<AliAODEvent*>(ev);
+  if (aod) return GetIndex(aod);
+  return -1;
+}
+
+//_________________________________________________________________________________________________
+Int_t AliMixEventCutObj::GetIndex(AliESDEvent* ev) {
+  //
+  // Finds bin (index) in current cut from ESD event information.
+  //
+  switch (fCutType) {
+  case kMultiplicity:
+    return GetBinNumber((Float_t)ev->GetNumberOfTracks());
+  case kZVertex:
+    return GetBinNumber(ev->GetVertex()->GetZ());
+  case kNumberV0s:
+    return GetBinNumber(ev->GetNumberOfV0s());
+  case kNumberTracklets:
+    const AliMultiplicity* multESD = ev->GetMultiplicity();
+    return GetBinNumber(multESD->GetNumberOfTracklets());
+  }
+  return -1;
+}
+
+//_________________________________________________________________________________________________
+Int_t AliMixEventCutObj::GetIndex(AliAODEvent* ev) {
+  //
+  // Finds bin (index) in current cut from AOD event information.
+  //
+  switch (fCutType) {
+  case kMultiplicity:
+    return GetBinNumber((Float_t)ev->GetNumberOfTracks());
+  case kZVertex:
+    return GetBinNumber(ev->GetVertex(0)->GetZ());
+  case kNumberV0s:
+    return GetBinNumber(ev->GetNumberOfV0s());
+  }
+  return -1;
+}
+//_________________________________________________________________________________________________
+const char* AliMixEventCutObj::GetNameOfCut(Short_t index) const
+{
+  //
+  // Retruns name of cut
+  //
+  switch ((Int_t)index) {
+    case kMultiplicity:
+      return "Multiplicity";
+    case kZVertex:
+      return "ZVertex";
+    case kNumberV0s:
+      return "NumberV0s";
+    case kNumberTracklets:
+      return "NumberTracklets";
+  }
+  return "";
+}
+
diff --git a/ANALYSIS/EventMixing/AliMixEventCutObj.h b/ANALYSIS/EventMixing/AliMixEventCutObj.h
new file mode 100644 (file)
index 0000000..2a304fa
--- /dev/null
@@ -0,0 +1,60 @@
+//
+// Class AliMixEventCutObj
+//
+// AliMixEventCutObj object contains information about one cut on for event mixing
+// used by AliMixEventPool class
+//
+// authors: 
+//          Martin Vala (martin.vala@cern.ch)
+//
+
+#ifndef ALIMIXEVENTCUTOBJ_H
+#define ALIMIXEVENTCUTOBJ_H
+
+#include <TObject.h>
+class AliVEvent;
+class AliAODEvent;
+class AliESDEvent;
+class AliMixEventCutObj : public TObject
+{
+public:
+  enum EEPAxis_t {kMultiplicity=0, kZVertex=1, kNumberV0s=2, kNumberTracklets=3, kAllEventAxis=4};
+    
+    AliMixEventCutObj(EEPAxis_t type=kMultiplicity,Float_t min=0,Float_t max=0, Float_t step=0);
+    AliMixEventCutObj(const AliMixEventCutObj& obj);
+    virtual ~AliMixEventCutObj() {;}
+
+    virtual void Print(const Option_t *) const;
+    void PrintCurrentInterval();
+    void Reset();
+    void AddStep();
+
+    Bool_t      HasMore() const;
+
+    Int_t       GetNumberOfBins() const;
+    Float_t     GetMin() const { return fCurrentVal;}
+    Float_t     GetMax() const { return fCurrentVal+fCutStep-fCutSmallVal;}
+    Float_t     GetStep() const { return fCutStep;}
+    Short_t     GetType() const {return fCutType;}
+    Int_t       GetBinNumber(Float_t num) const;
+    Int_t       GetIndex(AliVEvent*ev);
+    Int_t       GetIndex(AliESDEvent*ev);
+    Int_t       GetIndex(AliAODEvent*ev);
+    const char *GetNameOfCut(Short_t index) const;
+    
+private:
+    Short_t     fCutType;       // cut type
+    Float_t     fCutMin;        // cut min
+    Float_t     fCutMax;        // cut max
+    Float_t     fCutStep;       // cut step
+    Float_t     fCutSmallVal;   // small value
+
+    Float_t     fCurrentVal;    // current value
+    Bool_t      fNoMore;        // flag for no more bins
+
+    AliMixEventCutObj& operator=(const AliMixEventCutObj& ) { return *this;}
+
+    ClassDef(AliMixEventCutObj, 1)
+};
+
+#endif
diff --git a/ANALYSIS/EventMixing/AliMixEventInputHandler.cxx b/ANALYSIS/EventMixing/AliMixEventInputHandler.cxx
new file mode 100644 (file)
index 0000000..ec05fa6
--- /dev/null
@@ -0,0 +1,249 @@
+//
+// Class AliMixEventInputHandler
+//
+// Mixing input handler prepare N events before UserExec
+// TODO example
+// author: 
+//        Martin Vala (martin.vala@cern.ch)
+//
+
+#include <TFile.h>
+#include <TChain.h>
+#include <TEntryList.h>
+#include "AliLog.h"
+#include "AliMixEventPool.h"
+#include "AliMixEventInputHandler.h"
+#include "AliAnalysisManager.h"
+
+#include "AliMixInputHandlerInfo.h"
+#include <TChainElement.h>
+
+ClassImp(AliMixEventInputHandler)
+
+//_____________________________________________________________________________
+AliMixEventInputHandler::AliMixEventInputHandler(const Int_t size) :
+    AliInputEventHandler(),
+    fBufferSize(size),
+    fInputHandlers(),
+    fMixTrees(),
+    fTreeMap(size),
+    fMixIntupHandlerInfoTmp(0),
+    fEntryCounter(0),
+    fEventPool(0),
+    fMixEventNumber(0) {
+//
+// Default constructor.
+//
+  AliDebug(AliLog::kDebug + 10, "<-");
+  AliDebug(AliLog::kDebug + 10, "->");
+}
+
+//_____________________________________________________________________________
+AliInputEventHandler* AliMixEventInputHandler::InputEventHandler(const Int_t index) {
+  //
+  // Returns input handler
+  //
+  AliDebug(AliLog::kDebug, Form("<-"));
+  if ((index >= 0) && (index < fBufferSize)) {
+    AliDebug(AliLog::kDebug, Form("->"));
+    return (AliInputEventHandler*) fInputHandlers.At(index);
+  }
+  AliDebug(AliLog::kDebug, Form("->"));
+  return 0;
+}
+//_____________________________________________________________________________
+void AliMixEventInputHandler::SetInputHandlerForMixing(const AliInputEventHandler*const inHandler) {
+  //
+  // Create N (fBufferSize) copies of input handler
+  //
+  AliDebug(AliLog::kDebug, Form("<-"));
+  AliDebug(AliLog::kDebug, Form("Creating %d input event handlers ...", fBufferSize));
+  for (Int_t i = 0;i < fBufferSize;i++) {
+    AliDebug(AliLog::kDebug + 5, Form("Adding %d ...", i));
+    fInputHandlers.Add((AliInputEventHandler*) inHandler->Clone());
+  }
+  AliDebug(AliLog::kDebug, Form("->"));
+}
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::Init(Option_t*opt) {
+  //
+  // Init() is called for all mix input handlers.
+  //
+  AliDebug(AliLog::kDebug, Form("<- \"%s\"", opt));
+  AliInputEventHandler *eh = 0;
+  TObjArrayIter next(&fInputHandlers);
+  while ((eh = (AliInputEventHandler *) next())) {
+    eh->Init(opt);
+  }
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::Init(TTree* tree, Option_t*) {
+  //
+  // Init(const char*path) is called for all mix input handlers.
+  // Create event pool if needed
+  //
+  AliDebug(AliLog::kDebug, Form("<- %p", tree));
+  if (!tree) {
+    AliDebug(AliLog::kDebug, Form("->"));
+    return kFALSE;
+  }
+  AliDebug(AliLog::kDebug, Form("%s", tree->GetCurrentFile()->GetName()));
+
+  // clears array of input handlers
+  fMixTrees.SetOwner(kTRUE);
+  fMixTrees.Clear();
+
+  // create AliMixInputHandlerInfo
+  if (!fMixIntupHandlerInfoTmp) fMixIntupHandlerInfoTmp = new AliMixInputHandlerInfo(tree->GetName());
+
+  // adds current file
+  fMixIntupHandlerInfoTmp->AddTreeToChain(tree);
+  Int_t lastIndex = fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->GetEntries();
+  TChainElement *che = (TChainElement *)fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->At(lastIndex - 1);
+  AliMixInputHandlerInfo *mixIHI = 0;
+  for (Int_t i = 0;i < fInputHandlers.GetEntries();i++) {
+
+    AliDebug(AliLog::kDebug, Form("fInputHandlers[%d]", i));
+    mixIHI = new AliMixInputHandlerInfo(fMixIntupHandlerInfoTmp->GetName(), fMixIntupHandlerInfoTmp->GetTitle());
+    mixIHI->PrepareEntry(che, -1, InputEventHandler(i));
+    AliDebug(AliLog::kDebug, Form("chain[%d]->GetEntries() = %lld", i, mixIHI->GetChain()->GetEntries()));
+    fMixTrees.Add(mixIHI);
+  }
+  AliDebug(AliLog::kDebug, Form("fEntryCounter=%lld", fEntryCounter));
+
+  if (fEventPool->NeedInit())
+    fEventPool->Init();
+
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::Notify() {
+  //
+  // Notify() is called for all mix input handlers
+  //
+  AliDebug(AliLog::kDebug, Form("<-"));
+  AliInputEventHandler *eh = 0;
+  TObjArrayIter next(&fInputHandlers);
+  while ((eh = (AliInputEventHandler *) next())) {
+    eh->Notify();
+  }
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::Notify(const char*path) {
+  //
+  // Notify(const char*path) is called for all mix input handlers
+  //
+  AliDebug(AliLog::kDebug, Form("<- %s", path));
+  AliInputEventHandler *eh = 0;
+  TObjArrayIter next(&fInputHandlers);
+  while ((eh = (AliInputEventHandler *) next())) {
+    eh->Notify(path);
+  }
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::BeginEvent(Long64_t entry) {
+  //
+  // BeginEvent(Long64_t entry) is called for all mix input handlers
+  //
+  
+  AliDebug(AliLog::kDebug, Form("-> %lld", entry));
+  AliInputEventHandler *eh = 0;
+  TObjArrayIter next(&fInputHandlers);
+  while ((eh = (AliInputEventHandler *) next())) {
+    eh->BeginEvent(entry);
+  }
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::GetEntry() {
+  //
+  // Sets correct events to every mix events
+  //
+  AliDebug(AliLog::kDebug, Form("<-"));
+
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+  AliInputEventHandler *inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());
+
+  Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetEntries();
+  
+  // if fEntryCounter is 0 just add entry
+  if (!fEntryCounter) {
+    if (inEvHMain) {
+
+      fEventPool->AddEntry(inEvHMain->GetTree()->GetReadEntry() + zeroChainEntries, inEvHMain->GetEvent());
+    }
+    return kTRUE;
+  }
+
+  AliDebug(AliLog::kDebug, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
+
+  fMixEventNumber = 0;
+  TEntryList *el = fEventPool->FindEntryList(inEvHMain->GetEvent());
+  Long64_t elNum = 0;
+  if (el)
+    elNum = el->GetN();
+  else
+    AliDebug(AliLog::kDebug, "el is null");
+
+  AliInputEventHandler *eh = 0;
+  AliMixInputHandlerInfo *mihi = 0;
+  TObjArrayIter next(&fInputHandlers);
+  Int_t counter = 0;
+  Long64_t entryMix = 0;
+  while ((eh = (AliInputEventHandler *) next())) {
+    if (fEventPool->GetListOfEventCuts()->GetEntries() > 0) {
+      entryMix = -1;
+      if (el && el->GetN() >= fBufferSize) {
+        Long64_t entryInEntryList =  elNum - 1 - counter;
+        if (entryInEntryList < 0) break;
+        entryMix = el->GetEntry(entryInEntryList);
+      }
+    } else {
+      entryMix = fEntryCounter - 1 - counter ;
+    }
+
+    AliDebug(AliLog::kDebug, Form("Handler[%d] entryMix %lld ", counter, entryMix));
+    if (entryMix < 0) break;
+
+    mihi = (AliMixInputHandlerInfo*) fMixTrees.At(counter);
+    TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
+    mihi->PrepareEntry(te, entryMix, InputEventHandler(counter));
+    fMixEventNumber++;
+    counter++;
+  }
+
+  if (inEvHMain) {
+    fEventPool->AddEntry(inEvHMain->GetTree()->GetReadEntry() + zeroChainEntries, inEvHMain->GetEvent());
+  }
+
+  AliDebug(AliLog::kDebug, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fMixEventNumber));
+  AliDebug(AliLog::kDebug, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliMixEventInputHandler::FinishEvent() {
+  //
+  // FinishEvent() is called for all mix input handlers
+  //
+  AliDebug(AliLog::kDebug, Form("<-"));
+  AliInputEventHandler *eh = 0;
+  TObjArrayIter next(&fInputHandlers);
+  while ((eh = (AliInputEventHandler *) next())) {
+    eh->FinishEvent();
+  }
+  fEntryCounter++;
+  AliDebug(AliLog::kDebug, Form("->"));
+  return kTRUE;
+}
diff --git a/ANALYSIS/EventMixing/AliMixEventInputHandler.h b/ANALYSIS/EventMixing/AliMixEventInputHandler.h
new file mode 100644 (file)
index 0000000..b17de59
--- /dev/null
@@ -0,0 +1,65 @@
+//
+// Class AliMixEventInputHandler
+//
+// Mixing input handler prepare N events before UserExec
+// TODO example
+// author: 
+//        Martin Vala (martin.vala@cern.ch)
+//
+
+#ifndef ALIMIXEVENTINPUTHANDLER_H
+#define ALIMIXEVENTINPUTHANDLER_H
+
+#include <TObjArray.h>
+
+#include "AliInputEventHandler.h"
+#include <TArrayI.h>
+
+class TChain;
+class AliMixEventPool;
+class AliMixInputHandlerInfo;
+class AliMixEventInputHandler : public AliInputEventHandler {
+
+public:
+  AliMixEventInputHandler(const Int_t size=1);
+  virtual ~AliMixEventInputHandler() {;};
+  
+  // From the interface
+  virtual Bool_t  Init(Option_t* opt /*opt*/);
+  virtual Bool_t  Init(TTree* tree, Option_t* /*opt*/);
+  virtual Bool_t  BeginEvent(Long64_t entry /*entry*/);
+  virtual Bool_t  GetEntry();
+  virtual Bool_t  FinishEvent();
+  virtual Bool_t  Notify();
+  virtual Bool_t  Notify(const char *path);
+
+  
+  void SetInputHandlerForMixing(const AliInputEventHandler * const inHandler);
+  void SetEventPool(AliMixEventPool * const evPool) {fEventPool = evPool;}
+  
+  AliInputEventHandler * InputEventHandler(const Int_t index);
+  AliMixEventPool *GetEventPool() const { return fEventPool;}
+  Int_t           BufferSize() const {return fBufferSize;}
+  Int_t           MixedEventNumber() const {return fMixEventNumber;}
+  Long64_t        EntryAll() const { return fEntryCounter;}
+protected:
+  
+  Int_t             fBufferSize;          // Size of the buffer
+  TObjArray         fInputHandlers;       // buffer of input handlers
+  TObjArray         fMixTrees;            // buffer of input handlers
+  TArrayI           fTreeMap;             // tree map
+  AliMixInputHandlerInfo *fMixIntupHandlerInfoTmp;    //! mix input handler info full chain
+  Long64_t          fEntryCounter;        // entry counter
+  AliMixEventPool  *fEventPool;           // event pool
+  
+  Int_t             fMixEventNumber;      // number mix
+  
+private:
+
+  AliMixEventInputHandler(const AliMixEventInputHandler& handler);             
+  AliMixEventInputHandler& operator=(const AliMixEventInputHandler& handler);  
+
+  ClassDef(AliMixEventInputHandler, 1)
+};
+
+#endif
diff --git a/ANALYSIS/EventMixing/AliMixEventPool.cxx b/ANALYSIS/EventMixing/AliMixEventPool.cxx
new file mode 100644 (file)
index 0000000..8b03fef
--- /dev/null
@@ -0,0 +1,220 @@
+//
+// Class AliMixEventPool
+//
+// AliMixEventPool is used to find 
+// similar events
+//
+// author:
+//        Martin Vala (martin.vala@cern.ch)
+//
+
+#include <TEntryList.h>
+
+#include "AliLog.h"
+#include "AliMixEventCutObj.h"
+
+#include "AliMixEventPool.h"
+
+ClassImp(AliMixEventPool)
+
+//_________________________________________________________________________________________________
+AliMixEventPool::AliMixEventPool(const char* name, const char* title) : TNamed(name, title),
+    fListOfEntryList(),
+    fListOfEventCuts(),
+    fBinNumber(0) {
+  //
+  // Default constructor.
+  //
+
+  AliDebug(AliLog::kDebug + 5, "<-");
+  AliDebug(AliLog::kDebug + 5, "->");
+}
+//_________________________________________________________________________________________________
+AliMixEventPool::AliMixEventPool(const AliMixEventPool& obj) : TNamed(obj),
+    fListOfEntryList(obj.fListOfEntryList),
+    fListOfEventCuts(obj.fListOfEventCuts),
+    fBinNumber(obj.fBinNumber) {
+  //
+  // Copy constructor
+  //
+  AliDebug(AliLog::kDebug + 5, "<-");
+  AliDebug(AliLog::kDebug + 5, "->");
+}
+//_________________________________________________________________________________________________
+AliMixEventPool::~AliMixEventPool() {
+  //
+  // Destructor
+  //
+  AliDebug(AliLog::kDebug + 5, "<-");
+  AliDebug(AliLog::kDebug + 5, "->");
+}
+//_________________________________________________________________________________________________
+void AliMixEventPool::AddCut(AliMixEventCutObj* cut) {
+  //
+  // Adds cut
+  //
+
+  if (cut) fListOfEventCuts.Add(cut);
+}
+//_________________________________________________________________________________________________
+void AliMixEventPool::Print(const Option_t* option) const {
+  //
+  // Prints usefull information
+  //
+
+  TObjArrayIter next(&fListOfEventCuts);
+  //   Int_t c=0;
+  AliMixEventCutObj *cut;
+  while ((cut = (AliMixEventCutObj *) next())) {
+    cut->Print(option);
+  }
+
+  AliInfo(Form("NumOfEntryList %d", fListOfEntryList.GetEntries()));
+
+  TEntryList *el;
+  for (Int_t i = 0;i < fListOfEntryList.GetEntries();i++) {
+    el = (TEntryList*) fListOfEntryList.At(i);
+
+    AliInfo(Form("EntryList[%d] %lld", i, el->GetN()));
+  }
+}
+//_________________________________________________________________________________________________
+Int_t AliMixEventPool::Init() {
+  //
+  // Init event pool
+  //
+  AliDebug(AliLog::kDebug+5,"<-");
+  CreateEntryListsRecursivly(fListOfEventCuts.GetEntries() - 1);
+
+  fBinNumber++;
+  AliDebug(AliLog::kDebug, Form("fBinnumber = %d", fBinNumber));
+
+  AddEntryList();
+  AliDebug(AliLog::kDebug+5,"->");
+  return 0;
+}
+
+//_________________________________________________________________________________________________
+void AliMixEventPool::CreateEntryListsRecursivly(Int_t index) {
+  //
+  // Helper function which create entrylist recursivly
+  //
+  AliDebug(AliLog::kDebug+5,"<-");
+  AliMixEventCutObj *cut;
+  if (index >= 0) {
+    AliDebug(AliLog::kDebug, Form("index = %d", index));
+    cut = dynamic_cast<AliMixEventCutObj*>(fListOfEventCuts.At(index));
+    cut->Reset();
+
+    while (cut->HasMore()) {
+      cut->AddStep();
+      CreateEntryListsRecursivly(index - 1);
+      if (cut->HasMore()) {
+        fBinNumber++;
+        AliDebug(AliLog::kDebug, Form("fBinnumber = %d", fBinNumber));
+        AddEntryList();
+        //                 PrintCurrentCutIntervals();
+      }
+    }
+
+  }
+  AliDebug(AliLog::kDebug+5,"->");
+}
+
+//_________________________________________________________________________________________________
+TEntryList* AliMixEventPool::AddEntryList() {
+  //
+  // Adds endtry list
+  //
+  
+  AliDebug(AliLog::kDebug+5,"<-");
+  
+  TObjArrayIter next(&fListOfEventCuts);
+  AliMixEventCutObj *cut;
+  while ((cut = (AliMixEventCutObj*) next())) {
+    if (cut) cut->PrintCurrentInterval();
+  }
+
+  TEntryList *el = new TEntryList;
+  fListOfEntryList.Add(el);
+
+  AliDebug(AliLog::kDebug, Form("Number in Entry list -> %lld", el->GetN()));
+  AliDebug(AliLog::kDebug+5,"->");
+  return el;
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliMixEventPool::AddEntry(Long64_t entry, AliVEvent* ev) {
+  //
+  // Adds entry to correct entry list
+  //
+  
+  AliDebug(AliLog::kDebug+5,"<-");
+  AliDebug(AliLog::kDebug + 5, Form("AddEntry(%lld,%p)", entry, ev));
+  if (entry < 0) {
+    AliDebug(AliLog::kDebug, Form("Entry %lld was NOT added !!!", entry));
+    return kFALSE;
+
+  }
+
+  TEntryList *el =  FindEntryList(ev);
+  if (el) {
+    el->Enter(entry);
+    AliDebug(AliLog::kDebug, Form("Entry %lld was added !!!", entry));
+    return kTRUE;
+  }
+
+  AliDebug(AliLog::kDebug, Form("Entry %lld was NOT added !!!", entry));
+  AliDebug(AliLog::kDebug+5,"->");
+  return kFALSE;
+}
+
+//_________________________________________________________________________________________________
+TEntryList* AliMixEventPool::FindEntryList(AliVEvent* ev) {
+  //
+  // Find entrlist in list of entrlist
+  //
+  
+  AliDebug(AliLog::kDebug+5,"<-");
+  const Int_t num = fListOfEventCuts.GetEntries();
+  if (num <= 0) return 0;
+
+  Int_t indexes[num];
+  Int_t lenght[num];
+  Int_t i = 0;
+  TObjArrayIter next(&fListOfEventCuts);
+  AliMixEventCutObj *cut;
+  while ((cut = (AliMixEventCutObj*) next())) {
+    indexes[i] = cut->GetIndex(ev);
+    if (indexes[i] < 0) {
+      AliDebug(AliLog::kDebug, Form("retIndex %d", -1));
+      return 0;
+    }
+    lenght[i] = cut->GetNumberOfBins();
+    AliDebug(AliLog::kDebug + 1, Form("indexes[%d] %d", i, indexes[i]));
+    i++;
+  }
+
+  Int_t retIndex = 0;
+  SearchIndexRecursive(fListOfEventCuts.GetEntries() - 1, &indexes[0], &lenght[0], retIndex);
+  AliDebug(AliLog::kDebug, Form("retIndex %d", retIndex - 1));
+  // index which start with 0 (retIndex-1)
+  AliDebug(AliLog::kDebug+5,"->");
+  return (TEntryList*) fListOfEntryList.At(retIndex - 1);
+}
+
+//_________________________________________________________________________________________________
+void AliMixEventPool::SearchIndexRecursive(Int_t num, Int_t* i, Int_t* d, Int_t& index) {
+  //
+  // Search for index of entrylist
+  //
+  
+  AliDebug(AliLog::kDebug+5,"<-");
+  if (num > 0) {
+    index += (i[num] - 1) * d[num-1];
+    SearchIndexRecursive(num - 1, i, d, index);
+  } else {
+    index += i[num];
+  }
+  AliDebug(AliLog::kDebug+5,"->");
+}
diff --git a/ANALYSIS/EventMixing/AliMixEventPool.h b/ANALYSIS/EventMixing/AliMixEventPool.h
new file mode 100644 (file)
index 0000000..f1adbc9
--- /dev/null
@@ -0,0 +1,58 @@
+//
+// Class AliMixEventPool
+//
+// AliMixEventPool is used to find 
+// similar events
+//
+// author:
+//        Martin Vala (martin.vala@cern.ch)
+//
+
+#ifndef ALIMIXEVENTPOOL_H
+#define ALIMIXEVENTPOOL_H
+
+#include <TObjArray.h>
+#include <TNamed.h>
+
+class TEntryList;
+class AliMixEventCutObj;
+class AliVEvent;
+class AliMixEventPool : public TNamed
+{
+  public:
+    AliMixEventPool(const char* name="mixEventPool", const char* title="Mix event pool");
+    AliMixEventPool(const AliMixEventPool& obj);
+    virtual ~AliMixEventPool();
+
+    // prints object info
+    virtual void      Print(const Option_t* option="") const;
+
+    // inits correctly object
+    Int_t       Init();
+    
+    void        CreateEntryListsRecursivly(Int_t index);
+    void        SearchIndexRecursive(Int_t num, Int_t *i, Int_t *d, Int_t &index);
+    TEntryList* AddEntryList();
+    
+    Bool_t      AddEntry(Long64_t entry, AliVEvent* ev);
+    TEntryList *FindEntryList(AliVEvent *ev);
+    
+    void        AddCut(AliMixEventCutObj*cut);
+    
+    Bool_t      NeedInit() { return (fListOfEntryList.GetEntries() == 0); }
+    TObjArray  *GetListOfEntryLists() { return &fListOfEntryList; }   
+    TObjArray  *GetListOfEventCuts() { return &fListOfEventCuts; }
+    
+  private:
+
+    TObjArray   fListOfEntryList;       // list of entry lists
+    TObjArray   fListOfEventCuts;       // list of entry lists
+    
+    Int_t       fBinNumber;             // bin number
+    
+    AliMixEventPool& operator= (const AliMixEventPool&) { return *this; }
+
+    ClassDef(AliMixEventPool, 1)
+};
+
+#endif
diff --git a/ANALYSIS/EventMixing/AliMixInputHandlerInfo.cxx b/ANALYSIS/EventMixing/AliMixInputHandlerInfo.cxx
new file mode 100644 (file)
index 0000000..f847dc1
--- /dev/null
@@ -0,0 +1,172 @@
+//
+// Class AliMixInputHandlerInfo
+//
+// AliMixInputHandlerInfo is interface with mixed 
+// input handlers
+//
+// author: 
+//        Martin Vala (martin.vala@cern.ch)
+//
+#include <TTree.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <TChainElement.h>
+
+#include "AliLog.h"
+#include "AliInputEventHandler.h"
+
+#include "AliMixInputHandlerInfo.h"
+
+ClassImp(AliMixInputHandlerInfo)
+
+//_____________________________________________________________________________
+AliMixInputHandlerInfo::AliMixInputHandlerInfo(const char* name, const char* title): TNamed(name, title),
+    fChain(0),
+    fChainEntriesArray(),
+    fZeroEntryNumber(0),
+    fNeedNotify(kFALSE) {
+  //
+  // Default constructor.
+  //
+}
+//_____________________________________________________________________________
+AliMixInputHandlerInfo::~AliMixInputHandlerInfo() {
+  //
+  // Destructor
+  //
+  if (fChain) delete fChain;
+}
+
+//_____________________________________________________________________________
+TChain* AliMixInputHandlerInfo::GetChain() {
+  //
+  // Returns curren chain. When chain is null it will create it
+  //
+  if (!fChain) fChain = new TChain(GetName());
+  return fChain;
+}
+
+//_____________________________________________________________________________
+void AliMixInputHandlerInfo::AddChain(TChain* chain) {
+  //
+  // Add chain
+  //
+  AliDebug(AliLog::kDebug, "<-");
+
+  if (!chain) return;
+
+  if (fChain) delete fChain;
+  fChain = new TChain(GetName());
+  fChain->Add(chain);
+
+  AliDebug(AliLog::kDebug, "->");
+}
+
+//_____________________________________________________________________________
+void AliMixInputHandlerInfo::AddTreeToChain(TTree *tree) {
+  //
+  // Adds tree to chain
+  //
+  AliDebug(AliLog::kDebug, Form("%s %lld", tree->GetCurrentFile()->GetName(), tree->GetEntries()));
+
+  GetChain();
+  fChain->AddFile(tree->GetCurrentFile()->GetName());
+
+
+  fChainEntriesArray.Set(fChain->GetListOfFiles()->GetEntries());
+
+  AliDebug(AliLog::kDebug, Form("Adding %lld to id %d", tree->GetEntries(), fChain->GetListOfFiles()->GetEntries() - 1));
+  fChainEntriesArray.AddAt(tree->GetEntries(), fChain->GetListOfFiles()->GetEntries() - 1);
+
+}
+
+//_____________________________________________________________________________
+TChainElement* AliMixInputHandlerInfo::GetEntryInTree(Long64_t& entry) {
+  //
+  // Get entry in current tree
+  //
+  fZeroEntryNumber = 0;
+  if (entry < fZeroEntryNumber) {
+    AliError(Form("Num %lld is less then ZeroEntryNumber(%lld)", entry, fZeroEntryNumber));
+    entry = -1;
+    return 0;
+  }
+
+  Long64_t sumTree = fZeroEntryNumber;
+  for (Int_t i = 0;i < fChainEntriesArray.GetSize() ;i++) {
+    sumTree += fChainEntriesArray.At(i);
+    if (sumTree > entry) {
+      sumTree = entry - sumTree + fChainEntriesArray.At(i);
+      AliDebug(AliLog::kDebug, Form("Entry in current tree num is %lld with i=%d", sumTree, i));
+
+      entry = sumTree;
+      TChainElement *chEl = (TChainElement*) fChain->GetListOfFiles()->At(i);
+      AliDebug(AliLog::kDebug, Form("Real filename is %s %s", chEl->GetName(), chEl->GetTitle()));
+
+      AliDebug(AliLog::kDebug, Form("And filename is %s %lld", fChain->GetTree()->GetCurrentFile()->GetName(), fChain->GetEntries()));
+      return chEl;
+    }
+  }
+
+  entry = -1;
+  return 0;
+}
+
+//_____________________________________________________________________________
+void AliMixInputHandlerInfo::PrepareEntry(TChainElement *te, Long64_t entry, AliInputEventHandler *eh) {
+  //
+  // Prepare Entry 
+  //
+  if (!te) return;
+
+  if (te) {
+    if (entry < 0) {
+      AliDebug(AliLog::kDebug, Form("We are creating new chain from file %s ...", te->GetTitle()));
+      if (!fChain) {
+        fChain = new TChain(te->GetName());
+        fChain->AddFile(te->GetTitle());
+        fChain->GetEntry(0);
+        eh->Init(fChain->GetTree(), "proof");
+//       eh->Notify(te->GetTitle());
+      }
+      fNeedNotify = kTRUE;
+      return;
+    }
+
+  }
+
+  if (fChain) {
+    AliDebug(AliLog::kDebug, Form("Filename is %s", fChain->GetCurrentFile()->GetName()));
+    TString fn = fChain->GetCurrentFile()->GetName();
+    if (fn.CompareTo(te->GetTitle())) {
+      AliDebug(AliLog::kDebug, Form("Filename %s is NOT same ...", te->GetTitle()));
+      AliDebug(AliLog::kDebug, Form("We are changing to file %s ...", te->GetTitle()));
+      // change file
+      delete fChain;
+      fChain = new TChain(te->GetName());
+      fChain->AddFile(te->GetTitle());
+      fChain->GetEntry(0);
+      eh->Init(fChain->GetTree(), "proof");
+
+      eh->Notify(te->GetTitle());
+      eh->BeginEvent(entry);
+      fChain->GetEntry(entry);
+      fNeedNotify = kFALSE;
+    } else {
+      AliDebug(AliLog::kDebug, Form("We are reusing file %s ...", te->GetTitle()));
+      if (fNeedNotify) eh->Notify(te->GetTitle());
+      fNeedNotify = kFALSE;
+      AliDebug(AliLog::kDebug, Form("Entry is %lld + GetEntries %lld ...", entry, fChain->GetEntries()));
+      eh->BeginEvent(entry);
+      fChain->GetEntry(entry);
+      // file is in tree fChain already
+    }
+  }
+
+  AliDebug(AliLog::kDebug, Form("We are USING file %s ...", te->GetTitle()));
+  AliDebug(AliLog::kDebug, Form("We are USING file from fChain->GetTree() %s ...", fChain->GetTree()->GetCurrentFile()->GetName()));
+
+  // here we have correct chain with 1 tree only
+  AliDebug(AliLog::kDebug, Form("Entry is %lld ...", entry));
+
+}
diff --git a/ANALYSIS/EventMixing/AliMixInputHandlerInfo.h b/ANALYSIS/EventMixing/AliMixInputHandlerInfo.h
new file mode 100644 (file)
index 0000000..adb49c8
--- /dev/null
@@ -0,0 +1,46 @@
+//
+// Class AliMixInputHandlerInfo
+//
+// AliMixInputHandlerInfo is interface with mixed 
+// input handlers
+//
+// author: 
+//        Martin Vala (martin.vala@cern.ch)
+//
+#ifndef ALIMIXINPUTHANDLERINFO_H
+#define ALIMIXINPUTHANDLERINFO_H
+#include <TArrayI.h>
+#include <TNamed.h>
+
+class TTree;
+class TChain;
+class TChainElement;
+class AliInputEventHandler;
+class AliMixInputHandlerInfo : public TNamed {
+
+public:
+  AliMixInputHandlerInfo(const char* name = "defautlTree", const char* title = "Defautl tree");
+  virtual ~AliMixInputHandlerInfo();
+  TChain *GetChain();
+  
+  void AddChain(TChain *chain);
+  void AddTreeToChain(TTree *tree);
+  
+  void PrepareEntry(TChainElement* te, Long64_t entry, AliInputEventHandler* eh);
+  
+  void SetZeroEntryNumber(Long64_t num) { fZeroEntryNumber = num;}
+  TChainElement* GetEntryInTree(Long64_t& entry);
+
+private:
+  TChain    *fChain;              // current chain
+  TArrayI   fChainEntriesArray;   // array of entries of every chaing
+  Long64_t  fZeroEntryNumber;     // zero entry number (will be used when we will delete not needed chains)
+  Bool_t    fNeedNotify;          // flag if Notify is needed for current input handler
+  
+  AliMixInputHandlerInfo(const AliMixInputHandlerInfo& handler);             
+  AliMixInputHandlerInfo& operator=(const AliMixInputHandlerInfo& handler);  
+
+  ClassDef(AliMixInputHandlerInfo, 1); // Mix Input Handler info
+};
+
+#endif // ALIMIXINPUTHANDLERINFO_H
diff --git a/ANALYSIS/EventMixingLinkDef.h b/ANALYSIS/EventMixingLinkDef.h
new file mode 100644 (file)
index 0000000..f78558c
--- /dev/null
@@ -0,0 +1,12 @@
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class AliMixEventInputHandler+;
+#pragma link C++ class AliMixInputHandlerInfo+;
+#pragma link C++ class AliMixEventPool+;
+#pragma link C++ class AliMixEventCutObj+;
+
+#endif
diff --git a/ANALYSIS/libEventMixing.pkg b/ANALYSIS/libEventMixing.pkg
new file mode 100644 (file)
index 0000000..916c9da
--- /dev/null
@@ -0,0 +1,21 @@
+#-*- Mode: Makefile -*-
+
+SRCS = \
+EventMixing/AliMixEventInputHandler.cxx \
+EventMixing/AliMixInputHandlerInfo.cxx \
+EventMixing/AliMixEventPool.cxx \
+EventMixing/AliMixEventCutObj.cxx
+
+HDRS:= $(SRCS:.cxx=.h) 
+
+DHDR= EventMixingLinkDef.h
+
+EXPORT:=$(SRCS:.cxx=.h)
+
+#EINCLUDE:= ANALYSIS ANALYSIS/Tender
+
+#ifeq (win32gcc,$(ALICE_TARGET))
+#PACKSOFLAGS:= $(SOFLAGS) -L$(ALICE_ROOT)/lib/tgt_$(ALICE_TARGET) -lSTEERBase \
+#                         -lANALYSIS -lCDB
+#endif