[u/mrichter/AliRoot.git] / ANALYSIS / AliEventPoolOTF.h

#ifndef ALIEVENTPOOLOTF_H
#define ALIEVENTPOOLOTF_H
 
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

// Realisation of an AliVEventPool via
// on the flight (OTF) generation of the bin using AliTagAnalysis.
// Author Andreas Morsch
// andreas.morsch@cern.ch

#include <AliVEventPool.h>
class AliRunTagCuts;
class AliLHCTagCuts;
class AliDetectorTagCuts;
class AliEventTagCuts;
class AliTagAnalysis;
class TGridResult;

typedef enum {kMultiplicity, kZVertex, kEventPlane, kLeadingParticleEta, kLeadingParticlePhi, kUser1, kUser2}  EventPoolAxis_t;

class AliEventPoolOTF : public AliVEventPool
{
 public:
    AliEventPoolOTF();
    AliEventPoolOTF(const char* name, const char* title = "AOD");

    virtual ~AliEventPoolOTF();
    // Interface
    virtual TChain* GetNextChain();
    virtual void  GetCurrentBin(Float_t* /*bin*/);
    virtual Int_t GetDimension();
    virtual void  Init();
    virtual void  SetMultiplicityBin(Int_t min, Int_t max, Int_t step)
	{fValueMin[kMultiplicity] = Float_t(min); fValueMax[kMultiplicity] = Float_t(max); fValueStep[kMultiplicity] = Float_t(step);}

    virtual void  SetMultiplicityBinning(Float_t min, Float_t max, Float_t step)
	{fValueMin[kMultiplicity] = min; fValueMax[kMultiplicity] = max; fValueStep[kMultiplicity] = step;}
    virtual void  SetZVertexBinning(Float_t min, Float_t max, Float_t step)
	{fValueMin[kZVertex] = min; fValueMax[kZVertex] = max; fValueStep[kZVertex] = step;}
    virtual void  SetEventPlaneBinning(Float_t min, Float_t max, Float_t step)
	{fValueMin[kEventPlane] = min; fValueMax[kEventPlane] = max; fValueStep[kEventPlane] = step;}
    virtual void  SetLeadingParticleEtaBinning(Float_t min, Float_t max, Float_t step)
	{fValueMin[kLeadingParticleEta] = min; fValueMax[kLeadingParticleEta] = max; fValueStep[kLeadingParticleEta] = step;}
  virtual void  SetLeadingParticlePhiBinning(Float_t min, Float_t max, Float_t step)
	{fValueMin[kLeadingParticlePhi] = min; fValueMax[kLeadingParticlePhi] = max; fValueStep[kLeadingParticlePhi] = step;}

    //
    void SetTagDirectory(const char* dirname) {fTagDirectory = dirname;};
    void SetGridResult(TGridResult*  gridTag) {fGridTags = gridTag;};
    virtual Int_t BinNumber() const {return fBinNumber;}
	    
 private:
    AliEventPoolOTF(const AliEventPoolOTF& obj);
    AliEventPoolOTF& operator=(const AliEventPoolOTF& other);
    void InitArrays();
    
 protected:
    AliTagAnalysis*      fTagAnalysis;   // Pointer to tag analysis
    AliRunTagCuts*       fRunCuts;       // Run      cuts
    AliLHCTagCuts*       fLHCCuts;       // LHC      cuts
    AliDetectorTagCuts*  fDetectorCuts;  // Detector cuts
    AliEventTagCuts*     fEventCuts;     // Event    cuts
    TGridResult*         fGridTags;      // Tags from a grid file collection
    TChain*              fChain;         // Current chain
    const char*          fTagDirectory;  // Directory with local tag files
    // Common pool cuts
    // Multiplicity
    Float_t              fValueMin[10];  // Minimum value
    Float_t              fValueMax[10];  // Maximum value
    Float_t              fValueStep[10]; // Step size
    Float_t              fValue[10];     // Current value
    //
    Int_t                fBinNumber;    // Current bin number
    Bool_t               fNoMore;       // No more bins 
    
    ClassDef(AliEventPoolOTF, 0); 
};
 
#endif
Commit	Line	Data
	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	{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	{fValueMin[kMultiplicity] = min; fValueMax[kMultiplicity] = max; fValueStep[kMultiplicity] = step;}
	41	virtual void SetZVertexBinning(Float_t min, Float_t max, Float_t step)
	42	{fValueMin[kZVertex] = min; fValueMax[kZVertex] = max; fValueStep[kZVertex] = step;}
	43	virtual void SetEventPlaneBinning(Float_t min, Float_t max, Float_t step)
	44	{fValueMin[kEventPlane] = min; fValueMax[kEventPlane] = max; fValueStep[kEventPlane] = step;}
	45	virtual void SetLeadingParticleEtaBinning(Float_t min, Float_t max, Float_t step)
	46	{fValueMin[kLeadingParticleEta] = min; fValueMax[kLeadingParticleEta] = max; fValueStep[kLeadingParticleEta] = step;}
	47	virtual void SetLeadingParticlePhiBinning(Float_t min, Float_t max, Float_t step)
	48	{fValueMin[kLeadingParticlePhi] = min; fValueMax[kLeadingParticlePhi] = max; fValueStep[kLeadingParticlePhi] = step;}
	49
	50	//
	51	void SetTagDirectory(const char* dirname) {fTagDirectory = dirname;};
	52	void SetGridResult(TGridResult* gridTag) {fGridTags = gridTag;};
	53	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	ClassDef(AliEventPoolOTF, 0);
	80	};
	81
	82	#endif