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

#include "AliHBTPair.h"
//_________________________________________________________________________
///////////////////////////////////////////////////////////////////////////
//
// class AliHBTPair
//
// class implements pair of particles and taking care of caluclation (almost)
// all of pair properties (Qinv, InvMass,...)
// 
// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
//
////////////////////////////////////////////////////////////////////////////

#include "AliHBTParticle.h"
#include "AliHBTWeights.h"

ClassImp(AliHBTPair)

/************************************************************************/
AliHBTPair::AliHBTPair(Bool_t rev):
 fPart1(0x0),
 fPart2(0x0),
 fSwapedPair(0x0),
 fQSideCMSLC(0.0),
 fQSideCMSLCNotCalc(kTRUE),
 fQOutCMSLC(0.0),
 fQOutCMSLCNotCalc(kTRUE),
 fQLongCMSLC(0.0),
 fQLongCMSLCNotCalc(kTRUE),
 fQInv(0.0),
 fQInvNotCalc(kTRUE),
 fInvMass(0.0),
 fInvMassNotCalc(kTRUE),
 fKt(0.0),
 fKtNotCalc(kTRUE),
 fKStar(0.0),
 fKStarNotCalc(kTRUE),
 fPInv(0.0),
 fQSide(0.0),
 fOut(0.0),
 fQLong(0.0),
 fMt(0.0),
 fMtNotCalc(kTRUE),
 fInvMassSqr(0.0),
 fMassSqrNotCalc(kTRUE),
 fQInvL(0.0),
 fQInvLNotCalc(kTRUE),
 fWeight(0.0),
 fWeightNotCalc(kTRUE),
 fPxSum(0.0),
 fPySum(0.0),
 fPzSum(0.0),
 fESum(0.0),
 fSumsNotCalc(kTRUE),
 fPxDiff(0.0),
 fPyDiff(0.0),
 fPzDiff(0.0),
 fEDiff(0.0),
 fDiffsNotCalc(kTRUE),
 fGammaCMSLC(0.0),
 fGammaCMSLCNotCalc(kTRUE),
 fChanged(kTRUE)
 {
//value of rev defines if it is Swaped
//if you pass kTRUE swpaped pair will NOT be created
//though you wont be able to get the swaped pair from this pair

  if(!rev) fSwapedPair = new AliHBTPair(kTRUE); //if false create swaped pair
  
 }
/************************************************************************/

AliHBTPair::AliHBTPair(AliHBTParticle* part1, AliHBTParticle* part2, Bool_t rev):
 fPart1(part1),
 fPart2(part2),
 fSwapedPair(0x0),
 fQSideCMSLC(0.0),
 fQSideCMSLCNotCalc(kTRUE),
 fQOutCMSLC(0.0),
 fQOutCMSLCNotCalc(kTRUE),
 fQLongCMSLC(0.0),
 fQLongCMSLCNotCalc(kTRUE),
 fQInv(0.0),
 fQInvNotCalc(kTRUE),
 fInvMass(0.0),
 fInvMassNotCalc(kTRUE),
 fKt(0.0),
 fKtNotCalc(kTRUE),
 fKStar(0.0),
 fKStarNotCalc(kTRUE),
 fPInv(0.0),
 fQSide(0.0),
 fOut(0.0),
 fQLong(0.0),
 fMt(0.0),
 fMtNotCalc(kTRUE),
 fInvMassSqr(0.0),
 fMassSqrNotCalc(kTRUE),
 fQInvL(0.0),
 fQInvLNotCalc(kTRUE),
 fWeight(0.0),
 fWeightNotCalc(kTRUE),
 fPxSum(0.0),
 fPySum(0.0),
 fPzSum(0.0),
 fESum(0.0),
 fSumsNotCalc(kTRUE),
 fPxDiff(0.0),
 fPyDiff(0.0),
 fPzDiff(0.0),
 fEDiff(0.0),
 fDiffsNotCalc(kTRUE),
 fGammaCMSLC(0.0),
 fGammaCMSLCNotCalc(kTRUE),
 fChanged(kTRUE)
 {
//value of rev defines if it is Swaped
//if you pass kTRUE swpaped pair will NOT be created
//though you wont be able to get the swaped pair from this pair

  if(!rev) fSwapedPair = new AliHBTPair(part2,part1,kTRUE); //if false create swaped pair
  
 }
/************************************************************************/
AliHBTPair::AliHBTPair(const AliHBTPair& in):
 TObject(in),
 fPart1(0x0),
 fPart2(0x0),
 fSwapedPair(0x0),
 fQSideCMSLC(0.0),
 fQSideCMSLCNotCalc(kTRUE),
 fQOutCMSLC(0.0),
 fQOutCMSLCNotCalc(kTRUE),
 fQLongCMSLC(0.0),
 fQLongCMSLCNotCalc(kTRUE),
 fQInv(0.0),
 fQInvNotCalc(kTRUE),
 fInvMass(0.0),
 fInvMassNotCalc(kTRUE),
 fKt(0.0),
 fKtNotCalc(kTRUE),
 fKStar(0.0),
 fKStarNotCalc(kTRUE),
 fPInv(0.0),
 fQSide(0.0),
 fOut(0.0),
 fQLong(0.0),
 fMt(0.0),
 fMtNotCalc(kTRUE),
 fInvMassSqr(0.0),
 fMassSqrNotCalc(kTRUE),
 fQInvL(0.0),
 fQInvLNotCalc(kTRUE),
 fWeight(0.0),
 fWeightNotCalc(kTRUE),
 fPxSum(0.0),
 fPySum(0.0),
 fPzSum(0.0),
 fESum(0.0),
 fSumsNotCalc(kTRUE),
 fPxDiff(0.0),
 fPyDiff(0.0),
 fPzDiff(0.0),
 fEDiff(0.0),
 fDiffsNotCalc(kTRUE),
 fGammaCMSLC(0.0),
 fGammaCMSLCNotCalc(kTRUE),
 fChanged(kTRUE)
{
 //cpy constructor
 in.Copy(*this);
}
/************************************************************************/

AliHBTPair& AliHBTPair::operator=(const AliHBTPair& in)
{
 //Assigment operator
 in.Copy(*this);
 return *this;
}
/************************************************************************/

Double_t AliHBTPair::GetInvMass()
{
//Returns qinv value for a pair
  if(fInvMassNotCalc)
   {
     CalculateInvMassSqr(); //method is inline so we not waste th time for jumping into method 
     
     if(fInvMassSqr<0)  fInvMass = TMath::Sqrt(-fInvMassSqr);
     else fInvMass = TMath::Sqrt(fInvMassSqr); 
     
     fInvMassNotCalc = kFALSE;
   }
  return fInvMass;
}
/************************************************************************/
Double_t AliHBTPair::GetQSideCMSLC()
{
  //return Q Side in Central Of Mass System in Longitudialy Comoving Frame
 
  if (fQSideCMSLCNotCalc)
   {
    fQSideCMSLC = (fPart1->Px()*fPart2->Py()-fPart2->Px()*fPart1->Py())/GetKt();
    fQSideCMSLCNotCalc = kFALSE;
   }
  return fQSideCMSLC;
}
/************************************************************************/
Double_t AliHBTPair::GetQOutCMSLC()
{
 //caculates Qout in Center Of Mass Longitudionally Co-Moving
 if(fQOutCMSLCNotCalc)
  {
   CalculateSums();
   CalculateDiffs();

   if (fPart1->GetMass() != fPart2->GetMass())
    {
/*    
      //STAR algorithm
      Double_t beta  = fPzSum/fESum;
      Double_t gamma = GetGammaToCMSLC();
      Double_t el = gamma * (fPart1->Energy() - beta * fPart1->Pz());
      Double_t x  = ( fPart1->Px()*fPxSum + fPart1->Py()*fPySum) / ( 2.0*GetKt() );
      beta  = 2.0*GetKt()/GetMt();
      gamma = GetMt()/GetQInv();
      fQOutCMSLC = gamma * (x - beta * el);
*/

      //beta=fPzSum/fESum;    // Longit. V == beta
      Double_t beta=fPzSum/fESum;
      Double_t gamma = GetGammaToCMSLC();
      
      Double_t cosphi=fPxSum/(2.0*GetKt());  // cos(phi)
      Double_t sinphi=fPySum/(2.0*GetKt()); // sin(phi)
      
//      ROTATE(part1Px,part1Py,SPHI,CPHI,part1Px,part1Py);//ROT8
//      ROTATE(part2Px,part2Py,SPHI,CPHI,part2Px,part2Py);//ROT8
      Double_t tmp;
      tmp = fPart1->Px()*cosphi + fPart1->Py()*sinphi;
      Double_t part1Py = fPart1->Py()*cosphi - fPart1->Px()*sinphi;
      Double_t part1Px = tmp;

      tmp = fPart2->Px()*cosphi + fPart2->Py()*sinphi;
      Double_t part2Py = fPart2->Py()*cosphi - fPart2->Px()*sinphi;
      Double_t part2Px = tmp;
      
      
//      LTR(part1Pz,E1,beta,GetGammaToCMSLC(),part1Pz,E1a);
//      LTR(part2Pz,E2,beta,GetGammaToCMSLC(),part2Pz,E2a);
      Double_t part1Pz=gamma*(fPart1->Pz()-beta*fPart1->Energy());
      Double_t part2Pz=gamma*(fPart2->Pz()-beta*fPart2->Energy());

      Double_t part1P2=part1Px*part1Px+part1Py*part1Py+part1Pz*part1Pz;
      Double_t part2P2=part2Px*part2Px+part2Py*part2Py+part2Pz*part2Pz;
      Double_t part1E=TMath::Sqrt(fPart1->GetMass()*fPart1->GetMass()+part1P2);
      Double_t part2E=TMath::Sqrt(fPart2->GetMass()*fPart2->GetMass()+part2P2);
      Double_t sumE=part1E+part2E;
      Double_t sumPx=part1Px+part2Px;
      Double_t sumPy=part1Py+part2Py;
      Double_t sumPZ=part1Pz+part2Pz;
      Double_t sumP2=sumPx*sumPx+sumPy*sumPy+sumPZ*sumPZ;

      Double_t relmass=TMath::Sqrt(sumE*sumE-sumP2);
      Double_t hf = (fPart1->GetMass()*fPart1->GetMass() - fPart2->GetMass()*fPart2->GetMass())/(relmass*relmass);
      fQOutCMSLC=(part1Px-part2Px);//== id
      fQOutCMSLC=fQOutCMSLC-sumPx*hf; //sumPx == fPxSum ale po rotacji i transf
    }
   else
    {
      Double_t k2 = fPxSum*fPxDiff+fPySum*fPyDiff;
      fQOutCMSLC = 0.5*k2/GetKt();
   // if (non-id)  fQOutCMSLC=fQOutCMSLC - sumPx*HF;
    }

    
   fQOutCMSLCNotCalc = kFALSE;
  }
 return fQOutCMSLC;
}
/************************************************************************/
Double_t AliHBTPair::GetQLongCMSLC()
{
 //return Q Long in Central Of Mass System in Longitudialy Comoving Frame
 if (fQLongCMSLCNotCalc)
  {
    CalculateSums();
    CalculateDiffs();
    Double_t beta = fPzSum/fESum;
    fQLongCMSLC = GetGammaToCMSLC() * ( fPzDiff - beta*fEDiff );
    fQLongCMSLCNotCalc = kFALSE;
  }
 return fQLongCMSLC; 
}
/************************************************************************/
Double_t AliHBTPair::GetKt()
{
 //calculates the evarage momentum of the pair
  if(fKtNotCalc)
   { 
     CalculateSums();
     fKt =  0.5*TMath::Hypot(fPxSum,fPySum);
     fKtNotCalc = kFALSE;
   }
  return fKt;
}
/************************************************************************/

Double_t AliHBTPair::GetKStar()
{
  //calculates invariant velocity difference
  if (fKStarNotCalc)
   { 
    CalculateSums();

    Double_t ptrans = fPxSum*fPxSum + fPySum*fPySum;
    Double_t mtrans = fESum*fESum - fPzSum*fPzSum;
    Double_t pinv =   TMath::Sqrt(mtrans - ptrans);

    Double_t q = (fPart1->GetMass()*fPart1->GetMass() - fPart2->GetMass()*fPart2->GetMass())/pinv;
    
    CalculateQInvL();
    
    q = q*q - fQInvL;
    if ( q < 0)
     {
        Info("GetKStar","q = %f",q);
        fPart1->Print();
        fPart2->Print();
        q = TMath::Abs(q);
     }
     
    q = TMath::Sqrt(q);
    fKStar = q/2.;
    fKStarNotCalc = kFALSE;
   }
  return fKStar;
}
/************************************************************************/

Double_t AliHBTPair::GetQInv()
{
//returns Qinv 
//warning for non-id particles you want to use 2*KStar
  if(fQInvNotCalc)
   {
    CalculateQInvL();
    fQInv = TMath::Sqrt(TMath::Abs(fQInvL));
    fQInvNotCalc = kFALSE;
   }
  return fQInv;
}
/************************************************************************/

Double_t AliHBTPair::GetGammaToCMSLC()
{
  //calculates gamma factor of the boost to CMSLC
  if(fGammaCMSLCNotCalc)
   {
     CalculateSums();
     Double_t beta = fPzSum/fESum;
     fGammaCMSLC = 1.0/TMath::Sqrt(1.0 - beta*beta);
     fGammaCMSLCNotCalc = kFALSE;
   }
  return fGammaCMSLC;
}
/************************************************************************/

Double_t AliHBTPair::GetMt()
{
  //Calculates transverse mass of the pair
  if (fMtNotCalc)
   {
     CalculateSums();
     fMt = TMath::Sqrt(fESum*fESum - fPzSum*fPzSum);
     fMtNotCalc = kFALSE;
   }
   return fMt;
}
/************************************************************************/

Double_t AliHBTPair::GetWeight()
{
  //returns and buffers weight for this pair
  if (fWeightNotCalc)
   {
      fWeight = AliHBTWeights::Weight(this);
      fWeightNotCalc = kFALSE;  
   }
  return fWeight; 
}
Commit	Line	Data
1b446896	1	#include "AliHBTPair.h"
58ee8590	2	//_________________________________________________________________________
	3	///////////////////////////////////////////////////////////////////////////
	4	//
	5	// class AliHBTPair
	6	//
	7	// class implements pair of particles and taking care of caluclation (almost)
	8	// all of pair properties (Qinv, InvMass,...)
d012b7d0	9	//
58ee8590	10	// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
	11	//
	12	////////////////////////////////////////////////////////////////////////////
	13
1b446896	14	#include "AliHBTParticle.h"
dd82cadc	15	#include "AliHBTWeights.h"
1b446896	16
	17	ClassImp(AliHBTPair)
	18
1b446896	19	/************************************************************************/
ec6e4013	20	AliHBTPair::AliHBTPair(Bool_t rev):
ec6e4013	21	fPart1(0x0),
7261986f	22	fPart2(0x0),
	23	fSwapedPair(0x0),
	24	fQSideCMSLC(0.0),
	25	fQSideCMSLCNotCalc(kTRUE),
	26	fQOutCMSLC(0.0),
	27	fQOutCMSLCNotCalc(kTRUE),
	28	fQLongCMSLC(0.0),
	29	fQLongCMSLCNotCalc(kTRUE),
	30	fQInv(0.0),
	31	fQInvNotCalc(kTRUE),
	32	fInvMass(0.0),
	33	fInvMassNotCalc(kTRUE),
	34	fKt(0.0),
	35	fKtNotCalc(kTRUE),
	36	fKStar(0.0),
	37	fKStarNotCalc(kTRUE),
	38	fPInv(0.0),
	39	fQSide(0.0),
	40	fOut(0.0),
	41	fQLong(0.0),
	42	fMt(0.0),
	43	fMtNotCalc(kTRUE),
	44	fInvMassSqr(0.0),
	45	fMassSqrNotCalc(kTRUE),
	46	fQInvL(0.0),
	47	fQInvLNotCalc(kTRUE),
dd82cadc	48	fWeight(0.0),
dd82cadc	49	fWeightNotCalc(kTRUE),
7261986f	50	fPxSum(0.0),
	51	fPySum(0.0),
	52	fPzSum(0.0),
	53	fESum(0.0),
	54	fSumsNotCalc(kTRUE),
	55	fPxDiff(0.0),
	56	fPyDiff(0.0),
	57	fPzDiff(0.0),
	58	fEDiff(0.0),
	59	fDiffsNotCalc(kTRUE),
	60	fGammaCMSLC(0.0),
	61	fGammaCMSLCNotCalc(kTRUE),
	62	fChanged(kTRUE)
1b446896	63	{
	64	//value of rev defines if it is Swaped
	65	//if you pass kTRUE swpaped pair will NOT be created
	66	//though you wont be able to get the swaped pair from this pair
	67
	68	if(!rev) fSwapedPair = new AliHBTPair(kTRUE); //if false create swaped pair
1b446896	69
	70	}
	71	/************************************************************************/
ec6e4013	72
	73	AliHBTPair::AliHBTPair(AliHBTParticle* part1, AliHBTParticle* part2, Bool_t rev):
	74	fPart1(part1),
7261986f	75	fPart2(part2),
	76	fSwapedPair(0x0),
	77	fQSideCMSLC(0.0),
	78	fQSideCMSLCNotCalc(kTRUE),
	79	fQOutCMSLC(0.0),
	80	fQOutCMSLCNotCalc(kTRUE),
	81	fQLongCMSLC(0.0),
	82	fQLongCMSLCNotCalc(kTRUE),
	83	fQInv(0.0),
	84	fQInvNotCalc(kTRUE),
	85	fInvMass(0.0),
	86	fInvMassNotCalc(kTRUE),
	87	fKt(0.0),
	88	fKtNotCalc(kTRUE),
	89	fKStar(0.0),
	90	fKStarNotCalc(kTRUE),
	91	fPInv(0.0),
	92	fQSide(0.0),
	93	fOut(0.0),
	94	fQLong(0.0),
	95	fMt(0.0),
	96	fMtNotCalc(kTRUE),
	97	fInvMassSqr(0.0),
	98	fMassSqrNotCalc(kTRUE),
	99	fQInvL(0.0),
	100	fQInvLNotCalc(kTRUE),
dd82cadc	101	fWeight(0.0),
dd82cadc	102	fWeightNotCalc(kTRUE),
7261986f	103	fPxSum(0.0),
	104	fPySum(0.0),
	105	fPzSum(0.0),
	106	fESum(0.0),
	107	fSumsNotCalc(kTRUE),
	108	fPxDiff(0.0),
	109	fPyDiff(0.0),
	110	fPzDiff(0.0),
	111	fEDiff(0.0),
	112	fDiffsNotCalc(kTRUE),
	113	fGammaCMSLC(0.0),
	114	fGammaCMSLCNotCalc(kTRUE),
	115	fChanged(kTRUE)
ec6e4013	116	{
	117	//value of rev defines if it is Swaped
	118	//if you pass kTRUE swpaped pair will NOT be created
	119	//though you wont be able to get the swaped pair from this pair
	120
	121	if(!rev) fSwapedPair = new AliHBTPair(part2,part1,kTRUE); //if false create swaped pair
ec6e4013	122
	123	}
	124	/************************************************************************/
d012b7d0	125	AliHBTPair::AliHBTPair(const AliHBTPair& in):
	126	TObject(in),
	127	fPart1(0x0),
	128	fPart2(0x0),
	129	fSwapedPair(0x0),
	130	fQSideCMSLC(0.0),
	131	fQSideCMSLCNotCalc(kTRUE),
	132	fQOutCMSLC(0.0),
	133	fQOutCMSLCNotCalc(kTRUE),
	134	fQLongCMSLC(0.0),
	135	fQLongCMSLCNotCalc(kTRUE),
	136	fQInv(0.0),
	137	fQInvNotCalc(kTRUE),
	138	fInvMass(0.0),
	139	fInvMassNotCalc(kTRUE),
	140	fKt(0.0),
	141	fKtNotCalc(kTRUE),
	142	fKStar(0.0),
	143	fKStarNotCalc(kTRUE),
	144	fPInv(0.0),
	145	fQSide(0.0),
	146	fOut(0.0),
	147	fQLong(0.0),
	148	fMt(0.0),
	149	fMtNotCalc(kTRUE),
	150	fInvMassSqr(0.0),
	151	fMassSqrNotCalc(kTRUE),
	152	fQInvL(0.0),
	153	fQInvLNotCalc(kTRUE),
	154	fWeight(0.0),
	155	fWeightNotCalc(kTRUE),
	156	fPxSum(0.0),
	157	fPySum(0.0),
	158	fPzSum(0.0),
	159	fESum(0.0),
	160	fSumsNotCalc(kTRUE),
	161	fPxDiff(0.0),
	162	fPyDiff(0.0),
	163	fPzDiff(0.0),
	164	fEDiff(0.0),
	165	fDiffsNotCalc(kTRUE),
	166	fGammaCMSLC(0.0),
	167	fGammaCMSLCNotCalc(kTRUE),
	168	fChanged(kTRUE)
	169	{
	170	//cpy constructor
	171	in.Copy(*this);
	172	}
	173	/************************************************************************/
	174
34914285	175	AliHBTPair& AliHBTPair::operator=(const AliHBTPair& in)
d012b7d0	176	{
	177	//Assigment operator
	178	in.Copy(*this);
	179	return *this;
	180	}
34914285	181	/************************************************************************/
ec6e4013	182
1b446896	183	Double_t AliHBTPair::GetInvMass()
1b446896	184	{
b928db6c	185	//Returns qinv value for a pair
1b446896	186	if(fInvMassNotCalc)
	187	{
	188	CalculateInvMassSqr(); //method is inline so we not waste th time for jumping into method
	189
	190	if(fInvMassSqr<0) fInvMass = TMath::Sqrt(-fInvMassSqr);
	191	else fInvMass = TMath::Sqrt(fInvMassSqr);
	192
	193	fInvMassNotCalc = kFALSE;
	194	}
	195	return fInvMass;
	196	}
	197	/************************************************************************/
	198	Double_t AliHBTPair::GetQSideCMSLC()
	199	{
	200	//return Q Side in Central Of Mass System in Longitudialy Comoving Frame
	201
	202	if (fQSideCMSLCNotCalc)
	203	{
	204	fQSideCMSLC = (fPart1->Px()fPart2->Py()-fPart2->Px()fPart1->Py())/GetKt();
	205	fQSideCMSLCNotCalc = kFALSE;
	206	}
	207	return fQSideCMSLC;
	208	}
	209	/************************************************************************/
	210	Double_t AliHBTPair::GetQOutCMSLC()
	211	{
58ee8590	212	//caculates Qout in Center Of Mass Longitudionally Co-Moving
1b446896	213	if(fQOutCMSLCNotCalc)
	214	{
	215	CalculateSums();
	216	CalculateDiffs();
951aadb9	217
	218	if (fPart1->GetMass() != fPart2->GetMass())
	219	{
	220	/*
	221	//STAR algorithm
	222	Double_t beta = fPzSum/fESum;
	223	Double_t gamma = GetGammaToCMSLC();
	224	Double_t el = gamma * (fPart1->Energy() - beta * fPart1->Pz());
	225	Double_t x = ( fPart1->Px()fPxSum + fPart1->Py()fPySum) / ( 2.0*GetKt() );
	226	beta = 2.0*GetKt()/GetMt();
	227	gamma = GetMt()/GetQInv();
	228	fQOutCMSLC = gamma * (x - beta * el);
	229	*/
	230
	231	//beta=fPzSum/fESum; // Longit. V == beta
	232	Double_t beta=fPzSum/fESum;
	233	Double_t gamma = GetGammaToCMSLC();
	234
	235	Double_t cosphi=fPxSum/(2.0*GetKt()); // cos(phi)
	236	Double_t sinphi=fPySum/(2.0*GetKt()); // sin(phi)
	237
	238	// ROTATE(part1Px,part1Py,SPHI,CPHI,part1Px,part1Py);//ROT8
	239	// ROTATE(part2Px,part2Py,SPHI,CPHI,part2Px,part2Py);//ROT8
	240	Double_t tmp;
	241	tmp = fPart1->Px()cosphi + fPart1->Py()sinphi;
	242	Double_t part1Py = fPart1->Py()cosphi - fPart1->Px()sinphi;
	243	Double_t part1Px = tmp;
	244
	245	tmp = fPart2->Px()cosphi + fPart2->Py()sinphi;
	246	Double_t part2Py = fPart2->Py()cosphi - fPart2->Px()sinphi;
	247	Double_t part2Px = tmp;
	248
	249
	250	// LTR(part1Pz,E1,beta,GetGammaToCMSLC(),part1Pz,E1a);
	251	// LTR(part2Pz,E2,beta,GetGammaToCMSLC(),part2Pz,E2a);
	252	Double_t part1Pz=gamma(fPart1->Pz()-betafPart1->Energy());
	253	Double_t part2Pz=gamma(fPart2->Pz()-betafPart2->Energy());
	254
	255	Double_t part1P2=part1Pxpart1Px+part1Pypart1Py+part1Pz*part1Pz;
	256	Double_t part2P2=part2Pxpart2Px+part2Pypart2Py+part2Pz*part2Pz;
	257	Double_t part1E=TMath::Sqrt(fPart1->GetMass()*fPart1->GetMass()+part1P2);
	258	Double_t part2E=TMath::Sqrt(fPart2->GetMass()*fPart2->GetMass()+part2P2);
	259	Double_t sumE=part1E+part2E;
	260	Double_t sumPx=part1Px+part2Px;
	261	Double_t sumPy=part1Py+part2Py;
	262	Double_t sumPZ=part1Pz+part2Pz;
	263	Double_t sumP2=sumPxsumPx+sumPysumPy+sumPZ*sumPZ;
	264
	265	Double_t relmass=TMath::Sqrt(sumE*sumE-sumP2);
	266	Double_t hf = (fPart1->GetMass()fPart1->GetMass() - fPart2->GetMass()fPart2->GetMass())/(relmass*relmass);
	267	fQOutCMSLC=(part1Px-part2Px);//== id
	268	fQOutCMSLC=fQOutCMSLC-sumPx*hf; //sumPx == fPxSum ale po rotacji i transf
	269	}
	270	else
	271	{
	272	Double_t k2 = fPxSumfPxDiff+fPySumfPyDiff;
	273	fQOutCMSLC = 0.5*k2/GetKt();
	274	// if (non-id) fQOutCMSLC=fQOutCMSLC - sumPx*HF;
	275	}
	276
	277
1b446896	278	fQOutCMSLCNotCalc = kFALSE;
	279	}
	280	return fQOutCMSLC;
	281	}
	282	/************************************************************************/
	283	Double_t AliHBTPair::GetQLongCMSLC()
	284	{
58ee8590	285	//return Q Long in Central Of Mass System in Longitudialy Comoving Frame
1b446896	286	if (fQLongCMSLCNotCalc)
	287	{
	288	CalculateSums();
	289	CalculateDiffs();
	290	Double_t beta = fPzSum/fESum;
951aadb9	291	fQLongCMSLC = GetGammaToCMSLC() * ( fPzDiff - beta*fEDiff );
1b446896	292	fQLongCMSLCNotCalc = kFALSE;
	293	}
	294	return fQLongCMSLC;
	295	}
	296	/************************************************************************/
	297	Double_t AliHBTPair::GetKt()
	298	{
58ee8590	299	//calculates the evarage momentum of the pair
1b446896	300	if(fKtNotCalc)
	301	{
	302	CalculateSums();
	303	fKt = 0.5*TMath::Hypot(fPxSum,fPySum);
	304	fKtNotCalc = kFALSE;
	305	}
	306	return fKt;
	307	}
	308	/************************************************************************/
	309
	310	Double_t AliHBTPair::GetKStar()
	311	{
58ee8590	312	//calculates invariant velocity difference
1b446896	313	if (fKStarNotCalc)
1b446896	314	{
1b446896	315	CalculateSums();
1b446896	316
d012b7d0	317	Double_t ptrans = fPxSumfPxSum + fPySumfPySum;
	318	Double_t mtrans = fESumfESum - fPzSumfPzSum;
	319	Double_t pinv = TMath::Sqrt(mtrans - ptrans);
1b446896	320
d012b7d0	321	Double_t q = (fPart1->GetMass()fPart1->GetMass() - fPart2->GetMass()fPart2->GetMass())/pinv;
1b446896	322
	323	CalculateQInvL();
	324
d012b7d0	325	q = q*q - fQInvL;
d012b7d0	326	if ( q < 0)
4453ae67	327	{
d012b7d0	328	Info("GetKStar","q = %f",q);
4453ae67	329	fPart1->Print();
4453ae67	330	fPart2->Print();
d012b7d0	331	q = TMath::Abs(q);
4453ae67	332	}
4453ae67	333
d012b7d0	334	q = TMath::Sqrt(q);
d012b7d0	335	fKStar = q/2.;
1b446896	336	fKStarNotCalc = kFALSE;
	337	}
	338	return fKStar;
	339	}
	340	/************************************************************************/
	341
	342	Double_t AliHBTPair::GetQInv()
	343	{
951aadb9	344	//returns Qinv
951aadb9	345	//warning for non-id particles you want to use 2*KStar
1b446896	346	if(fQInvNotCalc)
	347	{
	348	CalculateQInvL();
30025bb4	349	fQInv = TMath::Sqrt(TMath::Abs(fQInvL));
1b446896	350	fQInvNotCalc = kFALSE;
1b446896	351	}
1b446896	352	return fQInv;
1b446896	353	}
30025bb4	354	/************************************************************************/
951aadb9	355
	356	Double_t AliHBTPair::GetGammaToCMSLC()
	357	{
58ee8590	358	//calculates gamma factor of the boost to CMSLC
951aadb9	359	if(fGammaCMSLCNotCalc)
	360	{
	361	CalculateSums();
	362	Double_t beta = fPzSum/fESum;
	363	fGammaCMSLC = 1.0/TMath::Sqrt(1.0 - beta*beta);
	364	fGammaCMSLCNotCalc = kFALSE;
	365	}
	366	return fGammaCMSLC;
	367	}
30025bb4	368	/************************************************************************/
30025bb4	369
951aadb9	370	Double_t AliHBTPair::GetMt()
951aadb9	371	{
58ee8590	372	//Calculates transverse mass of the pair
951aadb9	373	if (fMtNotCalc)
	374	{
	375	CalculateSums();
	376	fMt = TMath::Sqrt(fESumfESum - fPzSumfPzSum);
	377	fMtNotCalc = kFALSE;
	378	}
	379	return fMt;
	380	}
30025bb4	381	/************************************************************************/
1b446896	382
dd82cadc	383	Double_t AliHBTPair::GetWeight()
47d9a058	384	{
58ee8590	385	//returns and buffers weight for this pair
dd82cadc	386	if (fWeightNotCalc)
47d9a058	387	{
dd82cadc	388	fWeight = AliHBTWeights::Weight(this);
dd82cadc	389	fWeightNotCalc = kFALSE;
47d9a058	390	}
dd82cadc	391	return fWeight;
47d9a058	392	}