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

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

/* $Id$ */

//__________________________________________________________________
////////////////////////////////////////////////////////////////////
//
// 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 <TMath.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;

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