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

//Piotr Skowronski@cern.ch

#ifndef ALIHBTFUNCTION_H
#define ALIHBTFUNCTION_H

#include "AliHBTParticleCut.h"
#include "AliHBTPairCut.h"
#include "AliHBTPair.h"

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


class AliHBTAnalysis;

class AliHBTFunction: public TNamed
//Abstract base class for HBT functions
{
  public:
    AliHBTFunction();
    virtual ~AliHBTFunction(){delete fPairCut;}
    
    virtual TH1* GetNumerator() =0;
    virtual TH1* GetDenominator() =0;
    virtual TH1* GetResult() = 0;

    virtual void Write();
    
    TH1* GetRatio(Double_t normfactor = 1.0);
    void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
    void Rename(const Char_t * name, const Char_t * title); //renames and retitle the function and histograms
    
    void SetPairCut(AliHBTPairCut*);
    
    virtual AliHBTPair* CheckPair(AliHBTPair* pair);
    
  protected:
    
    AliHBTPairCut*      fPairCut;
    
  public:  
   ClassDef(AliHBTFunction,1)
};
/******************************************************************/
inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
{
  //check if pair and both particles meets the cut criteria
  if(fPairCut->Pass(pair)) //if the pair is BAD
   {//it is BAD 
    pair = pair->GetSwapedPair();
    if(fPairCut->Pass(pair)) //so try reverse combination
     { 
       return 0x0;//it is BAD as well - so return
     }
   }
  return pair; 
}

/******************************************************************/
/******************************************************************/
/******************************************************************/
class AliHBTTwoPartFctn: public AliHBTFunction
{
  public:
    AliHBTTwoPartFctn(){}
    virtual ~AliHBTTwoPartFctn(){}
    
    virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
    virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;


  protected:
  public:  
   ClassDef(AliHBTTwoPartFctn,1)
  
};
/******************************************************************/
/******************************************************************/
/******************************************************************/
class AliHBTFourPartFctn: public AliHBTFunction
{
  public:
    AliHBTFourPartFctn(){};
    virtual ~AliHBTFourPartFctn(){};
    
    virtual void 
    ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
    virtual void 
    ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;

	     
  protected:
  public:  
   ClassDef(AliHBTFourPartFctn,1)
  
};
/******************************************************************/
/******************************************************************/
/******************************************************************/


class AliHBTTwoPartFctn1D: public AliHBTTwoPartFctn
{
 public:
  AliHBTTwoPartFctn1D(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
  virtual ~AliHBTTwoPartFctn1D();
  
  
  TH1* GetNumerator(){return fNumerator;}
  TH1* GetDenominator(){return fDenominator;}

  void ProcessSameEventParticles(AliHBTPair* pair);
  void ProcessDiffEventParticles(AliHBTPair* pair);
  Double_t Scale();  
  void SetNumberOfBinsToScale();
 protected:
  //retruns velue to be histogrammed
  virtual Double_t GetValue(AliHBTPair* pair) = 0; 

  TH1D* fNumerator;
  TH1D* fDenominator;
  Int_t fNBinsToScale;
  
 public:
  ClassDef(AliHBTTwoPartFctn1D,2)
};

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

class AliHBTTwoPartFctn2D: public AliHBTTwoPartFctn
{
 public:
  AliHBTTwoPartFctn2D(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);
  ~AliHBTTwoPartFctn2D();
  
  TH1* GetNumerator(){return fNumerator;}
  TH1* GetDenominator(){return fDenominator;}
  
  void ProcessSameEventParticles(AliHBTPair* pair);
  void ProcessDiffEventParticles(AliHBTPair* pair);
 

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

  TH2D* fNumerator;
  TH2D* fDenominator;
  
 public:
  ClassDef(AliHBTTwoPartFctn2D,1)
};
/******************************************************************/
/******************************************************************/
/******************************************************************/

class AliHBTTwoPartFctn3D: public AliHBTTwoPartFctn
{
 public:
  AliHBTTwoPartFctn3D(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 ~AliHBTTwoPartFctn3D();

  TH1* GetNumerator(){return fNumerator;}
  TH1* GetDenominator(){return fDenominator;}

 protected:
  TH3D* fNumerator;
  TH3D* fDenominator;
 public:
  ClassDef(AliHBTTwoPartFctn3D,1)
};
/******************************************************************/
/******************************************************************/
/******************************************************************/


/******************************************************************/
/******************************************************************/
/******************************************************************/
class AliHBTFourPartFctn2D: public AliHBTFourPartFctn
{
 public:
  AliHBTFourPartFctn2D(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);
  ~AliHBTFourPartFctn2D();
  
  TH1* GetNumerator(){return fNumerator;}
  TH1* GetDenominator(){return fDenominator;}
  
  void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
  void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 
  
 protected:
  virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&) = 0;

  TH2D* fNumerator;
  TH2D* fDenominator;
  
 public:
  ClassDef(AliHBTFourPartFctn2D,1)
};


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

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


#endif
Commit	Line	Data
1b446896	1	//Piotr Skowronski@cern.ch
	2
	3	#ifndef ALIHBTFUNCTION_H
	4	#define ALIHBTFUNCTION_H
	5
	6	#include "AliHBTParticleCut.h"
	7	#include "AliHBTPairCut.h"
	8	#include "AliHBTPair.h"
	9
	10	#include <TH2.h>
	11	#include <TH3.h>
	12
	13
	14	class AliHBTAnalysis;
	15
	16	class AliHBTFunction: public TNamed
	17	//Abstract base class for HBT functions
	18	{
	19	public:
	20	AliHBTFunction();
976183fd	21	virtual ~AliHBTFunction(){delete fPairCut;}
1b446896	22
	23	virtual TH1* GetNumerator() =0;
	24	virtual TH1* GetDenominator() =0;
	25	virtual TH1* GetResult() = 0;
976183fd	26
1b446896	27	virtual void Write();
	28
	29	TH1* GetRatio(Double_t normfactor = 1.0);
	30	void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
	31	void Rename(const Char_t * name, const Char_t * title); //renames and retitle the function and histograms
	32
	33	void SetPairCut(AliHBTPairCut*);
	34
	35	virtual AliHBTPair* CheckPair(AliHBTPair* pair);
	36
	37	protected:
	38
	39	AliHBTPairCut* fPairCut;
	40
	41	public:
	42	ClassDef(AliHBTFunction,1)
	43	};
976183fd	44	/******************************************************************/
1b446896	45	inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
	46	{
	47	//check if pair and both particles meets the cut criteria
	48	if(fPairCut->Pass(pair)) //if the pair is BAD
	49	{//it is BAD
	50	pair = pair->GetSwapedPair();
	51	if(fPairCut->Pass(pair)) //so try reverse combination
	52	{
	53	return 0x0;//it is BAD as well - so return
	54	}
	55	}
	56	return pair;
	57	}
	58
1b446896	59	/******************************************************************/
	60	/******************************************************************/
	61	/******************************************************************/
	62	class AliHBTTwoPartFctn: public AliHBTFunction
	63	{
	64	public:
	65	AliHBTTwoPartFctn(){}
	66	virtual ~AliHBTTwoPartFctn(){}
	67
	68	virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
	69	virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
976183fd	70
976183fd	71
1b446896	72
	73	protected:
	74	public:
	75	ClassDef(AliHBTTwoPartFctn,1)
	76
	77	};
	78	/******************************************************************/
	79	/******************************************************************/
	80	/******************************************************************/
	81	class AliHBTFourPartFctn: public AliHBTFunction
	82	{
	83	public:
	84	AliHBTFourPartFctn(){};
	85	virtual ~AliHBTFourPartFctn(){};
	86
	87	virtual void
	88	ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
	89	virtual void
	90	ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
976183fd	91
1b446896	92
	93	protected:
	94	public:
	95	ClassDef(AliHBTFourPartFctn,1)
	96
	97	};
	98	/******************************************************************/
	99	/******************************************************************/
	100	/******************************************************************/
	101
	102
	103	class AliHBTTwoPartFctn1D: public AliHBTTwoPartFctn
	104	{
	105	public:
	106	AliHBTTwoPartFctn1D(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
	107	virtual ~AliHBTTwoPartFctn1D();
	108
	109
	110	TH1* GetNumerator(){return fNumerator;}
	111	TH1* GetDenominator(){return fDenominator;}
	112
	113	void ProcessSameEventParticles(AliHBTPair* pair);
	114	void ProcessDiffEventParticles(AliHBTPair* pair);
976183fd	115	Double_t Scale();
976183fd	116	void SetNumberOfBinsToScale();
1b446896	117	protected:
	118	//retruns velue to be histogrammed
	119	virtual Double_t GetValue(AliHBTPair* pair) = 0;
976183fd	120
1b446896	121	TH1D* fNumerator;
1b446896	122	TH1D* fDenominator;
976183fd	123	Int_t fNBinsToScale;
1b446896	124
1b446896	125	public:
976183fd	126	ClassDef(AliHBTTwoPartFctn1D,2)
1b446896	127	};
1b446896	128
1b446896	129	/******************************************************************/
	130	/******************************************************************/
	131	/******************************************************************/
	132
	133	class AliHBTTwoPartFctn2D: public AliHBTTwoPartFctn
	134	{
	135	public:
	136	AliHBTTwoPartFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	137	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
	138	~AliHBTTwoPartFctn2D();
	139
	140	TH1* GetNumerator(){return fNumerator;}
	141	TH1* GetDenominator(){return fDenominator;}
	142
	143	void ProcessSameEventParticles(AliHBTPair* pair);
	144	void ProcessDiffEventParticles(AliHBTPair* pair);
	145
976183fd	146
1b446896	147	protected:
976183fd	148	virtual void GetValues(AliHBTPair* pair, Double_t&, Double_t&) = 0;
976183fd	149
1b446896	150	TH2D* fNumerator;
	151	TH2D* fDenominator;
	152
	153	public:
	154	ClassDef(AliHBTTwoPartFctn2D,1)
	155	};
	156	/******************************************************************/
	157	/******************************************************************/
	158	/******************************************************************/
	159
	160	class AliHBTTwoPartFctn3D: public AliHBTTwoPartFctn
	161	{
	162	public:
	163	AliHBTTwoPartFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	164	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
	165	Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
	166
	167	virtual ~AliHBTTwoPartFctn3D();
	168
	169	TH1* GetNumerator(){return fNumerator;}
	170	TH1* GetDenominator(){return fDenominator;}
	171
	172	protected:
	173	TH3D* fNumerator;
	174	TH3D* fDenominator;
	175	public:
	176	ClassDef(AliHBTTwoPartFctn3D,1)
	177	};
	178	/******************************************************************/
	179	/******************************************************************/
	180	/******************************************************************/
	181
	182
	183
	184	/******************************************************************/
	185	/******************************************************************/
	186	/******************************************************************/
	187	class AliHBTFourPartFctn2D: public AliHBTFourPartFctn
	188	{
	189	public:
	190	AliHBTFourPartFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
	191	Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
	192	~AliHBTFourPartFctn2D();
	193
	194	TH1* GetNumerator(){return fNumerator;}
	195	TH1* GetDenominator(){return fDenominator;}
	196
	197	void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	198	void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
	199
1b446896	200
1b446896	201	protected:
976183fd	202	virtual void GetValues(AliHBTPair,AliHBTPair, Double_t&, Double_t&) = 0;
976183fd	203
1b446896	204	TH2D* fNumerator;
	205	TH2D* fDenominator;
	206
	207	public:
	208	ClassDef(AliHBTFourPartFctn2D,1)
	209	};
	210
	211
	212	/******************************************************************/
	213	/******************************************************************/
	214	/******************************************************************/
	215
	216	/******************************************************************/
	217	/******************************************************************/
	218	/******************************************************************/
	219
	220
	221
	222	#endif