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

//Zbigniew.Chajecki@cern.ch

#ifndef ALIMONITORFUNCTION_H
#define ALIMONITORFUNCTION_H

#include "AliHBTParticleCut.h"
#include "AliHBTParticle.h"  

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

//class AliHBTAnalysis;

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

    virtual void Write();
    virtual void Init(){}
    void Rename(const Char_t * name); 
    void Rename(const Char_t * name, const Char_t * title); 
    
    void SetParticleCut(AliHBTParticleCut*);

    virtual AliHBTParticle* CheckParticle(AliHBTParticle* particle);

  protected:
    AliHBTParticleCut*      fParticleCut;
    
  public:  
   ClassDef(AliHBTMonitorFunction,1)
};
/******************************************************************/
/******************************************************************/
inline AliHBTParticle* AliHBTMonitorFunction::CheckParticle(AliHBTParticle* particle)
{
  //check if particle meets the cut criteria
  if(fParticleCut->Pass(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){}
    virtual ~AliHBTMonOneParticleFctn(){}
    
    virtual void Process(AliHBTParticle* particle) = 0;
    
  protected:
  public:  
   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);
  virtual ~AliHBTMonOneParticleFctn1D();
  
  TH1* GetResult(){return fResult;}

  void Process(AliHBTParticle* particle);

 protected:
  virtual Double_t GetValue(AliHBTParticle* particle) = 0; 

  TH1D* fResult;
  
 public:
  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);
  virtual ~AliHBTMonOneParticleFctn2D();
  
  TH1* GetResult(){return fResult;}
  
  void Process(AliHBTParticle* particle);

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

  TH2D* fResult;
  
 public:
  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);
	    
  virtual ~AliHBTMonOneParticleFctn3D();

  TH1* GetResult(){return fResult;}

 protected:
  TH3D* fResult;

 public:
  ClassDef(AliHBTMonOneParticleFctn3D,1)
};
/******************************************************************/
/******************************************************************/
class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
{
  public:
    AliHBTMonTwoParticleFctn(){};
    AliHBTMonTwoParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
    virtual ~AliHBTMonTwoParticleFctn(){};
    
    virtual void 
    Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
	     
  protected:
  public:  
   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*,const char*,
                      Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
  virtual ~AliHBTMonTwoParticleFctn1D();
  
  TH1* GetResult(){return fResult;}
  
  void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
  
 protected:
  virtual Double_t GetValue(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;

  TH1D* fResult;

 public:
  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);
  virtual ~AliHBTMonTwoParticleFctn2D();
  
  TH1* GetResult(){return fResult;}
  
  void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
  
 protected:
  virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&) = 0;

  TH2D* fResult;
  
 public:
  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){}
  virtual ~AliHBTMonTwoParticleFctn3D(){}
  
  TH1* GetResult(){return fResult;}
  
  void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);

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

  TH3D* fResult;
  
 public:
  ClassDef(AliHBTMonTwoParticleFctn3D,1)
};

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

#endif
Commit	Line	Data
b98bda8e	1	//Zbigniew.Chajecki@cern.ch
b98bda8e	2
a57afe91	3	#ifndef ALIMONITORFUNCTION_H
	4	#define ALIMONITORFUNCTION_H
	5
	6	#include "AliHBTParticleCut.h"
	7	#include "AliHBTParticle.h"
	8
b98bda8e	9	#include <TH2.h>
b98bda8e	10	#include <TH3.h>
a57afe91	11
	12	//class AliHBTAnalysis;
	13
	14	class AliHBTMonitorFunction: public TNamed
	15	//Abstract base class for HBT functions
	16	{
b98bda8e	17	public:
	18	AliHBTMonitorFunction();
	19	AliHBTMonitorFunction(const char* name,const char* title);
	20	virtual ~AliHBTMonitorFunction();
a57afe91	21
b98bda8e	22	virtual TH1* GetResult() = 0;
604034d8	23
b98bda8e	24	virtual void Write();
	25	virtual void Init(){}
	26	void Rename(const Char_t * name);
	27	void Rename(const Char_t * name, const Char_t * title);
	28
	29	void SetParticleCut(AliHBTParticleCut*);
	30
	31	virtual AliHBTParticle* CheckParticle(AliHBTParticle* particle);
	32
	33	protected:
	34	AliHBTParticleCut* fParticleCut;
	35
	36	public:
	37	ClassDef(AliHBTMonitorFunction,1)
	38	};
	39	/******************************************************************/
a57afe91	40	/******************************************************************/
	41	inline AliHBTParticle* AliHBTMonitorFunction::CheckParticle(AliHBTParticle* particle)
	42	{
	43	//check if particle meets the cut criteria
	44	if(fParticleCut->Pass(particle)) //if the particle is BAD
b98bda8e	45	{
	46	return 0x0;//it is BAD as well - so return
	47	}
a57afe91	48	return particle;
	49	}
	50
	51	/******************************************************************/
b98bda8e	52	/******************************************************************/
	53	/******************************************************************/
	54
a57afe91	55	class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
a57afe91	56	{
b98bda8e	57	public:
	58	AliHBTMonOneParticleFctn(){}
	59	AliHBTMonOneParticleFctn(const Char_t name, const Char_t title):AliHBTMonitorFunction(name,title){}
	60	virtual ~AliHBTMonOneParticleFctn(){}
a57afe91	61
b98bda8e	62	virtual void Process(AliHBTParticle* particle) = 0;
a57afe91	63
b98bda8e	64	protected:
	65	public:
	66	ClassDef(AliHBTMonOneParticleFctn,1)
a57afe91	67
	68	};
	69	/******************************************************************/
	70	class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
	71	{
	72	public:
	73	AliHBTMonOneParticleFctn1D();
	74	AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
	75	AliHBTMonOneParticleFctn1D(const Char_t name, const Char_t title,
b98bda8e	76	Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
a57afe91	77	virtual ~AliHBTMonOneParticleFctn1D();
	78
	79	TH1* GetResult(){return fResult;}
	80
e4f2b1da	81	void Process(AliHBTParticle* particle);
a57afe91	82
	83	protected:
	84	virtual Double_t GetValue(AliHBTParticle* particle) = 0;
	85
	86	TH1D* fResult;
	87
b98bda8e	88	public:
a57afe91	89	ClassDef(AliHBTMonOneParticleFctn1D,2)
a57afe91	90	};
b98bda8e	91	/******************************************************************/
b98bda8e	92
a57afe91	93	class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
	94	{
	95	public:
	96	AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
b98bda8e	97	Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
8961c985	98	virtual ~AliHBTMonOneParticleFctn2D();
a57afe91	99
	100	TH1* GetResult(){return fResult;}
	101
e4f2b1da	102	void Process(AliHBTParticle* particle);
b98bda8e	103
a57afe91	104	protected:
	105	virtual void GetValues(AliHBTParticle* particle, Double_t&, Double_t&) = 0;
	106
	107	TH2D* fResult;
	108
b98bda8e	109	public:
a57afe91	110	ClassDef(AliHBTMonOneParticleFctn2D,1)
a57afe91	111	};
604034d8	112	/******************************************************************/
b98bda8e	113	/******************************************************************/
	114	/******************************************************************/
	115
a57afe91	116	class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
	117	{
	118	public:
	119	AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
b98bda8e	120	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
b98bda8e	121	Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
a57afe91	122
	123	virtual ~AliHBTMonOneParticleFctn3D();
	124
	125	TH1* GetResult(){return fResult;}
	126
	127	protected:
	128	TH3D* fResult;
	129
b98bda8e	130	public:
a57afe91	131	ClassDef(AliHBTMonOneParticleFctn3D,1)
a57afe91	132	};
b98bda8e	133	/******************************************************************/
a57afe91	134	/******************************************************************/
	135	class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
	136	{
b98bda8e	137	public:
	138	AliHBTMonTwoParticleFctn(){};
	139	AliHBTMonTwoParticleFctn(const Char_t name, const Char_t title):AliHBTMonitorFunction(name,title){}
	140	virtual ~AliHBTMonTwoParticleFctn(){};
	141
	142	virtual void
e4f2b1da	143	Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
b98bda8e	144
	145	protected:
	146	public:
	147	ClassDef(AliHBTMonTwoParticleFctn,1)
a57afe91	148
a57afe91	149	};
604034d8	150	/******************************************************************/
b98bda8e	151
a57afe91	152	class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
	153	{
	154	public:
	155	AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
	156	AliHBTMonTwoParticleFctn1D(const char,const char,
b98bda8e	157	Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
8961c985	158	virtual ~AliHBTMonTwoParticleFctn1D();
a57afe91	159
	160	TH1* GetResult(){return fResult;}
	161
e4f2b1da	162	void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
a57afe91	163
	164	protected:
	165	virtual Double_t GetValue(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
	166
	167	TH1D* fResult;
	168
b98bda8e	169	public:
a57afe91	170	ClassDef(AliHBTMonTwoParticleFctn1D,1)
	171	};
	172	/******************************************************************/
	173	class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
	174	{
	175	public:
	176	AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
b98bda8e	177	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
a57afe91	178	virtual ~AliHBTMonTwoParticleFctn2D();
	179
	180	TH1* GetResult(){return fResult;}
	181
e4f2b1da	182	void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
a57afe91	183
	184	protected:
	185	virtual void GetValues(AliHBTParticle,AliHBTParticle, Double_t&, Double_t&) = 0;
	186
	187	TH2D* fResult;
	188
b98bda8e	189	public:
a57afe91	190	ClassDef(AliHBTMonTwoParticleFctn2D,1)
	191	};
	192
b98bda8e	193
a57afe91	194	/******************************************************************/
	195	class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
	196	{
	197	public:
	198	AliHBTMonTwoParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
b98bda8e	199	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
b98bda8e	200	Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
a57afe91	201	virtual ~AliHBTMonTwoParticleFctn3D(){}
	202
	203	TH1* GetResult(){return fResult;}
	204
e4f2b1da	205	void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
e4f2b1da	206
a57afe91	207	protected:
	208	virtual void GetValues(AliHBTParticle,AliHBTParticle, Double_t&, Double_t&,Double_t&) = 0;
	209
	210	TH3D* fResult;
	211
b98bda8e	212	public:
a57afe91	213	ClassDef(AliHBTMonTwoParticleFctn3D,1)
	214	};
	215
b98bda8e	216	/******************************************************************/
	217	/******************************************************************/
	218	/******************************************************************/
	219	/******************************************************************/
	220
a57afe91	221	#endif