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

#ifndef ALIHBTCORRECTCORRELFCTN_H
#define ALIHBTCORRECTCORRELFCTN_H
//____________________
///////////////////////////////////////////////////////
//                                                   //
// AliHBTCorrectQInvCorrelFctn                       //
//                                                   //
// Class for calculating Q Invariant correlation     //
// taking to the account resolution of the           //
// detector and coulomb effects.                     //
//                                                   //
///////////////////////////////////////////////////////

#include "AliHBTFunction.h"

  class AliHBTCorrectQInvCorrelFctn: public AliHBTOnePairFctn1D
{
  public:
    AliHBTCorrectQInvCorrelFctn(const char* name = "qinvcorrectedCF", 
                                const char* title= "Corrected Q_{inv} Correlation Fonction");

    AliHBTCorrectQInvCorrelFctn(const char* name, const char* title,
	            Int_t nbins, Float_t maxXval, Float_t minXval);

    AliHBTCorrectQInvCorrelFctn(TH1D* measqinv, 
                                const char* name = "qinvcorrectedCF", 
                                const char* title= "Corrected Q_{inv} Correlation Fonction");
    virtual ~AliHBTCorrectQInvCorrelFctn();
    void SetInitialValues(Double_t lambda, Double_t r);
    void Init();
    void ProcessSameEventParticles(AliHBTPair* pair);//process particles from same event (real pair)
    void ProcessDiffEventParticles(AliHBTPair* pair);//process particles coming from different events (mixed pairs)
    void SetMeasuredHistogram(TH1D* meas){fMeasCorrelFctn = meas;}
    TH1* GetResult();//returns the result histogram
    Double_t GetRadius()const{ return TMath::Sqrt(fR2);}//returns assumed radius
    Double_t GetLambda()const{ return fLambda;}//retutrns assumed intercept parameter
    void     SetRadiusConvergenceTreshold(Double_t ct){fRConvergenceTreshold=ct;}//if fitted and assumed R us different less then that number con
    void     SetLambdaConvergenceTreshold(Double_t ct){fLambdaConvergenceTreshold=ct;}
    Bool_t   IsConverged();
    void     Fit();
    Double_t GetFittedRadius();
    Double_t GetFittedLambda();
    void     WriteAll();
    void     SetMeasNum(TH1D* measnum){fMeasNumer = measnum;}
    void     SetMeasDen(TH1D* h){fMeasDenom = h;}
    void     MakeMeasCF();
  protected:
    virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
    Double_t GetCoulombCorrection(AliHBTPair* pair){return 1.0;}
    Double_t GetValue(AliHBTPair * pair){return pair->GetQInv();}
    void Smear(AliHBTPair* pair,AliHBTPair& smeared);
    void Smear(AliHBTParticle* part, AliHBTParticle* smeared);
    Double_t GetModelValue(Double_t qinv);

    //Our ideal numerator 
    TH1D* fMeasCorrelFctn;
    TH1D* fMeasNumer;
    TH1D* fMeasDenom;  
    
    TH1D* fSmearedNumer; //! Numerator of smeard q
    TH1D* fSmearedDenom; //! Denominator of smeard q
    
    //Parameters of Pt RMS
    //linear dependence dPt/Pt from Pt itself 
    Float_t fDPtOverPtRMS; //RMS of dPt/Pt 
    
    //We assume that RMS of Theta and Phisangle depends on Pt Like A+B*(Pt)^Alpha
    //Idea copied from Star HBT Maker (Fabrice Retiere)
    //Parameters comes from Monte Carlo Resolution Analysis

    Float_t fThetaA; //"A" parameter of theta RMS dependence
    Float_t fThetaB; //"B" parameter of theta RMS dependence
    Float_t fThetaAlpha; //"Alpha" parameter (power) of theta RMS dependence

    Float_t fPhiA;//"A" parameter of phi RMS dependence
    Float_t fPhiB;//"B" parameter of phi RMS dependence
    Float_t fPhiAlpha;//"Alpha" parameter (power) of phi RMS dependence
    
    Double_t fR2;//square of radius
    Double_t fLambda;//Interception parameter

    Double_t fFittedR;//fitted radius
    Double_t fFittedLambda;//fitted Interception parameter
        
    Float_t  fRConvergenceTreshold;
    Float_t  fLambdaConvergenceTreshold;
  private:
  public:
    ClassDef(AliHBTCorrectQInvCorrelFctn,1)
};

inline
Double_t AliHBTCorrectQInvCorrelFctn::GetModelValue(Double_t qinv)
{
  //factor 0.038936366329 conected with units change GeV<->SI
  return 1.0 + fLambda*TMath::Exp(-fR2*qinv*qinv/0.038936366329);
}

//____________________
///////////////////////////////////////////////////////
//                                                   //
// AliHBTCorrectQ3DCorrelFctn                        //
//                                                   //
// Class for calculating Q Invariant correlation     //
// taking to the account resolution of the           //
// detector and coulomb effects.                     //
//                                                   //
///////////////////////////////////////////////////////

class AliHBTCorrectQ3DCorrelFctn: public AliHBTOnePairFctn3D
{
  public:
   AliHBTCorrectQ3DCorrelFctn(const char* name = "qinvcorrectedCF", 
                               const char* title= "Corrected Q_{inv} Correlation Fonction");
   virtual ~AliHBTCorrectQ3DCorrelFctn();
   
  protected:
    TH3D* fMeasCorrelFctn;
    
    TH3D* fSmearedNumer; //! Numerator of smeard q
    TH3D* fSmearedDenom; //! Denominator of smeard q
    TH3D* fMeasNumer;  //! Numerator of ideal q calculated on basis of model equation
    TH3D* fMeasDenom;  //! Denominator of ideal q calculated on basis of model equation

    
  private:
  
  public:
    ClassDef(AliHBTCorrectQ3DCorrelFctn,1)
};

#endif
Commit	Line	Data
83b33650	1	#ifndef ALIHBTCORRECTCORRELFCTN_H
	2	#define ALIHBTCORRECTCORRELFCTN_H
	3	//____________________
	4	///////////////////////////////////////////////////////
	5	// //
	6	// AliHBTCorrectQInvCorrelFctn //
	7	// //
	8	// Class for calculating Q Invariant correlation //
	9	// taking to the account resolution of the //
	10	// detector and coulomb effects. //
	11	// //
	12	///////////////////////////////////////////////////////
	13
	14	#include "AliHBTFunction.h"
	15
	16	class AliHBTCorrectQInvCorrelFctn: public AliHBTOnePairFctn1D
	17	{
	18	public:
	19	AliHBTCorrectQInvCorrelFctn(const char* name = "qinvcorrectedCF",
	20	const char* title= "Corrected Q_{inv} Correlation Fonction");
	21
	22	AliHBTCorrectQInvCorrelFctn(const char* name, const char* title,
	23	Int_t nbins, Float_t maxXval, Float_t minXval);
	24
	25	AliHBTCorrectQInvCorrelFctn(TH1D* measqinv,
	26	const char* name = "qinvcorrectedCF",
	27	const char* title= "Corrected Q_{inv} Correlation Fonction");
	28	virtual ~AliHBTCorrectQInvCorrelFctn();
	29	void SetInitialValues(Double_t lambda, Double_t r);
	30	void Init();
	31	void ProcessSameEventParticles(AliHBTPair* pair);//process particles from same event (real pair)
	32	void ProcessDiffEventParticles(AliHBTPair* pair);//process particles coming from different events (mixed pairs)
	33	void SetMeasuredHistogram(TH1D* meas){fMeasCorrelFctn = meas;}
	34	TH1* GetResult();//returns the result histogram
	35	Double_t GetRadius()const{ return TMath::Sqrt(fR2);}//returns assumed radius
	36	Double_t GetLambda()const{ return fLambda;}//retutrns assumed intercept parameter
	37	void SetRadiusConvergenceTreshold(Double_t ct){fRConvergenceTreshold=ct;}//if fitted and assumed R us different less then that number con
	38	void SetLambdaConvergenceTreshold(Double_t ct){fLambdaConvergenceTreshold=ct;}
	39	Bool_t IsConverged();
	40	void Fit();
	41	Double_t GetFittedRadius();
	42	Double_t GetFittedLambda();
	43	void WriteAll();
	44	void SetMeasNum(TH1D* measnum){fMeasNumer = measnum;}
	45	void SetMeasDen(TH1D* h){fMeasDenom = h;}
	46	void MakeMeasCF();
	47	protected:
	48	virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
	49	Double_t GetCoulombCorrection(AliHBTPair* pair){return 1.0;}
	50	Double_t GetValue(AliHBTPair * pair){return pair->GetQInv();}
	51	void Smear(AliHBTPair* pair,AliHBTPair& smeared);
	52	void Smear(AliHBTParticle* part, AliHBTParticle* smeared);
	53	Double_t GetModelValue(Double_t qinv);
	54
	55	//Our ideal numerator
	56	TH1D* fMeasCorrelFctn;
	57	TH1D* fMeasNumer;
	58	TH1D* fMeasDenom;
	59
	60	TH1D* fSmearedNumer; //! Numerator of smeard q
	61	TH1D* fSmearedDenom; //! Denominator of smeard q
	62
	63	//Parameters of Pt RMS
	64	//linear dependence dPt/Pt from Pt itself
65	Float_t fDPtOverPtRMS; //RMS of dPt/Pt
66
67	//We assume that RMS of Theta and Phisangle depends on Pt Like A+B*(Pt)^Alpha
68	//Idea copied from Star HBT Maker (Fabrice Retiere)
69	//Parameters comes from Monte Carlo Resolution Analysis
70
71	Float_t fThetaA; //"A" parameter of theta RMS dependence
72	Float_t fThetaB; //"B" parameter of theta RMS dependence
73	Float_t fThetaAlpha; //"Alpha" parameter (power) of theta RMS dependence
74
75	Float_t fPhiA;//"A" parameter of phi RMS dependence
76	Float_t fPhiB;//"B" parameter of phi RMS dependence
77	Float_t fPhiAlpha;//"Alpha" parameter (power) of phi RMS dependence
78
79	Double_t fR2;//square of radius
80	Double_t fLambda;//Interception parameter
81
82	Double_t fFittedR;//fitted radius
83	Double_t fFittedLambda;//fitted Interception parameter
84
85	Float_t fRConvergenceTreshold;
86	Float_t fLambdaConvergenceTreshold;
87	private:
88	public:
89	ClassDef(AliHBTCorrectQInvCorrelFctn,1)
90	};
91
92	inline
93	Double_t AliHBTCorrectQInvCorrelFctn::GetModelValue(Double_t qinv)
94	{
95	//factor 0.038936366329 conected with units change GeV<->SI
96	return 1.0 + fLambdaTMath::Exp(-fR2qinv*qinv/0.038936366329);
97	}
98
99	//____________________
100	///////////////////////////////////////////////////////
101	// //
102	// AliHBTCorrectQ3DCorrelFctn //
103	// //
104	// Class for calculating Q Invariant correlation //
105	// taking to the account resolution of the //
106	// detector and coulomb effects. //
107	// //
108	///////////////////////////////////////////////////////
109
110	class AliHBTCorrectQ3DCorrelFctn: public AliHBTOnePairFctn3D
111	{
112	public:
113	AliHBTCorrectQ3DCorrelFctn(const char* name = "qinvcorrectedCF",
114	const char* title= "Corrected Q_{inv} Correlation Fonction");
115	virtual ~AliHBTCorrectQ3DCorrelFctn();
116
117	protected:
118	TH3D* fMeasCorrelFctn;
119
120	TH3D* fSmearedNumer; //! Numerator of smeard q
121	TH3D* fSmearedDenom; //! Denominator of smeard q
122	TH3D* fMeasNumer; //! Numerator of ideal q calculated on basis of model equation
123	TH3D* fMeasDenom; //! Denominator of ideal q calculated on basis of model equation
124
125
126	private:
127
128	public:
129	ClassDef(AliHBTCorrectQ3DCorrelFctn,1)
130	};
131
132	#endif