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

#include "AliHBTLLWeightFctn.h"
/* $Id$ */
//_________________________________________________________________________
//
// class 
//
//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 "AliHBTLLWeightsPID.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
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqinvcf","Q_{inv} Weight Correlation Function");
}
/****************************************************************/
void  AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    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)
    
AliHBTLLWeightQOutFctn::AliHBTLLWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
{
//ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqoutcf","Q_{out} Weight Correlation Function");
}
/****************************************************************/
void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)  
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  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)
AliHBTLLWeightQLongFctn::AliHBTLLWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
{
//ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqlongcf","Q_{long} Weight Correlation Function");
}
/****************************************************************/
void AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  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)
/*************************************************************************************/ 

AliHBTLLWeightQSideFctn::AliHBTLLWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
{
//ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqsidecf","Q_{side} Weight Correlation Function");
}
/****************************************************************/
void AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
  }
} 
/****************************************************************/

void  AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  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)
/*************************************************************************************/ 
AliHBTLLWeightTwoKStarFctn::AliHBTLLWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
{
//ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wtwokstarcf","2*K^{*} Weight Correlation Function");
}
/****************************************************************/
void AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
  }
} 
/****************************************************************/

void  AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  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());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTLLWeightQOutQSideFctn)
/*************************************************************************************/ 
    
AliHBTLLWeightQOutQSideFctn::AliHBTLLWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
                                                         Int_t nybins, Double_t maxYval, Double_t minYval):
 AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
{
  //ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
}    
/*************************************************************************************/ 
void AliHBTLLWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) 
      fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTLLWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
  }
}
/**************************************************************/
TH1* AliHBTLLWeightQOutQSideFctn::GetResult()
{
  //returns result
  return GetRatio(Scale());
}

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

ClassImp(AliHBTLLWeightQOutQLongFctn)
/*************************************************************************************/ 
    
AliHBTLLWeightQOutQLongFctn::AliHBTLLWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
                                                         Int_t nybins, Double_t maxYval, Double_t minYval):
 AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
{
  //ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
}    
/*************************************************************************************/ 
void AliHBTLLWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) 
      fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTLLWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
  }
}
/**************************************************************/

TH1* AliHBTLLWeightQOutQLongFctn::GetResult()
{
  //returns result
  return GetRatio(Scale());
}

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

ClassImp(AliHBTLLWeightQSideQLongFctn)
/*************************************************************************************/ 
    
AliHBTLLWeightQSideQLongFctn::AliHBTLLWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
                                                         Int_t nybins, Double_t maxYval, Double_t minYval):
 AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
{
  //ctor
 fWriteNumAndDen = kTRUE;//change default behaviour
 Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
}    
/*************************************************************************************/ 
void AliHBTLLWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from same events (fills numerator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)     
  {
    Double_t weightPID=1.;
    Double_t weightHBT=partpair->GetLLWeight();
    Double_t weight=weightHBT*weightPID;
    if(TMath::Abs(weight)<=10.) 
      fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTLLWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
{
  //process particles from diff events (fills denominator)
  trackpair = CheckPair(trackpair);
  partpair  = CheckPair(partpair);
  if ( trackpair && partpair)  
  {
     fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
  }
}
/**************************************************************/
TH1* AliHBTLLWeightQSideQLongFctn::GetResult()
{
  //returns result
  return GetRatio(Scale());
}
Commit	Line	Data
9714a029	1	#include "AliHBTLLWeightFctn.h"
4fdf4eb3	2	/* $Id$ */
9714a029	3	//_________________________________________________________________________
	4	//
	5	// class
	6	//
4fdf4eb3	7	//This class allows to obtain Q_inv correlation function with weights
	8	//calculated by Lednicky's alghorithm.
	9	//Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
	10	//Weights are calculated with corresponding simulated particles momenta.
	11	//Denominator is filled with mixing unweighted reconstructed tracks.
	12	//One needs both pairs
	13	//(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
3506b383	14	//Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
88cb7938	15	#include "AliHBTLLWeightsPID.h"
7f92929e	16
	17	//--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
	18
88cb7938	19	ClassImp( AliHBTLLWeightQInvFctn )
	20
	21
7f92929e	22	/****************************************************************/
7f92929e	23	AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
9714a029	24	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
7f92929e	25	{
2f8eea63	26	//ctor
9714a029	27	fWriteNumAndDen = kTRUE;//change default behaviour
9714a029	28	Rename("wqinvcf","Q_{inv} Weight Correlation Function");
7f92929e	29	}
	30	/****************************************************************/
	31	void AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	32	{
9714a029	33	//process particles from same events (fills numerator)
7f92929e	34	trackpair = CheckPair(trackpair);
	35	partpair = CheckPair(partpair);
	36	if ( trackpair && partpair)
	37	{
2f8eea63	38	Double_t weightPID=1.;
47d9a058	39	Double_t weightHBT=partpair->GetLLWeight();
2f8eea63	40	Double_t weight=weightHBT*weightPID;
b3fb9814	41	if(TMath::Abs(weight)<=10.)fNumerator->Fill(trackpair->GetQInv(),weight);
7f92929e	42	}
7f92929e	43	}
7f92929e	44	/****************************************************************/
2f8eea63	45
2f8eea63	46	void AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
7f92929e	47	{
4fdf4eb3	48	// Fills the denominator using mixed pairs
7f92929e	49	trackpair = CheckPair(trackpair);
	50	partpair = CheckPair(partpair);
	51	if ( trackpair && partpair)
	52	{
	53	fDenominator->Fill(trackpair->GetQInv());
	54	}
	55	}
	56	/**************************************************************/
9714a029	57	TH1* AliHBTLLWeightQInvFctn::GetResult()
7f92929e	58	{
7f92929e	59	//returns ratio of numerator and denominator
af8cf344	60	return GetRatio(Scale());
7f92929e	61	}
7f92929e	62
b3fb9814	63	/**************************************************************************************/
	64	/**************************************************************************************/
	65	/**************************************************************************************/
	66	/**************************************************************************************/
	67
	68	ClassImp(AliHBTLLWeightQOutFctn)
9714a029	69
	70	AliHBTLLWeightQOutFctn::AliHBTLLWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
	71	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	72	{
	73	//ctor
	74	fWriteNumAndDen = kTRUE;//change default behaviour
	75	Rename("wqoutcf","Q_{out} Weight Correlation Function");
	76	}
b3fb9814	77	/****************************************************************/
	78	void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	79	{
9714a029	80	//process particles from same events (fills numerator)
b3fb9814	81	trackpair = CheckPair(trackpair);
	82	partpair = CheckPair(partpair);
	83	if ( trackpair && partpair)
	84	{
	85	Double_t weightPID=1.;
47d9a058	86	Double_t weightHBT=partpair->GetLLWeight();
b3fb9814	87	Double_t weight=weightHBT*weightPID;
	88	if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
	89	}
	90	}
	91	/****************************************************************/
	92
	93	void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	94	{
9714a029	95	//process particles from diff events (fills denominator)
b3fb9814	96	trackpair = CheckPair(trackpair);
	97	partpair = CheckPair(partpair);
	98	if ( trackpair && partpair)
	99	{
	100	fDenominator->Fill(trackpair->GetQOutCMSLC());
	101	}
	102	}
	103	/**************************************************************/
	104	TH1* AliHBTLLWeightQOutFctn::GetResult()
	105
	106	{
	107	//returns ratio of numerator and denominator
	108	return GetRatio(Scale());
	109	}
	110
	111	/*************************************************************************************/
	112	/*************************************************************************************/
	113	/*************************************************************************************/
	114
	115	ClassImp(AliHBTLLWeightQLongFctn)
9714a029	116	AliHBTLLWeightQLongFctn::AliHBTLLWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
	117	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	118	{
	119	//ctor
	120	fWriteNumAndDen = kTRUE;//change default behaviour
	121	Rename("wqlongcf","Q_{long} Weight Correlation Function");
	122	}
b3fb9814	123	/****************************************************************/
9714a029	124	void AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	125	{
9714a029	126	//process particles from same events (fills numerator)
b3fb9814	127	trackpair = CheckPair(trackpair);
	128	partpair = CheckPair(partpair);
	129	if ( trackpair && partpair)
	130	{
	131	Double_t weightPID=1.;
47d9a058	132	Double_t weightHBT=partpair->GetLLWeight();
b3fb9814	133	Double_t weight=weightHBT*weightPID;
	134	if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
	135	}
	136	}
	137	/****************************************************************/
	138
9714a029	139	void AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	140	{
9714a029	141	//process particles from diff events (fills denominator)
b3fb9814	142	trackpair = CheckPair(trackpair);
	143	partpair = CheckPair(partpair);
	144	if ( trackpair && partpair)
	145	{
	146	fDenominator->Fill(trackpair->GetQLongCMSLC());
	147	}
	148	}
	149	/**************************************************************/
	150	TH1* AliHBTLLWeightQLongFctn::GetResult()
	151
	152	{
	153	//returns ratio of numerator and denominator
	154	return GetRatio(Scale());
	155	}
	156
	157	/*************************************************************************************/
	158	/*************************************************************************************/
	159	/*************************************************************************************/
	160
	161	ClassImp(AliHBTLLWeightQSideFctn)
9714a029	162	/*************************************************************************************/
	163
	164	AliHBTLLWeightQSideFctn::AliHBTLLWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
	165	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	166	{
	167	//ctor
	168	fWriteNumAndDen = kTRUE;//change default behaviour
	169	Rename("wqsidecf","Q_{side} Weight Correlation Function");
	170	}
b3fb9814	171	/****************************************************************/
9714a029	172	void AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	173	{
9714a029	174	//process particles from same events (fills numerator)
b3fb9814	175	trackpair = CheckPair(trackpair);
	176	partpair = CheckPair(partpair);
	177	if ( trackpair && partpair)
	178	{
	179	Double_t weightPID=1.;
47d9a058	180	Double_t weightHBT=partpair->GetLLWeight();
b3fb9814	181	Double_t weight=weightHBT*weightPID;
	182	if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
	183	}
	184	}
	185	/****************************************************************/
	186
	187	void AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	188	{
9714a029	189	//process particles from diff events (fills denominator)
b3fb9814	190	trackpair = CheckPair(trackpair);
	191	partpair = CheckPair(partpair);
	192	if ( trackpair && partpair)
	193	{
	194	fDenominator->Fill(trackpair->GetQSideCMSLC());
	195	}
	196	}
	197	/**************************************************************/
	198	TH1* AliHBTLLWeightQSideFctn::GetResult()
	199
	200	{
	201	//returns ratio of numerator and denominator
	202	return GetRatio(Scale());
	203	}
	204
9714a029	205	/*************************************************************************************/
b3fb9814	206	/*************************************************************************************/
	207	/*************************************************************************************/
	208
	209	ClassImp(AliHBTLLWeightTwoKStarFctn)
9714a029	210	/*************************************************************************************/
	211	AliHBTLLWeightTwoKStarFctn::AliHBTLLWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
	212	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	213	{
	214	//ctor
	215	fWriteNumAndDen = kTRUE;//change default behaviour
	216	Rename("wtwokstarcf","2K^{} Weight Correlation Function");
	217	}
b3fb9814	218	/****************************************************************/
9714a029	219	void AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	220	{
9714a029	221	//process particles from same events (fills numerator)
b3fb9814	222	trackpair = CheckPair(trackpair);
	223	partpair = CheckPair(partpair);
	224	if ( trackpair && partpair)
	225	{
	226	Double_t weightPID=1.;
47d9a058	227	Double_t weightHBT=partpair->GetLLWeight();
b3fb9814	228	Double_t weight=weightHBT*weightPID;
	229	if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
	230	}
	231	}
	232	/****************************************************************/
	233
	234	void AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	235	{
9714a029	236	//process particles from diff events (fills denominator)
b3fb9814	237	trackpair = CheckPair(trackpair);
	238	partpair = CheckPair(partpair);
	239	if ( trackpair && partpair)
	240	{
	241	fDenominator->Fill(2.0*(trackpair->GetKStar()));
	242	}
	243	}
	244	/**************************************************************/
	245	TH1* AliHBTLLWeightTwoKStarFctn::GetResult()
	246
	247	{
	248	//returns ratio of numerator and denominator
	249	return GetRatio(Scale());
	250	}
	251
9714a029	252	/*************************************************************************************/
	253	/*************************************************************************************/
	254	/*************************************************************************************/
	255
	256	ClassImp(AliHBTLLWeightQOutQSideFctn)
	257	/*************************************************************************************/
	258
	259	AliHBTLLWeightQOutQSideFctn::AliHBTLLWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
	260	Int_t nybins, Double_t maxYval, Double_t minYval):
	261	AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
	262	{
	263	//ctor
	264	fWriteNumAndDen = kTRUE;//change default behaviour
	265	Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
	266	}
	267	/*************************************************************************************/
	268	void AliHBTLLWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	269	{
	270	//process particles from same events (fills numerator)
	271	trackpair = CheckPair(trackpair);
	272	partpair = CheckPair(partpair);
	273	if ( trackpair && partpair)
	274	{
	275	Double_t weightPID=1.;
47d9a058	276	Double_t weightHBT=partpair->GetLLWeight();
9714a029	277	Double_t weight=weightHBT*weightPID;
	278	if(TMath::Abs(weight)<=10.)
	279	fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
	280	}
	281	}
	282	/****************************************************************/
	283
	284	void AliHBTLLWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	285	{
	286	//process particles from diff events (fills denominator)
	287	trackpair = CheckPair(trackpair);
	288	partpair = CheckPair(partpair);
	289	if ( trackpair && partpair)
	290	{
	291	fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
	292	}
	293	}
	294	/**************************************************************/
	295	TH1* AliHBTLLWeightQOutQSideFctn::GetResult()
	296	{
	297	//returns result
	298	return GetRatio(Scale());
	299	}
	300
	301	/*************************************************************************************/
	302	/*************************************************************************************/
	303	/*************************************************************************************/
	304
	305	ClassImp(AliHBTLLWeightQOutQLongFctn)
	306	/*************************************************************************************/
	307
	308	AliHBTLLWeightQOutQLongFctn::AliHBTLLWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
	309	Int_t nybins, Double_t maxYval, Double_t minYval):
	310	AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
	311	{
	312	//ctor
	313	fWriteNumAndDen = kTRUE;//change default behaviour
	314	Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
	315	}
	316	/*************************************************************************************/
	317	void AliHBTLLWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	318	{
	319	//process particles from same events (fills numerator)
	320	trackpair = CheckPair(trackpair);
	321	partpair = CheckPair(partpair);
	322	if ( trackpair && partpair)
	323	{
	324	Double_t weightPID=1.;
47d9a058	325	Double_t weightHBT=partpair->GetLLWeight();
9714a029	326	Double_t weight=weightHBT*weightPID;
	327	if(TMath::Abs(weight)<=10.)
	328	fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
	329	}
	330	}
	331	/****************************************************************/
	332
	333	void AliHBTLLWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	334	{
	335	//process particles from diff events (fills denominator)
	336	trackpair = CheckPair(trackpair);
	337	partpair = CheckPair(partpair);
	338	if ( trackpair && partpair)
	339	{
	340	fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
	341	}
	342	}
	343	/**************************************************************/
	344
	345	TH1* AliHBTLLWeightQOutQLongFctn::GetResult()
	346	{
	347	//returns result
	348	return GetRatio(Scale());
	349	}
	350
	351	/*************************************************************************************/
	352	/*************************************************************************************/
b3fb9814	353	/*************************************************************************************/
b3fb9814	354
9714a029	355	ClassImp(AliHBTLLWeightQSideQLongFctn)
	356	/*************************************************************************************/
	357
	358	AliHBTLLWeightQSideQLongFctn::AliHBTLLWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
	359	Int_t nybins, Double_t maxYval, Double_t minYval):
	360	AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
	361	{
	362	//ctor
	363	fWriteNumAndDen = kTRUE;//change default behaviour
	364	Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
	365	}
	366	/*************************************************************************************/
	367	void AliHBTLLWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	368	{
	369	//process particles from same events (fills numerator)
	370	trackpair = CheckPair(trackpair);
	371	partpair = CheckPair(partpair);
	372	if ( trackpair && partpair)
	373	{
	374	Double_t weightPID=1.;
47d9a058	375	Double_t weightHBT=partpair->GetLLWeight();
9714a029	376	Double_t weight=weightHBT*weightPID;
	377	if(TMath::Abs(weight)<=10.)
	378	fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
	379	}
	380	}
	381	/****************************************************************/
	382
	383	void AliHBTLLWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
	384	{
	385	//process particles from diff events (fills denominator)
	386	trackpair = CheckPair(trackpair);
	387	partpair = CheckPair(partpair);
	388	if ( trackpair && partpair)
	389	{
	390	fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
	391	}
	392	}
	393	/**************************************************************/
	394	TH1* AliHBTLLWeightQSideQLongFctn::GetResult()
	395	{
	396	//returns result
	397	return GetRatio(Scale());
	398	}