#include "AliHBTMonDistributionFctns.h"
-
-/******************************************************************/
-/******************************************************************/
+//______________________________________________________________
+////////////////////////////////////////////////////////////////
+//
+// class AliHBTMonPxDistributionFctn;
+// class AliHBTMonPxDistributionVsPtFctn;
+// class AliHBTMonPyDistributionFctn;
+// class AliHBTMonPyDistributionVsPtFctn;
+// class AliHBTMonPzDistributionFctn;
+// class AliHBTMonPzDistributionVsPtFctn;
+// class AliHBTMonPDistributionFctn;
+// class AliHBTMonPDistributionVsPtFctn;
+// class AliHBTMonPtDistributionFctn;
+// class AliHBTMonVxDistributionFctn;
+// class AliHBTMonVyDistributionFctn;
+// class AliHBTMonVzDistributionFctn;
+// class AliHBTMonRDistributionFctn;
+// class AliHBTMonVyDistributionVsVxFctn;
+// class AliHBTMonRtDistributionVsVzFctn;
+//
+// added by Zbigniew.Chajecki@cern.ch
+// this classes create distribution functions of particle momentum
+//
+/////////////////////////////////////////////////////////////////
/******************************************************************/
ClassImp(AliHBTMonPxDistributionFctn)
AliHBTMonPxDistributionFctn::AliHBTMonPxDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Px","Px");
}
AliHBTMonPyDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Py","Py");
}
AliHBTMonPzDistributionFctn::AliHBTMonPzDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Pz","Pz");
}
(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("P","P");
}
(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Pt","Pt");
}
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
+ //constructor
Rename("PxDistVsPt","Px vs. Pt");
}
/******************************************************************/
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
- Rename("PyDistVsPt","Py vs. Pt");
+ //constructor
+ Rename("PyDistVsPt","Py vs. Pt");
}
/******************************************************************/
ClassImp( AliHBTMonPzDistributionVsPtFctn )
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
+ //constructor
Rename("PzDistVsPt","Pz vs. Pt");
}
/******************************************************************/
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
- Rename("PDistVsPt","P vs. Pt");
+ //constructor
+ Rename("PDistVsPt","P vs. Pt");
}
/******************************************************************/
AliHBTMonPhiDistributionFctn::AliHBTMonPhiDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Phi","Phi");
}
/******************************************************************/
AliHBTMonThetaDistributionFctn::AliHBTMonThetaDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Theta","Theta");
}
/******************************************************************/
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
+ //constructor
Rename("PhiDistVsPt","Phi vs. Pt");
}
/******************************************************************/
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
- Rename("ThetaDistVsPt","Theta vs. Pt");
+ //constructor
+ Rename("ThetaDistVsPt","Theta vs. Pt");
}
/******************************************************************/
AliHBTMonVxDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Vx","X of Vertex");
}
/******************************************************************/
AliHBTMonVzDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
+ //constructor
Rename("Vz","Z of Vertex");
}
/******************************************************************/
AliHBTMonRDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
{
- Rename("VertexDistanceFromCenter","Distance of Particle Vertex From Center");
+ //constructor
+ Rename("VertexDistanceFromCenter","Distance of Particle Vertex From Center");
}
/******************************************************************/
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
- Rename("VyDistVsVx","Vrtex Y position versus X vertex position");
+ //constructor
+ Rename("VyDistVsVx","Vrtex Y position versus X vertex position");
}
/******************************************************************/
Int_t nYbins, Double_t maxYval, Double_t minYval):
AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
{
- Rename("RDistVsVz","Distance of vertex position from center in trensverse plane versus Z vertex position");
+ //constructor
+ Rename("RDistVsVz","Distance of vertex position from center in trensverse plane versus Z vertex position");
}
/******************************************************************/
-#ifndef ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
-#define ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
-
+#ifndef ALIHBTMONDISTRIBUTIONFCTNS_H
+#define ALIHBTMONDISTRIBUTIONFCTNS_H
+//______________________________________________________________
+////////////////////////////////////////////////////////////////
+//
+// class AliHBTMonPxDistributionFctn;
+// class AliHBTMonPxDistributionVsPtFctn;
+// class AliHBTMonPyDistributionFctn;
+// class AliHBTMonPyDistributionVsPtFctn;
+// class AliHBTMonPzDistributionFctn;
+// class AliHBTMonPzDistributionVsPtFctn;
+// class AliHBTMonPDistributionFctn;
+// class AliHBTMonPDistributionVsPtFctn;
+// class AliHBTMonPtDistributionFctn;
+// class AliHBTMonVxDistributionFctn;
+// class AliHBTMonVyDistributionFctn;
+// class AliHBTMonVzDistributionFctn;
+// class AliHBTMonRDistributionFctn;
+// class AliHBTMonVyDistributionVsVxFctn;
+// class AliHBTMonRtDistributionVsVzFctn;
+//
// added by Zbigniew.Chajecki@cern.ch
-// this classes create distribution functions of particle momentum
+// this classes create distribution functions of particle momentum
+//
+/////////////////////////////////////////////////////////////////
class AliHBTMonPxDistributionFctn;
class AliHBTMonPxDistributionVsPtFctn;
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->Px();}
- public:
- ClassDef(AliHBTMonPxDistributionFctn,1)
-
+ ClassDef(AliHBTMonPxDistributionFctn,1)
};
/*************************************************************************************/
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->Py();}
- public:
- ClassDef(AliHBTMonPyDistributionFctn,1)
-
+ ClassDef(AliHBTMonPyDistributionFctn,1)
};
/*************************************************************************************/
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->Pz();}
- public:
- ClassDef(AliHBTMonPzDistributionFctn,1)
+ ClassDef(AliHBTMonPzDistributionFctn,1)
};
/*************************************************************************************/
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->P();}
- public:
- ClassDef(AliHBTMonPDistributionFctn,1)
+ ClassDef(AliHBTMonPDistributionFctn,1)
};
/*************************************************************************************/
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->Pt();}
- public:
- ClassDef(AliHBTMonPtDistributionFctn,1)
-
+ ClassDef(AliHBTMonPtDistributionFctn,1)
};
/***********************************************************************/
void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
{
- x = partparticle->Pt();
- y = partparticle->Px();
+ x = partparticle->Pt();
+ y = partparticle->Px();
}
TH1* GetResult(){return fResult;}
- protected:
- private:
- public:
- ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
+ ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
};
/***********************************************************************/
x = partparticle->Pt();
y = partparticle->Py();
}
- TH1* GetResult(){return fResult;}
- protected:
- private:
- public:
- ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
+ TH1* GetResult(){return fResult;}
+ ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
};
/***********************************************************************/
class AliHBTMonPzDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
y = partparticle->Pz();
}
TH1* GetResult(){return fResult;}
- protected:
- private:
- public:
- ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
+ ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
};
/***********************************************************************/
y = partparticle->P();
}
TH1* GetResult(){return fResult;}
- protected:
- private:
- public:
- ClassDef(AliHBTMonPDistributionVsPtFctn,1)
+ ClassDef(AliHBTMonPDistributionVsPtFctn,1)
};
/***********************************************************************/
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->Phi();}
- public:
- ClassDef(AliHBTMonPhiDistributionFctn,1)
-
+ ClassDef(AliHBTMonPhiDistributionFctn,1)
};
/***********************************************************************/
TH1* GetResult(){return fResult;}
protected:
Double_t GetValue(AliHBTParticle * particle) { return particle->Theta();}
- public:
- ClassDef(AliHBTMonThetaDistributionFctn,1)
+ ClassDef(AliHBTMonThetaDistributionFctn,1)
};
/***********************************************************************/
x = partparticle->Pt();
y = partparticle->Phi();
}
- TH1* GetResult(){return fResult;}
- protected:
- private:
- public:
- ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
+ TH1* GetResult(){return fResult;}
+ ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
};
/***********************************************************************/
y = partparticle->Theta();
}
TH1* GetResult(){return fResult;}
- protected:
- private:
ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
};
y = partparticle->Vy();
}
TH1* GetResult(){return fResult;}
- protected:
- private:
ClassDef(AliHBTMonVyDistributionVsVxFctn,1)
};
y = TMath::Hypot(partparticle->Vx(),partparticle->Vy());
}
TH1* GetResult(){return fResult;}
- protected:
- private:
ClassDef(AliHBTMonRtDistributionVsVzFctn,1)
};
#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"
/************************************************************************/
Double_t AliHBTPair::GetQOutCMSLC()
{
+ //caculates Qout in Center Of Mass Longitudionally Co-Moving
if(fQOutCMSLCNotCalc)
{
CalculateSums();
/************************************************************************/
Double_t AliHBTPair::GetQLongCMSLC()
{
+ //return Q Long in Central Of Mass System in Longitudialy Comoving Frame
if (fQLongCMSLCNotCalc)
{
CalculateSums();
/************************************************************************/
Double_t AliHBTPair::GetKt()
{
+ //calculates the evarage momentum of the pair
if(fKtNotCalc)
{
CalculateSums();
Double_t AliHBTPair::GetKStar()
{
+ //calculates invariant velocity difference
if (fKStarNotCalc)
{
CalculateSums();
Double_t AliHBTPair::GetGammaToCMSLC()
{
+ //calculates gamma factor of the boost to CMSLC
if(fGammaCMSLCNotCalc)
{
CalculateSums();
Double_t AliHBTPair::GetMt()
{
+ //Calculates transverse mass of the pair
if (fMtNotCalc)
{
CalculateSums();
Double_t AliHBTPair::GetWeight()
{
+ //returns and buffers weight for this pair
if (fWeightNotCalc)
{
fWeight = AliHBTWeights::Weight(this);
#ifndef ALIHBTPAIR_H
#define 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 <TObject.h>
#include "AliHBTParticle.h"
-//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
+
class AliHBTPair: public TObject
{
Double_t fQLong;//Q Long
Double_t fMt;//Transverse coordinate of Inv. Mass
- Bool_t fMtNotCalc;//flag indicating if Mt is calculated
+ Bool_t fMtNotCalc;//flag indicating if Mt is calculated for current pair
Double_t fInvMassSqr;//squre of invariant mass
Bool_t fMassSqrNotCalc; //
void CalculateInvMassSqr();
- Double_t fQInvL;
- Bool_t fQInvLNotCalc;
+ Double_t fQInvL; //Qinv in longitudional direction
+ Bool_t fQInvLNotCalc;//flag indicating if fQInvL is calculated for current pair
void CalculateQInvL();
- Double_t fWeight;
- Bool_t fWeightNotCalc;
-
- Double_t fPxSum;
- Double_t fPySum;
- Double_t fPzSum;
- Double_t fESum;
- Bool_t fSumsNotCalc;
+ Double_t fWeight;//Value of the weight
+ Bool_t fWeightNotCalc;//flag indicating if fWeight is calculated for current pair
+
+ Double_t fPxSum;// Sum of Px momenta
+ Double_t fPySum;// Sum of Py momenta
+ Double_t fPzSum;// Sum of Pz momenta
+ Double_t fESum;// Sum of energies
+ Bool_t fSumsNotCalc;//flag indicating if fPxSum,fPxSum,fPxSum and fESum is calculated for current pair
void CalculateSums();
- Double_t fPxDiff;
- Double_t fPyDiff;
- Double_t fPzDiff;
- Double_t fEDiff;
- Bool_t fDiffsNotCalc;
+ Double_t fPxDiff;// Difference of Px momenta
+ Double_t fPyDiff;// Difference of Px momenta
+ Double_t fPzDiff;// Difference of Px momenta
+ Double_t fEDiff;// Difference of Px momenta
+ Bool_t fDiffsNotCalc;//flag indicating if fPxDiff,fPxDiff,fPxDiff and fEDiff is calculated for current pair
void CalculateDiffs();
- Double_t fGammaCMSLC;
- Bool_t fGammaCMSLCNotCalc;
+ Double_t fGammaCMSLC;//gamma of boost in CMSLC
+ Bool_t fGammaCMSLCNotCalc;//flag indicating if fGammaCMSLC is calculated for current pair
/***************************************************/
void CalculateBase();
- Bool_t fChanged;
+ Bool_t fChanged;//flag indicating if object has been changed
private:
- public:
ClassDef(AliHBTPair,1)
};
/****************************************************************/
inline
void AliHBTPair::CalculateInvMassSqr()
{
+ //calculates square of qinv
if (fMassSqrNotCalc)
{
CalculateSums();
inline
void AliHBTPair::CalculateSums()
{
+ //calculates momenta and energy sums
if(fSumsNotCalc)
{
fPxSum = fPart1->Px()+fPart2->Px();
inline
void AliHBTPair::CalculateDiffs()
{
+ //calculates momenta and energy differences
if(fDiffsNotCalc)
{
fPxDiff = fPart1->Px()-fPart2->Px();
inline
Double_t AliHBTPair::GetDeltaP() //return difference of momenta
{
+ //returns difference of momenta
CalculateDiffs();
return TMath::Sqrt(fPxDiff*fPxDiff + fPyDiff*fPyDiff + fPzDiff*fPzDiff);
}
inline
Double_t AliHBTPair::GetDeltaPx()
{
+ //returns difference of Pz
CalculateDiffs();
return fPxDiff;
}
inline
Double_t AliHBTPair::GetDeltaPy()
{
+ //returns difference of Py
CalculateDiffs();
return fPyDiff;
}
inline
Double_t AliHBTPair::GetDeltaPz()
{
+ //returns difference of Pz
CalculateDiffs();
return fPzDiff;
}
y = partpair->GetKt() - trackpair->GetKt();
x = partpair->GetQInv();
}
- protected:
- private:
- ClassDef(AliHBTKtResolVsQInvFctn,1)
+ ClassDef(AliHBTKtResolVsQInvFctn,1)
};
y = partpair->GetQInv() - trackpair->GetQInv();
x = partpair->GetQInv();
}
- protected:
- private:
- ClassDef(AliHBTQInvResolVsQInvFctn,1)
+ ClassDef(AliHBTQInvResolVsQInvFctn,1)
};
if (tqout < 0.0) y = -y;
x = partpair->GetQInv();
}
- protected:
- private:
- ClassDef(AliHBTQOutResolVsQInvFctn,1)
+ ClassDef(AliHBTQOutResolVsQInvFctn,1)
};
/***********************************************************************/
x = partpair->GetQInv();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQSideResolVsQInvFctn,1)
+ ClassDef(AliHBTQSideResolVsQInvFctn,1)
};
/***********************************************************************/
x = partpair->GetQInv();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQLongResolVsQInvFctn,1)
+ ClassDef(AliHBTQLongResolVsQInvFctn,1)
};
/***********************************************************************/
x = partpair->GetKt();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQInvResolVsKtFctn,1)
+ ClassDef(AliHBTQInvResolVsKtFctn,1)
};
/***********************************************************************/
/***********************************************************************/
if (trackpair->GetQOutCMSLC() < 0.0) y = -y;
x = partpair->GetKt();
}
- protected:
- private:
- ClassDef(AliHBTQOutResolVsKtFctn,1)
+ ClassDef(AliHBTQOutResolVsKtFctn,1)
};
/***********************************************************************/
/***********************************************************************/
if (trackpair->GetQSideCMSLC() < 0.0) y = -y;
x = partpair->GetKt();
}
- protected:
- private:
- ClassDef(AliHBTQSideResolVsKtFctn,1)
+ ClassDef(AliHBTQSideResolVsKtFctn,1)
};
/***********************************************************************/
/***********************************************************************/
x = partpair->GetKt();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQLongResolVsKtFctn,1)
+ ClassDef(AliHBTQLongResolVsKtFctn,1)
};
/***********************************************************************/
/***********************************************************************/
y = x - trackpair->GetQOutCMSLC();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQOutResolVsQOutFctn,1)
+ ClassDef(AliHBTQOutResolVsQOutFctn,1)
};
/***********************************************************************/
y = x - trackpair->GetQSideCMSLC();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQSideResolVsQSideFctn,1)
+ ClassDef(AliHBTQSideResolVsQSideFctn,1)
};
y = x - trackpair->GetQLongCMSLC();
}
TH1* GetResult(){return fNumerator;}
- protected:
- private:
- ClassDef(AliHBTQLongResolVsQLongFctn,1)
+ ClassDef(AliHBTQLongResolVsQLongFctn,1)
};
y = partTheta - trackTheta;
x = partpair->GetQInv();
}
- protected:
- private:
- ClassDef(AliHBTPairThetaResolVsQInvFctn,1)
+ ClassDef(AliHBTPairThetaResolVsQInvFctn,1)
};
/***********************************************************************/
if (trackTheta < 0.0) y = -y;
x = trackTheta;
}
- protected:
- private:
- ClassDef(AliHBTPairThetaResolVsPairThetaFctn,1)
+ ClassDef(AliHBTPairThetaResolVsPairThetaFctn,1)
};
y = partPhi - trackPhi;
x = partpair->GetQInv();
}
- protected:
- private:
- ClassDef(AliHBTPairPhiResolVsQInvFctn,1)
+ ClassDef(AliHBTPairPhiResolVsQInvFctn,1)
};
/***********************************************************************/
y = partTheta - trackTheta;
x = partpair->GetKt();
}
- protected:
- private:
- ClassDef(AliHBTPairThetaResolVsKtFctn,1)
+ ClassDef(AliHBTPairThetaResolVsKtFctn,1)
};
/***********************************************************************/
y = partPhi - trackPhi;
x = partpair->GetKt();
}
- protected:
- private:
- ClassDef(AliHBTPairPhiResolVsKtFctn,1)
+ ClassDef(AliHBTPairPhiResolVsKtFctn,1)
};
#endif
y = partPhi - trackPhi;
x = trackPhi;
}
- protected:
- private:
- ClassDef(AliHBTPairPhiResolVsPairPhiFctn,1)
+ ClassDef(AliHBTPairPhiResolVsPairPhiFctn,1)
};
-
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff