[u/mrichter/AliRoot.git] / HBTAN / AliHBTMonitorFunction.h

#ifndef ALIHBTMONITORFUNCTION_H
#define ALIHBTMONITORFUNCTION_H
//__________________________________________________________________
////////////////////////////////////////////////////////////////////
//
// class AliHBTMonitorFunction
//
// class AliHBTMonOneParticleFctn
// class AliHBTMonTwoParticleFctn
//
// class AliHBTMonOneParticleFctn1D
// class AliHBTMonOneParticleFctn2D
// class AliHBTMonOneParticleFctn3D
//
// class AliHBTMonTwoParticleFctn1D
// class AliHBTMonTwoParticleFctn2D
// class AliHBTMonTwoParticleFctn3D
//
// Base Classes for monitoring functions
// author: chajecki@if.pw.edu.pl
//
/******************************************************************/
/*
Base classes for monitor functions

          monitor function
               /    \
              /      \
             /        \
            /          \
           /            \
          /              \
         /                \
   one particle     two particle  
     /  |  \            /  |  \
    /   |   \          /   |   \
   1D  2D   3D        1D  2D   3D

Zbigniew.Chajecki@cern.ch

*/
///////////////////////////////////////////////////////////////////////

#include "AliAODParticleCut.h"

#include <TH2.h>
#include <TH3.h>

class AliVAODParticle;

class AliHBTMonitorFunction: public TNamed
//Abstract base class for HBT functions
{
  public:
    AliHBTMonitorFunction();
    AliHBTMonitorFunction(const char* name,const char* title);
    AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/);
    virtual ~AliHBTMonitorFunction();
    
    AliHBTMonitorFunction& operator=(const AliHBTMonitorFunction& /*in*/);
    
    
    virtual TH1* GetResult() = 0;

    virtual void Write();
    virtual void Init();
    virtual const char* Name(){return GetName();}
    void Rename(const Char_t * name); 
    void Rename(const Char_t * name, const Char_t * title); 
    
    void SetParticleCut(AliAODParticleCut* cut);

    virtual AliVAODParticle* CheckParticle(AliVAODParticle* particle) const;

  protected:
    AliAODParticleCut*      fParticleCut;//Particle cut
    
  private:  
   ClassDef(AliHBTMonitorFunction,1)
};
/******************************************************************/
/******************************************************************/
inline AliVAODParticle* AliHBTMonitorFunction::CheckParticle(AliVAODParticle* particle) const
{
  //check if particle meets the cut criteria
  if(fParticleCut->Rejected(particle)) //if the particle is BAD
   { 
     return 0x0;//it is BAD as well - so return
   }
  return particle; 
}

/******************************************************************/
/******************************************************************/
/******************************************************************/

class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
{
  public:
    AliHBTMonOneParticleFctn(){}
    AliHBTMonOneParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
    AliHBTMonOneParticleFctn(const AliHBTMonOneParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
    virtual ~AliHBTMonOneParticleFctn(){}
    
    AliHBTMonOneParticleFctn& operator=(const AliHBTMonOneParticleFctn& /*in*/){MayNotUse("operator=");return *this;} 
    
    virtual void Process(AliVAODParticle* particle) = 0;
    
  protected:
  private:  
   ClassDef(AliHBTMonOneParticleFctn,1)
  
};
/******************************************************************/
class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
{
 public:
  AliHBTMonOneParticleFctn1D();
  AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
  AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
                      Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
  AliHBTMonOneParticleFctn1D(const AliHBTMonOneParticleFctn1D& in):
               AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
  
  virtual ~AliHBTMonOneParticleFctn1D();
  
  AliHBTMonOneParticleFctn1D& operator=(const AliHBTMonOneParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}   
  TH1* GetResult(){return this->fResult;}

  void Process(AliVAODParticle* particle);

 protected:
  virtual Double_t GetValue(AliVAODParticle* particle) const = 0; 
  TH1D* fResult;//histogram to be filled
 private:
  ClassDef(AliHBTMonOneParticleFctn1D,2)
};
/******************************************************************/
 
class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
{
 public:
  AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
                      Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
  AliHBTMonOneParticleFctn2D(const AliHBTMonOneParticleFctn2D& in):
               AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
  virtual ~AliHBTMonOneParticleFctn2D();
  
  AliHBTMonOneParticleFctn2D& operator=(const AliHBTMonOneParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}   
  TH1* GetResult(){return this->fResult;}
  
  void Process(AliVAODParticle* particle);

 protected:
  virtual void GetValues(AliVAODParticle* particle, Double_t&, Double_t&) const = 0;

  TH2D* fResult;//histogram to be filled
  
 private:
  ClassDef(AliHBTMonOneParticleFctn2D,1)
};
/******************************************************************/
/******************************************************************/
/******************************************************************/

class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
{
 public:
  AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
                      Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15, 
                      Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
  AliHBTMonOneParticleFctn3D(const AliHBTMonOneParticleFctn3D& in):
               AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	    
  virtual ~AliHBTMonOneParticleFctn3D();

  AliHBTMonOneParticleFctn3D& operator=(const AliHBTMonOneParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}   
  TH1* GetResult(){return this->fResult;}

 protected:
  TH3D* fResult;//histogram to be filled

 private:
  ClassDef(AliHBTMonOneParticleFctn3D,1)
};
/******************************************************************/
/******************************************************************/
class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
{
  public:
    AliHBTMonTwoParticleFctn(){};
    AliHBTMonTwoParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
    AliHBTMonTwoParticleFctn(const AliHBTMonTwoParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
    virtual ~AliHBTMonTwoParticleFctn(){};
    AliHBTMonTwoParticleFctn& operator=(const AliHBTMonTwoParticleFctn& /*in*/){MayNotUse("operator=");return *this;} 
    
    virtual void 
    Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle) = 0;
	     
  protected:
  private:  
   ClassDef(AliHBTMonTwoParticleFctn,1)
  
};
/******************************************************************/

class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
{
 public:
  AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
  AliHBTMonTwoParticleFctn1D(const char* name,const char* title,
                      Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
  AliHBTMonTwoParticleFctn1D(const AliHBTMonTwoParticleFctn1D& in):
               AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
  virtual ~AliHBTMonTwoParticleFctn1D();
  
  AliHBTMonTwoParticleFctn1D& operator=(const AliHBTMonTwoParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}   
  TH1* GetResult(){return this->fResult;}
  
  void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
  
 protected:
  virtual Double_t GetValue(AliVAODParticle* trackparticle, AliVAODParticle* partparticle) const = 0;

  TH1D* fResult;//histogram to be filled

 private:
  ClassDef(AliHBTMonTwoParticleFctn1D,1)
};
/******************************************************************/
class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
{
 public:
  AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0, 
                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
  AliHBTMonTwoParticleFctn2D(const AliHBTMonTwoParticleFctn2D& in):
               AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
  virtual ~AliHBTMonTwoParticleFctn2D();
  
  AliHBTMonTwoParticleFctn2D& operator=(const AliHBTMonTwoParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}   
  TH1* GetResult(){return this->fResult;}
  
  void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
  
 protected:
  virtual void GetValues(AliVAODParticle*,AliVAODParticle*, Double_t&, Double_t&) const = 0;

  TH2D* fResult;//histogram to be filled
  
 private:
  ClassDef(AliHBTMonTwoParticleFctn2D,1)
};


/******************************************************************/
class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
{
 public:
  AliHBTMonTwoParticleFctn3D(Int_t /*nXbins = 200*/, Double_t /*maxXval = 1.5*/, Double_t /*minXval = 0.0*/, 
			     Int_t /*nYbins = 200*/, Double_t /*maxYval = .15*/, Double_t /*minYval =-0.15*/, 
			     Int_t /*nZbins = 200*/, Double_t /*maxZval = .15*/, Double_t /*minZval =-0.15*/){}
  AliHBTMonTwoParticleFctn3D(const AliHBTMonTwoParticleFctn3D& in):
               AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
  virtual ~AliHBTMonTwoParticleFctn3D(){}
  
  AliHBTMonTwoParticleFctn3D& operator=(const AliHBTMonTwoParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}   
  TH1* GetResult(){return this->fResult;}
  
  void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);

 protected:
  virtual void GetValues(AliVAODParticle*,AliVAODParticle*, Double_t&, Double_t&,Double_t&) const = 0;

  TH3D* fResult; //histogram to be filled
  
 private:
  ClassDef(AliHBTMonTwoParticleFctn3D,1)
};

/******************************************************************/
/******************************************************************/
/******************************************************************/
/******************************************************************/

#endif
Commit	Line	Data
	1	#ifndef ALIHBTMONITORFUNCTION_H
	2	#define ALIHBTMONITORFUNCTION_H
	3	//__________________________________________________________________
	4	////////////////////////////////////////////////////////////////////
	5	//
	6	// class AliHBTMonitorFunction
	7	//
	8	// class AliHBTMonOneParticleFctn
	9	// class AliHBTMonTwoParticleFctn
	10	//
	11	// class AliHBTMonOneParticleFctn1D
	12	// class AliHBTMonOneParticleFctn2D
	13	// class AliHBTMonOneParticleFctn3D
	14	//
	15	// class AliHBTMonTwoParticleFctn1D
	16	// class AliHBTMonTwoParticleFctn2D
	17	// class AliHBTMonTwoParticleFctn3D
	18	//
	19	// Base Classes for monitoring functions
	20	// author: chajecki@if.pw.edu.pl
	21	//
	22	/******************************************************************/
	23	/*
	24	Base classes for monitor functions
	25
	26	monitor function
	27	/ \
	28	/ \
	29	/ \
	30	/ \
	31	/ \
	32	/ \
	33	/ \
	34	one particle two particle
	35	/ \| \ / \| \
	36	/ \| \ / \| \
	37	1D 2D 3D 1D 2D 3D
	38
	39	Zbigniew.Chajecki@cern.ch
	40
	41	*/
	42	///////////////////////////////////////////////////////////////////////
	43
	44	#include "AliAODParticleCut.h"
	45
	46	#include <TH2.h>
	47	#include <TH3.h>
	48
	49	class AliVAODParticle;
	50
	51	class AliHBTMonitorFunction: public TNamed
	52	//Abstract base class for HBT functions
	53	{
	54	public:
	55	AliHBTMonitorFunction();
	56	AliHBTMonitorFunction(const char* name,const char* title);
	57	AliHBTMonitorFunction(const AliHBTMonitorFunction& /in/);
	58	virtual ~AliHBTMonitorFunction();
	59
	60	AliHBTMonitorFunction& operator=(const AliHBTMonitorFunction& /in/);
	61
	62
	63	virtual TH1* GetResult() = 0;
	64
	65	virtual void Write();
	66	virtual void Init();
	67	virtual const char* Name(){return GetName();}
	68	void Rename(const Char_t * name);
	69	void Rename(const Char_t * name, const Char_t * title);
	70
	71	void SetParticleCut(AliAODParticleCut* cut);
	72
	73	virtual AliVAODParticle* CheckParticle(AliVAODParticle* particle) const;
	74
	75	protected:
	76	AliAODParticleCut* fParticleCut;//Particle cut
	77
	78	private:
	79	ClassDef(AliHBTMonitorFunction,1)
	80	};
	81	/******************************************************************/
	82	/******************************************************************/
	83	inline AliVAODParticle* AliHBTMonitorFunction::CheckParticle(AliVAODParticle* particle) const
	84	{
	85	//check if particle meets the cut criteria
	86	if(fParticleCut->Rejected(particle)) //if the particle is BAD
	87	{
	88	return 0x0;//it is BAD as well - so return
	89	}
	90	return particle;
	91	}
	92
	93	/******************************************************************/
	94	/******************************************************************/
	95	/******************************************************************/
	96
	97	class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
	98	{
	99	public:
	100	AliHBTMonOneParticleFctn(){}
	101	AliHBTMonOneParticleFctn(const Char_t name, const Char_t title):AliHBTMonitorFunction(name,title){}
	102	AliHBTMonOneParticleFctn(const AliHBTMonOneParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
	103	virtual ~AliHBTMonOneParticleFctn(){}
	104
	105	AliHBTMonOneParticleFctn& operator=(const AliHBTMonOneParticleFctn& /in/){MayNotUse("operator=");return *this;}
	106
	107	virtual void Process(AliVAODParticle* particle) = 0;
	108
	109	protected:
	110	private:
	111	ClassDef(AliHBTMonOneParticleFctn,1)
	112
	113	};
	114	/******************************************************************/
	115	class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
	116	{
	117	public:
	118	AliHBTMonOneParticleFctn1D();
	119	AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
	120	AliHBTMonOneParticleFctn1D(const Char_t name, const Char_t title,
	121	Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
	122	AliHBTMonOneParticleFctn1D(const AliHBTMonOneParticleFctn1D& in):
	123	AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	124
	125	virtual ~AliHBTMonOneParticleFctn1D();
	126
	127	AliHBTMonOneParticleFctn1D& operator=(const AliHBTMonOneParticleFctn1D& /in/){MayNotUse("operator=");return *this;}
	128	TH1* GetResult(){return this->fResult;}
	129
	130	void Process(AliVAODParticle* particle);
	131
	132	protected:
	133	virtual Double_t GetValue(AliVAODParticle* particle) const = 0;
	134	TH1D* fResult;//histogram to be filled
	135	private:
	136	ClassDef(AliHBTMonOneParticleFctn1D,2)
	137	};
	138	/******************************************************************/
	139
	140	class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
	141	{
	142	public:
	143	AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	144	Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
	145	AliHBTMonOneParticleFctn2D(const AliHBTMonOneParticleFctn2D& in):
	146	AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	147	virtual ~AliHBTMonOneParticleFctn2D();
	148
	149	AliHBTMonOneParticleFctn2D& operator=(const AliHBTMonOneParticleFctn2D& /in/){MayNotUse("operator=");return *this;}
	150	TH1* GetResult(){return this->fResult;}
	151
	152	void Process(AliVAODParticle* particle);
	153
	154	protected:
	155	virtual void GetValues(AliVAODParticle* particle, Double_t&, Double_t&) const = 0;
	156
	157	TH2D* fResult;//histogram to be filled
	158
	159	private:
	160	ClassDef(AliHBTMonOneParticleFctn2D,1)
	161	};
	162	/******************************************************************/
	163	/******************************************************************/
	164	/******************************************************************/
	165
	166	class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
	167	{
	168	public:
	169	AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	170	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
	171	Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
	172	AliHBTMonOneParticleFctn3D(const AliHBTMonOneParticleFctn3D& in):
	173	AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	174
	175	virtual ~AliHBTMonOneParticleFctn3D();
	176
	177	AliHBTMonOneParticleFctn3D& operator=(const AliHBTMonOneParticleFctn3D& /in/){MayNotUse("operator=");return *this;}
	178	TH1* GetResult(){return this->fResult;}
	179
	180	protected:
	181	TH3D* fResult;//histogram to be filled
	182
	183	private:
	184	ClassDef(AliHBTMonOneParticleFctn3D,1)
	185	};
	186	/******************************************************************/
	187	/******************************************************************/
	188	class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
	189	{
	190	public:
	191	AliHBTMonTwoParticleFctn(){};
	192	AliHBTMonTwoParticleFctn(const Char_t name, const Char_t title):AliHBTMonitorFunction(name,title){}
	193	AliHBTMonTwoParticleFctn(const AliHBTMonTwoParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
	194	virtual ~AliHBTMonTwoParticleFctn(){};
	195	AliHBTMonTwoParticleFctn& operator=(const AliHBTMonTwoParticleFctn& /in/){MayNotUse("operator=");return *this;}
	196
	197	virtual void
	198	Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle) = 0;
	199
	200	protected:
	201	private:
	202	ClassDef(AliHBTMonTwoParticleFctn,1)
	203
	204	};
	205	/******************************************************************/
	206
	207	class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
	208	{
	209	public:
	210	AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
	211	AliHBTMonTwoParticleFctn1D(const char* name,const char* title,
	212	Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
	213	AliHBTMonTwoParticleFctn1D(const AliHBTMonTwoParticleFctn1D& in):
	214	AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	215	virtual ~AliHBTMonTwoParticleFctn1D();
	216
	217	AliHBTMonTwoParticleFctn1D& operator=(const AliHBTMonTwoParticleFctn1D& /in/){MayNotUse("operator=");return *this;}
	218	TH1* GetResult(){return this->fResult;}
	219
	220	void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
	221
	222	protected:
	223	virtual Double_t GetValue(AliVAODParticle* trackparticle, AliVAODParticle* partparticle) const = 0;
	224
	225	TH1D* fResult;//histogram to be filled
	226
	227	private:
	228	ClassDef(AliHBTMonTwoParticleFctn1D,1)
	229	};
	230	/******************************************************************/
	231	class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
	232	{
	233	public:
	234	AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	235	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
	236	AliHBTMonTwoParticleFctn2D(const AliHBTMonTwoParticleFctn2D& in):
	237	AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	238	virtual ~AliHBTMonTwoParticleFctn2D();
	239
	240	AliHBTMonTwoParticleFctn2D& operator=(const AliHBTMonTwoParticleFctn2D& /in/){MayNotUse("operator=");return *this;}
	241	TH1* GetResult(){return this->fResult;}
	242
	243	void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
	244
	245	protected:
	246	virtual void GetValues(AliVAODParticle,AliVAODParticle, Double_t&, Double_t&) const = 0;
	247
	248	TH2D* fResult;//histogram to be filled
	249
	250	private:
	251	ClassDef(AliHBTMonTwoParticleFctn2D,1)
	252	};
	253
	254
	255	/******************************************************************/
	256	class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
	257	{
	258	public:
	259	AliHBTMonTwoParticleFctn3D(Int_t /nXbins = 200/, Double_t /maxXval = 1.5/, Double_t /minXval = 0.0/,
	260	Int_t /nYbins = 200/, Double_t /maxYval = .15/, Double_t /minYval =-0.15/,
	261	Int_t /nZbins = 200/, Double_t /maxZval = .15/, Double_t /minZval =-0.15/){}
	262	AliHBTMonTwoParticleFctn3D(const AliHBTMonTwoParticleFctn3D& in):
	263	AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
	264	virtual ~AliHBTMonTwoParticleFctn3D(){}
	265
	266	AliHBTMonTwoParticleFctn3D& operator=(const AliHBTMonTwoParticleFctn3D& /in/){MayNotUse("operator=");return *this;}
	267	TH1* GetResult(){return this->fResult;}
	268
	269	void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
	270
	271	protected:
	272	virtual void GetValues(AliVAODParticle,AliVAODParticle, Double_t&, Double_t&,Double_t&) const = 0;
	273
	274	TH3D* fResult; //histogram to be filled
	275
	276	private:
	277	ClassDef(AliHBTMonTwoParticleFctn3D,1)
	278	};
	279
	280	/******************************************************************/
	281	/******************************************************************/
	282	/******************************************************************/
	283	/******************************************************************/
	284
	285	#endif