Line data    Source code

       1             : #ifndef ALIEVENTPOOLOTF_H
       2             : #define ALIEVENTPOOLOTF_H
       3             :  
       4             : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
       5             :  * See cxx source for full Copyright notice                               */
       6             : 
       7             : /* $Id$ */
       8             : 
       9             : // Realisation of an AliVEventPool via
      10             : // on the flight (OTF) generation of the bin using AliTagAnalysis.
      11             : // Author Andreas Morsch
      12             : // andreas.morsch@cern.ch
      13             : 
      14             : #include <AliVEventPool.h>
      15             : class AliRunTagCuts;
      16             : class AliLHCTagCuts;
      17             : class AliDetectorTagCuts;
      18             : class AliEventTagCuts;
      19             : class AliTagAnalysis;
      20             : class TGridResult;
      21             : 
      22             : typedef enum {kMultiplicity, kZVertex, kEventPlane, kLeadingParticleEta, kLeadingParticlePhi, kUser1, kUser2}  EventPoolAxis_t;
      23             : 
      24             : class AliEventPoolOTF : public AliVEventPool
      25             : {
      26             :  public:
      27             :     AliEventPoolOTF();
      28             :     AliEventPoolOTF(const char* name, const char* title = "AOD");
      29             : 
      30             :     virtual ~AliEventPoolOTF();
      31             :     // Interface
      32             :     virtual TChain* GetNextChain();
      33             :     virtual void  GetCurrentBin(Float_t* /*bin*/);
      34             :     virtual Int_t GetDimension();
      35             :     virtual void  Init();
      36             :     virtual void  SetMultiplicityBin(Int_t min, Int_t max, Int_t step)
      37           0 :         {fValueMin[kMultiplicity] = Float_t(min); fValueMax[kMultiplicity] = Float_t(max); fValueStep[kMultiplicity] = Float_t(step);}
      38             : 
      39             :     virtual void  SetMultiplicityBinning(Float_t min, Float_t max, Float_t step)
      40           0 :         {fValueMin[kMultiplicity] = min; fValueMax[kMultiplicity] = max; fValueStep[kMultiplicity] = step;}
      41             :     virtual void  SetZVertexBinning(Float_t min, Float_t max, Float_t step)
      42           0 :         {fValueMin[kZVertex] = min; fValueMax[kZVertex] = max; fValueStep[kZVertex] = step;}
      43             :     virtual void  SetEventPlaneBinning(Float_t min, Float_t max, Float_t step)
      44           0 :         {fValueMin[kEventPlane] = min; fValueMax[kEventPlane] = max; fValueStep[kEventPlane] = step;}
      45             :     virtual void  SetLeadingParticleEtaBinning(Float_t min, Float_t max, Float_t step)
      46           0 :         {fValueMin[kLeadingParticleEta] = min; fValueMax[kLeadingParticleEta] = max; fValueStep[kLeadingParticleEta] = step;}
      47             :   virtual void  SetLeadingParticlePhiBinning(Float_t min, Float_t max, Float_t step)
      48           0 :         {fValueMin[kLeadingParticlePhi] = min; fValueMax[kLeadingParticlePhi] = max; fValueStep[kLeadingParticlePhi] = step;}
      49             : 
      50             :     //
      51           0 :     void SetTagDirectory(const char* dirname) {fTagDirectory = dirname;};
      52           0 :     void SetGridResult(TGridResult*  gridTag) {fGridTags = gridTag;};
      53           0 :     virtual Int_t BinNumber() const {return fBinNumber;}
      54             :             
      55             :  private:
      56             :     AliEventPoolOTF(const AliEventPoolOTF& obj);
      57             :     AliEventPoolOTF& operator=(const AliEventPoolOTF& other);
      58             :     void InitArrays();
      59             :     
      60             :  protected:
      61             :     AliTagAnalysis*      fTagAnalysis;   // Pointer to tag analysis
      62             :     AliRunTagCuts*       fRunCuts;       // Run      cuts
      63             :     AliLHCTagCuts*       fLHCCuts;       // LHC      cuts
      64             :     AliDetectorTagCuts*  fDetectorCuts;  // Detector cuts
      65             :     AliEventTagCuts*     fEventCuts;     // Event    cuts
      66             :     TGridResult*         fGridTags;      // Tags from a grid file collection
      67             :     TChain*              fChain;         // Current chain
      68             :     const char*          fTagDirectory;  // Directory with local tag files
      69             :     // Common pool cuts
      70             :     // Multiplicity
      71             :     Float_t              fValueMin[10];  // Minimum value
      72             :     Float_t              fValueMax[10];  // Maximum value
      73             :     Float_t              fValueStep[10]; // Step size
      74             :     Float_t              fValue[10];     // Current value
      75             :     //
      76             :     Int_t                fBinNumber;    // Current bin number
      77             :     Bool_t               fNoMore;       // No more bins 
      78             :     
      79         170 :     ClassDef(AliEventPoolOTF, 0); 
      80             : };
      81             :  
      82             : #endif