[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();
    
    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 ProcessSameEventParticles(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 ProcessSameEventParticles(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 ProcessSameEventParticles(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 
    ProcessSameEventParticles(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 ProcessSameEventParticles(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 ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
  void ProcessDiffEventParticles(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 ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
  void ProcessDiffEventParticles(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
a57afe91	1	//Zbigniew.Chajecki@cern.ch
	2
	3	#ifndef ALIMONITORFUNCTION_H
	4	#define ALIMONITORFUNCTION_H
	5
	6	#include "AliHBTParticleCut.h"
	7	#include "AliHBTParticle.h"
	8
	9	#include <TH2.h>
	10	#include <TH3.h>
	11
	12	//class AliHBTAnalysis;
	13
	14	class AliHBTMonitorFunction: public TNamed
	15	//Abstract base class for HBT functions
	16	{
	17	public:
	18	AliHBTMonitorFunction();
	19	AliHBTMonitorFunction(const char* name,const char* title);
	20	virtual ~AliHBTMonitorFunction();
	21
	22	virtual TH1* GetResult() = 0;
	23
	24	virtual void Write();
	25
	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	/******************************************************************/
	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
	45	{
	46	return 0x0;//it is BAD as well - so return
	47	}
	48	return particle;
	49	}
	50
	51	/******************************************************************/
	52	/******************************************************************/
	53	/******************************************************************/
	54
	55	class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
	56	{
	57	public:
	58	AliHBTMonOneParticleFctn(){}
	59	AliHBTMonOneParticleFctn(const Char_t name, const Char_t title):AliHBTMonitorFunction(name,title){}
	60	virtual ~AliHBTMonOneParticleFctn(){}
	61
	62	virtual void ProcessSameEventParticles(AliHBTParticle* particle) = 0;
	63
	64	protected:
65	public:
66	ClassDef(AliHBTMonOneParticleFctn,1)
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,
76	Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
77	virtual ~AliHBTMonOneParticleFctn1D();
78
79	TH1* GetResult(){return fResult;}
80
81	void ProcessSameEventParticles(AliHBTParticle* particle);
82
83	protected:
84	virtual Double_t GetValue(AliHBTParticle* particle) = 0;
85
86	TH1D* fResult;
87
88	public:
89	ClassDef(AliHBTMonOneParticleFctn1D,2)
90	};
91	/******************************************************************/
92
93	class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
94	{
95	public:
96	AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
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
	102	void ProcessSameEventParticles(AliHBTParticle* particle);
	103
	104	protected:
	105	virtual void GetValues(AliHBTParticle* particle, Double_t&, Double_t&) = 0;
	106
	107	TH2D* fResult;
	108
	109	public:
	110	ClassDef(AliHBTMonOneParticleFctn2D,1)
	111	};
	112	/******************************************************************/
	113	/******************************************************************/
	114	/******************************************************************/
	115
	116	class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
	117	{
	118	public:
	119	AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	120	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
	121	Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
	122
	123	virtual ~AliHBTMonOneParticleFctn3D();
	124
	125	TH1* GetResult(){return fResult;}
	126
	127	protected:
	128	TH3D* fResult;
	129
	130	public:
	131	ClassDef(AliHBTMonOneParticleFctn3D,1)
	132	};
	133	/******************************************************************/
	134	/******************************************************************/
	135	class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
	136	{
	137	public:
	138	AliHBTMonTwoParticleFctn(){};
	139	AliHBTMonTwoParticleFctn(const Char_t name, const Char_t title):AliHBTMonitorFunction(name,title){}
	140	virtual ~AliHBTMonTwoParticleFctn(){};
	141
	142	virtual void
	143	ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
	144
	145	protected:
	146	public:
	147	ClassDef(AliHBTMonTwoParticleFctn,1)
	148
	149	};
	150	/******************************************************************/
	151
	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,
	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
	162	void ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
	163
	164	protected:
	165	virtual Double_t GetValue(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
	166
	167	TH1D* fResult;
	168
	169	public:
	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,
	177	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
	178	virtual ~AliHBTMonTwoParticleFctn2D();
	179
	180	TH1* GetResult(){return fResult;}
	181
	182	void ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
	183	void ProcessDiffEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle){};
	184
	185
	186	protected:
	187	virtual void GetValues(AliHBTParticle,AliHBTParticle, Double_t&, Double_t&) = 0;
	188
	189	TH2D* fResult;
	190
	191	public:
	192	ClassDef(AliHBTMonTwoParticleFctn2D,1)
	193	};
	194
	195
	196	/******************************************************************/
	197	class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
	198	{
	199	public:
	200	AliHBTMonTwoParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	201	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
	202	Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
	203	virtual ~AliHBTMonTwoParticleFctn3D(){}
	204
	205	TH1* GetResult(){return fResult;}
	206
	207	void ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
	208	void ProcessDiffEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle){};
	209
	210
	211	protected:
	212	virtual void GetValues(AliHBTParticle,AliHBTParticle, Double_t&, Double_t&,Double_t&) = 0;
	213
	214	TH3D* fResult;
	215
	216	public:
	217	ClassDef(AliHBTMonTwoParticleFctn3D,1)
	218	};
	219
	220	/******************************************************************/
	221	/******************************************************************/
	222	/******************************************************************/
223	/******************************************************************/
224
225	#endif