[u/mrichter/AliRoot.git] / HBTAN / AliHBTLLWeightFctn.cxx

/* $Id$ */

//This class allows to obtain Q_inv correlation function with weights
//calculated by Lednicky's alghorithm.
//Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
//Weights are calculated with corresponding simulated particles momenta.
//Denominator is filled with mixing unweighted reconstructed tracks.
//One needs both pairs 
//(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
//Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
#include "AliHBTLLWeightFctn.h"
#include "AliHBTLLWeights.h"

//--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();

ClassImp( AliHBTLLWeightQInvFctn )  
/****************************************************************/
AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
           AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
{
//ctor
}
/****************************************************************/
void  AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
//Processes Particles and tracks Same different even
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.)fNumerator->Fill(trackpair->GetQInv(),weight);
  }
} 
/****************************************************************/

void  AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  // Fills the denominator using mixed pairs
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQInv());
  }
}
/**************************************************************/
TH1* AliHBTLLWeightQInvFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/**************************************************************************************/
/**************************************************************************************/
/**************************************************************************************/
/**************************************************************************************/

ClassImp(AliHBTLLWeightQOutFctn)
/****************************************************************/
void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQOutCMSLC());
  }
}
/**************************************************************/
TH1* AliHBTLLWeightQOutFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTLLWeightQLongFctn)
/****************************************************************/
void  AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
//Processes Particles and tracks Same different even
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void  AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQLongCMSLC());
  }
}
/**************************************************************/
TH1* AliHBTLLWeightQLongFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTLLWeightQSideFctn)
/****************************************************************/
void  AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
//Processes Particles and tracks Same different even
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
  }
} 
/****************************************************************/

void  AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQSideCMSLC());
  }
}
/**************************************************************/
TH1* AliHBTLLWeightQSideFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTLLWeightTwoKStarFctn)
/****************************************************************/
void  AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
//Processes Particles and tracks Same different even
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
  }
} 
/****************************************************************/

void  AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(2.0*(trackpair->GetKStar()));
  }
}
/**************************************************************/
TH1* AliHBTLLWeightTwoKStarFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/
Commit	Line	Data
4fdf4eb3	1	/* $Id$ */
	2
	3	//This class allows to obtain Q_inv correlation function with weights
	4	//calculated by Lednicky's alghorithm.
	5	//Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
	6	//Weights are calculated with corresponding simulated particles momenta.
	7	//Denominator is filled with mixing unweighted reconstructed tracks.
	8	//One needs both pairs
	9	//(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
3506b383	10	//Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
7f92929e	11	#include "AliHBTLLWeightFctn.h"
	12	#include "AliHBTLLWeights.h"
	13
	14	//--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
	15
	16	ClassImp( AliHBTLLWeightQInvFctn )
	17	/****************************************************************/
	18	AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
	19	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	20	{
2f8eea63	21	//ctor
7f92929e	22	}
	23	/****************************************************************/
	24	void AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	25	{
2f8eea63	26	//Processes Particles and tracks Same different even
7f92929e	27	trackpair = CheckPair(trackpair);
	28	partpair = CheckPair(partpair);
	29	if ( trackpair && partpair)
	30	{
2f8eea63	31	Double_t weightPID=1.;
	32	Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
	33	Double_t weight=weightHBT*weightPID;
b3fb9814	34	if(TMath::Abs(weight)<=10.)fNumerator->Fill(trackpair->GetQInv(),weight);
7f92929e	35	}
7f92929e	36	}
7f92929e	37	/****************************************************************/
2f8eea63	38
2f8eea63	39	void AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
7f92929e	40	{
4fdf4eb3	41	// Fills the denominator using mixed pairs
7f92929e	42	trackpair = CheckPair(trackpair);
	43	partpair = CheckPair(partpair);
	44	if ( trackpair && partpair)
	45	{
	46	fDenominator->Fill(trackpair->GetQInv());
	47	}
	48	}
	49	/**************************************************************/
	50	TH1* AliHBTLLWeightQInvFctn::GetResult()
	51
	52	{
	53	//returns ratio of numerator and denominator
af8cf344	54	return GetRatio(Scale());
7f92929e	55	}
7f92929e	56
b3fb9814	57	/**************************************************************************************/
	58	/**************************************************************************************/
	59	/**************************************************************************************/
	60	/**************************************************************************************/
	61
	62	ClassImp(AliHBTLLWeightQOutFctn)
	63	/****************************************************************/
	64	void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	65	{
	66	trackpair = CheckPair(trackpair);
	67	partpair = CheckPair(partpair);
	68	if ( trackpair && partpair)
	69	{
	70	Double_t weightPID=1.;
	71	Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
	72	Double_t weight=weightHBT*weightPID;
	73	if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
	74	}
	75	}
	76	/****************************************************************/
	77
	78	void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	79	{
	80	trackpair = CheckPair(trackpair);
	81	partpair = CheckPair(partpair);
	82	if ( trackpair && partpair)
	83	{
	84	fDenominator->Fill(trackpair->GetQOutCMSLC());
	85	}
	86	}
	87	/**************************************************************/
	88	TH1* AliHBTLLWeightQOutFctn::GetResult()
	89
	90	{
	91	//returns ratio of numerator and denominator
	92	return GetRatio(Scale());
	93	}
	94
	95	/*************************************************************************************/
	96	/*************************************************************************************/
	97	/*************************************************************************************/
	98
	99	ClassImp(AliHBTLLWeightQLongFctn)
	100	/****************************************************************/
	101	void AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	102	{
	103	//Processes Particles and tracks Same different even
	104	trackpair = CheckPair(trackpair);
	105	partpair = CheckPair(partpair);
	106	if ( trackpair && partpair)
	107	{
	108	Double_t weightPID=1.;
	109	Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
	110	Double_t weight=weightHBT*weightPID;
	111	if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
	112	}
	113	}
	114	/****************************************************************/
	115
	116	void AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	117	{
	118	trackpair = CheckPair(trackpair);
	119	partpair = CheckPair(partpair);
	120	if ( trackpair && partpair)
121	{
122	fDenominator->Fill(trackpair->GetQLongCMSLC());
123	}
124	}
125	/**************************************************************/
126	TH1* AliHBTLLWeightQLongFctn::GetResult()
127
128	{
129	//returns ratio of numerator and denominator
130	return GetRatio(Scale());
131	}
132
133	/*************************************************************************************/
134	/*************************************************************************************/
135	/*************************************************************************************/
136
137	ClassImp(AliHBTLLWeightQSideFctn)
138	/****************************************************************/
139	void AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
140	{
141	//Processes Particles and tracks Same different even
142	trackpair = CheckPair(trackpair);
143	partpair = CheckPair(partpair);
144	if ( trackpair && partpair)
145	{
146	Double_t weightPID=1.;
147	Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
148	Double_t weight=weightHBT*weightPID;
149	if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
150	}
151	}
152	/****************************************************************/
153
154	void AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
155	{
156	trackpair = CheckPair(trackpair);
157	partpair = CheckPair(partpair);
158	if ( trackpair && partpair)
159	{
160	fDenominator->Fill(trackpair->GetQSideCMSLC());
161	}
162	}
163	/**************************************************************/
164	TH1* AliHBTLLWeightQSideFctn::GetResult()
165
166	{
167	//returns ratio of numerator and denominator
168	return GetRatio(Scale());
169	}
170
171	/*************************************************************************************/
172	/*************************************************************************************/
173
174	ClassImp(AliHBTLLWeightTwoKStarFctn)
175	/****************************************************************/
176	void AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
177	{
178	//Processes Particles and tracks Same different even
179	trackpair = CheckPair(trackpair);
180	partpair = CheckPair(partpair);
181	if ( trackpair && partpair)
182	{
183	Double_t weightPID=1.;
184	Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
185	Double_t weight=weightHBT*weightPID;
186	if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
187	}
188	}
189	/****************************************************************/
190
191	void AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
192	{
193	trackpair = CheckPair(trackpair);
194	partpair = CheckPair(partpair);
195	if ( trackpair && partpair)
196	{
197	fDenominator->Fill(2.0*(trackpair->GetKStar()));
198	}
199	}
200	/**************************************************************/
201	TH1* AliHBTLLWeightTwoKStarFctn::GetResult()
202
203	{
204	//returns ratio of numerator and denominator
205	return GetRatio(Scale());
206	}
207
208	/*************************************************************************************/
209