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

#include "AliHBTWeightFctn.h"
/* $Id$ */
//_________________________________________________________________________
//
// class AliHBTWeightQInvFctn
//
// 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)
//
////////////////////////////////////////////////////////////////////////////////

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