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

#include "AliHBTWeightFctn.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 "AliHBTWeightsPID.h"

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

ClassImp( AliHBTWeightQInvFctn )

  
/****************************************************************/
AliHBTWeightQInvFctn::AliHBTWeightQInvFctn(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  AliHBTWeightQInvFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQInv(),weight);
  }
} 
/****************************************************************/

void  AliHBTWeightQInvFctn::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* AliHBTWeightQInvFctn::GetResult()
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/**************************************************************************************/
/**************************************************************************************/
/**************************************************************************************/
/**************************************************************************************/

ClassImp(AliHBTWeightQOutFctn)
    
AliHBTWeightQOutFctn::AliHBTWeightQOutFctn(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 AliHBTWeightQOutFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTWeightQOutFctn::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* AliHBTWeightQOutFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTWeightQLongFctn)
AliHBTWeightQLongFctn::AliHBTWeightQLongFctn(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 AliHBTWeightQLongFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTWeightQLongFctn::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* AliHBTWeightQLongFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTWeightQSideFctn)
/*************************************************************************************/ 

AliHBTWeightQSideFctn::AliHBTWeightQSideFctn(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 AliHBTWeightQSideFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
  }
} 
/****************************************************************/

void  AliHBTWeightQSideFctn::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* AliHBTWeightQSideFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTWeightTwoKStarFctn)
/*************************************************************************************/ 
AliHBTWeightTwoKStarFctn::AliHBTWeightTwoKStarFctn(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 AliHBTWeightTwoKStarFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
  }
} 
/****************************************************************/

void  AliHBTWeightTwoKStarFctn::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* AliHBTWeightTwoKStarFctn::GetResult() 
                                                                               
{ 
//returns ratio of numerator and denominator                                    
 return GetRatio(Scale());                                                  
}                    
                                                              
/*************************************************************************************/ 
/*************************************************************************************/ 
/*************************************************************************************/ 

ClassImp(AliHBTWeightQOutQSideFctn)
/*************************************************************************************/ 
    
AliHBTWeightQOutQSideFctn::AliHBTWeightQOutQSideFctn(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 AliHBTWeightQOutQSideFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTWeightQOutQSideFctn::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* AliHBTWeightQOutQSideFctn::GetResult()
{
  //returns result
  return GetRatio(Scale());
}

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

ClassImp(AliHBTWeightQOutQLongFctn)
/*************************************************************************************/ 
    
AliHBTWeightQOutQLongFctn::AliHBTWeightQOutQLongFctn(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 AliHBTWeightQOutQLongFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTWeightQOutQLongFctn::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* AliHBTWeightQOutQLongFctn::GetResult()
{
  //returns result
  return GetRatio(Scale());
}

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

ClassImp(AliHBTWeightQSideQLongFctn)
/*************************************************************************************/ 
    
AliHBTWeightQSideQLongFctn::AliHBTWeightQSideQLongFctn(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 AliHBTWeightQSideQLongFctn::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 weight = 1.0;
    if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
         ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
      {   
         weight=partpair->GetWeight();
      }   
//    Double_t weight=weightHBT*weightPID;
    fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
  }
} 
/****************************************************************/

void AliHBTWeightQSideQLongFctn::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* AliHBTWeightQSideQLongFctn::GetResult()
{
  //returns result
  return GetRatio(Scale());
}
Commit	Line	Data
dd82cadc	1	#include "AliHBTWeightFctn.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)
dd82cadc	15	#include "AliHBTWeightsPID.h"
7f92929e	16
dd82cadc	17	//--for test--AliHBTWeightQInvFctn* yyy= new AliHBTWeightQInvFctn();
7f92929e	18
dd82cadc	19	ClassImp( AliHBTWeightQInvFctn )
88cb7938	20
88cb7938	21
7f92929e	22	/****************************************************************/
dd82cadc	23	AliHBTWeightQInvFctn::AliHBTWeightQInvFctn(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	}
7f92929e	30	/****************************************************************/
dd82cadc	31	void AliHBTWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
7f92929e	32	{
9714a029	33	//process particles from same events (fills numerator)
7f92929e	34	trackpair = CheckPair(trackpair);
	35	partpair = CheckPair(partpair);
	36	if ( trackpair && partpair)
	37	{
dd82cadc	38	// Double_t weightPID=1.;
	39	Double_t weight = 1.0;
	40	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	41	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	42	{
	43	weight=partpair->GetWeight();
	44	}
	45	// Double_t weight=weightHBT*weightPID;
	46	fNumerator->Fill(trackpair->GetQInv(),weight);
7f92929e	47	}
7f92929e	48	}
7f92929e	49	/****************************************************************/
2f8eea63	50
dd82cadc	51	void AliHBTWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
7f92929e	52	{
4fdf4eb3	53	// Fills the denominator using mixed pairs
7f92929e	54	trackpair = CheckPair(trackpair);
	55	partpair = CheckPair(partpair);
	56	if ( trackpair && partpair)
	57	{
	58	fDenominator->Fill(trackpair->GetQInv());
	59	}
	60	}
	61	/**************************************************************/
dd82cadc	62	TH1* AliHBTWeightQInvFctn::GetResult()
7f92929e	63	{
7f92929e	64	//returns ratio of numerator and denominator
af8cf344	65	return GetRatio(Scale());
7f92929e	66	}
7f92929e	67
b3fb9814	68	/**************************************************************************************/
	69	/**************************************************************************************/
	70	/**************************************************************************************/
	71	/**************************************************************************************/
	72
dd82cadc	73	ClassImp(AliHBTWeightQOutFctn)
9714a029	74
dd82cadc	75	AliHBTWeightQOutFctn::AliHBTWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
9714a029	76	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	77	{
	78	//ctor
	79	fWriteNumAndDen = kTRUE;//change default behaviour
	80	Rename("wqoutcf","Q_{out} Weight Correlation Function");
	81	}
b3fb9814	82	/****************************************************************/
dd82cadc	83	void AliHBTWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	84	{
9714a029	85	//process particles from same events (fills numerator)
b3fb9814	86	trackpair = CheckPair(trackpair);
	87	partpair = CheckPair(partpair);
	88	if ( trackpair && partpair)
	89	{
dd82cadc	90	// Double_t weightPID=1.;
	91	Double_t weight = 1.0;
	92	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	93	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	94	{
	95	weight=partpair->GetWeight();
	96	}
	97	// Double_t weight=weightHBT*weightPID;
	98	fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
b3fb9814	99	}
	100	}
	101	/****************************************************************/
	102
dd82cadc	103	void AliHBTWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	104	{
9714a029	105	//process particles from diff events (fills denominator)
b3fb9814	106	trackpair = CheckPair(trackpair);
	107	partpair = CheckPair(partpair);
	108	if ( trackpair && partpair)
	109	{
	110	fDenominator->Fill(trackpair->GetQOutCMSLC());
	111	}
	112	}
	113	/**************************************************************/
dd82cadc	114	TH1* AliHBTWeightQOutFctn::GetResult()
b3fb9814	115
	116	{
	117	//returns ratio of numerator and denominator
	118	return GetRatio(Scale());
	119	}
	120
	121	/*************************************************************************************/
	122	/*************************************************************************************/
	123	/*************************************************************************************/
	124
dd82cadc	125	ClassImp(AliHBTWeightQLongFctn)
dd82cadc	126	AliHBTWeightQLongFctn::AliHBTWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
9714a029	127	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	128	{
	129	//ctor
	130	fWriteNumAndDen = kTRUE;//change default behaviour
	131	Rename("wqlongcf","Q_{long} Weight Correlation Function");
	132	}
b3fb9814	133	/****************************************************************/
dd82cadc	134	void AliHBTWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	135	{
9714a029	136	//process particles from same events (fills numerator)
b3fb9814	137	trackpair = CheckPair(trackpair);
	138	partpair = CheckPair(partpair);
	139	if ( trackpair && partpair)
	140	{
dd82cadc	141	// Double_t weightPID=1.;
	142	Double_t weight = 1.0;
	143	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	144	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	145	{
	146	weight=partpair->GetWeight();
	147	}
	148	// Double_t weight=weightHBT*weightPID;
	149	fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
b3fb9814	150	}
	151	}
	152	/****************************************************************/
	153
dd82cadc	154	void AliHBTWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	155	{
9714a029	156	//process particles from diff events (fills denominator)
b3fb9814	157	trackpair = CheckPair(trackpair);
	158	partpair = CheckPair(partpair);
	159	if ( trackpair && partpair)
	160	{
	161	fDenominator->Fill(trackpair->GetQLongCMSLC());
	162	}
	163	}
	164	/**************************************************************/
dd82cadc	165	TH1* AliHBTWeightQLongFctn::GetResult()
b3fb9814	166
	167	{
	168	//returns ratio of numerator and denominator
	169	return GetRatio(Scale());
	170	}
	171
	172	/*************************************************************************************/
	173	/*************************************************************************************/
	174	/*************************************************************************************/
	175
dd82cadc	176	ClassImp(AliHBTWeightQSideFctn)
9714a029	177	/*************************************************************************************/
9714a029	178
dd82cadc	179	AliHBTWeightQSideFctn::AliHBTWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
9714a029	180	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	181	{
	182	//ctor
	183	fWriteNumAndDen = kTRUE;//change default behaviour
	184	Rename("wqsidecf","Q_{side} Weight Correlation Function");
	185	}
b3fb9814	186	/****************************************************************/
dd82cadc	187	void AliHBTWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	188	{
9714a029	189	//process particles from same events (fills numerator)
b3fb9814	190	trackpair = CheckPair(trackpair);
	191	partpair = CheckPair(partpair);
	192	if ( trackpair && partpair)
	193	{
dd82cadc	194	// Double_t weightPID=1.;
	195	Double_t weight = 1.0;
	196	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	197	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	198	{
	199	weight=partpair->GetWeight();
	200	}
	201	// Double_t weight=weightHBT*weightPID;
	202	fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
b3fb9814	203	}
	204	}
	205	/****************************************************************/
	206
dd82cadc	207	void AliHBTWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	208	{
9714a029	209	//process particles from diff events (fills denominator)
b3fb9814	210	trackpair = CheckPair(trackpair);
	211	partpair = CheckPair(partpair);
	212	if ( trackpair && partpair)
	213	{
	214	fDenominator->Fill(trackpair->GetQSideCMSLC());
	215	}
	216	}
	217	/**************************************************************/
dd82cadc	218	TH1* AliHBTWeightQSideFctn::GetResult()
b3fb9814	219
	220	{
	221	//returns ratio of numerator and denominator
	222	return GetRatio(Scale());
	223	}
	224
9714a029	225	/*************************************************************************************/
b3fb9814	226	/*************************************************************************************/
	227	/*************************************************************************************/
	228
dd82cadc	229	ClassImp(AliHBTWeightTwoKStarFctn)
9714a029	230	/*************************************************************************************/
dd82cadc	231	AliHBTWeightTwoKStarFctn::AliHBTWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
9714a029	232	AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
	233	{
	234	//ctor
	235	fWriteNumAndDen = kTRUE;//change default behaviour
	236	Rename("wtwokstarcf","2K^{} Weight Correlation Function");
	237	}
b3fb9814	238	/****************************************************************/
dd82cadc	239	void AliHBTWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	240	{
9714a029	241	//process particles from same events (fills numerator)
b3fb9814	242	trackpair = CheckPair(trackpair);
	243	partpair = CheckPair(partpair);
	244	if ( trackpair && partpair)
	245	{
dd82cadc	246	// Double_t weightPID=1.;
	247	Double_t weight = 1.0;
	248	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	249	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	250	{
	251	weight=partpair->GetWeight();
	252	}
	253	// Double_t weight=weightHBT*weightPID;
	254	fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
b3fb9814	255	}
	256	}
	257	/****************************************************************/
	258
dd82cadc	259	void AliHBTWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
b3fb9814	260	{
9714a029	261	//process particles from diff events (fills denominator)
b3fb9814	262	trackpair = CheckPair(trackpair);
	263	partpair = CheckPair(partpair);
	264	if ( trackpair && partpair)
	265	{
	266	fDenominator->Fill(2.0*(trackpair->GetKStar()));
	267	}
	268	}
	269	/**************************************************************/
dd82cadc	270	TH1* AliHBTWeightTwoKStarFctn::GetResult()
b3fb9814	271
	272	{
	273	//returns ratio of numerator and denominator
	274	return GetRatio(Scale());
	275	}
	276
9714a029	277	/*************************************************************************************/
	278	/*************************************************************************************/
	279	/*************************************************************************************/
	280
dd82cadc	281	ClassImp(AliHBTWeightQOutQSideFctn)
9714a029	282	/*************************************************************************************/
9714a029	283
dd82cadc	284	AliHBTWeightQOutQSideFctn::AliHBTWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
9714a029	285	Int_t nybins, Double_t maxYval, Double_t minYval):
	286	AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
	287	{
	288	//ctor
	289	fWriteNumAndDen = kTRUE;//change default behaviour
	290	Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
	291	}
	292	/*************************************************************************************/
dd82cadc	293	void AliHBTWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
9714a029	294	{
	295	//process particles from same events (fills numerator)
	296	trackpair = CheckPair(trackpair);
	297	partpair = CheckPair(partpair);
	298	if ( trackpair && partpair)
	299	{
dd82cadc	300	// Double_t weightPID=1.;
	301	Double_t weight = 1.0;
	302	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	303	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	304	{
	305	weight=partpair->GetWeight();
	306	}
	307	// Double_t weight=weightHBT*weightPID;
	308	fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
9714a029	309	}
	310	}
	311	/****************************************************************/
	312
dd82cadc	313	void AliHBTWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
9714a029	314	{
	315	//process particles from diff events (fills denominator)
	316	trackpair = CheckPair(trackpair);
	317	partpair = CheckPair(partpair);
	318	if ( trackpair && partpair)
	319	{
	320	fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
	321	}
	322	}
	323	/**************************************************************/
dd82cadc	324	TH1* AliHBTWeightQOutQSideFctn::GetResult()
9714a029	325	{
	326	//returns result
	327	return GetRatio(Scale());
	328	}
	329
	330	/*************************************************************************************/
	331	/*************************************************************************************/
	332	/*************************************************************************************/
	333
dd82cadc	334	ClassImp(AliHBTWeightQOutQLongFctn)
9714a029	335	/*************************************************************************************/
9714a029	336
dd82cadc	337	AliHBTWeightQOutQLongFctn::AliHBTWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
9714a029	338	Int_t nybins, Double_t maxYval, Double_t minYval):
	339	AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
	340	{
	341	//ctor
	342	fWriteNumAndDen = kTRUE;//change default behaviour
	343	Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
	344	}
	345	/*************************************************************************************/
dd82cadc	346	void AliHBTWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
9714a029	347	{
	348	//process particles from same events (fills numerator)
	349	trackpair = CheckPair(trackpair);
	350	partpair = CheckPair(partpair);
	351	if ( trackpair && partpair)
	352	{
dd82cadc	353	// Double_t weightPID=1.;
	354	Double_t weight = 1.0;
	355	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	356	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	357	{
	358	weight=partpair->GetWeight();
	359	}
	360	// Double_t weight=weightHBT*weightPID;
	361	fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
9714a029	362	}
	363	}
	364	/****************************************************************/
	365
dd82cadc	366	void AliHBTWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
9714a029	367	{
	368	//process particles from diff events (fills denominator)
	369	trackpair = CheckPair(trackpair);
	370	partpair = CheckPair(partpair);
	371	if ( trackpair && partpair)
	372	{
	373	fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
	374	}
	375	}
	376	/**************************************************************/
	377
dd82cadc	378	TH1* AliHBTWeightQOutQLongFctn::GetResult()
9714a029	379	{
	380	//returns result
	381	return GetRatio(Scale());
	382	}
	383
	384	/*************************************************************************************/
	385	/*************************************************************************************/
b3fb9814	386	/*************************************************************************************/
b3fb9814	387
dd82cadc	388	ClassImp(AliHBTWeightQSideQLongFctn)
9714a029	389	/*************************************************************************************/
9714a029	390
dd82cadc	391	AliHBTWeightQSideQLongFctn::AliHBTWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
9714a029	392	Int_t nybins, Double_t maxYval, Double_t minYval):
	393	AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
	394	{
	395	//ctor
	396	fWriteNumAndDen = kTRUE;//change default behaviour
	397	Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
	398	}
	399	/*************************************************************************************/
dd82cadc	400	void AliHBTWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
9714a029	401	{
	402	//process particles from same events (fills numerator)
	403	trackpair = CheckPair(trackpair);
	404	partpair = CheckPair(partpair);
	405	if ( trackpair && partpair)
	406	{
dd82cadc	407	// Double_t weightPID=1.;
	408	Double_t weight = 1.0;
	409	if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
	410	( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode()) )
	411	{
	412	weight=partpair->GetWeight();
	413	}
	414	// Double_t weight=weightHBT*weightPID;
	415	fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
9714a029	416	}
	417	}
	418	/****************************************************************/
	419
dd82cadc	420	void AliHBTWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
9714a029	421	{
	422	//process particles from diff events (fills denominator)
	423	trackpair = CheckPair(trackpair);
	424	partpair = CheckPair(partpair);
	425	if ( trackpair && partpair)
	426	{
	427	fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
	428	}
	429	}
	430	/**************************************************************/
dd82cadc	431	TH1* AliHBTWeightQSideQLongFctn::GetResult()
9714a029	432	{
	433	//returns result
	434	return GetRatio(Scale());
	435	}