--- /dev/null
+#include "AliHBTMonDistributionFctns.h"
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+ClassImp(AliHBTMonPxDistributionFctn)
+
+AliHBTMonPxDistributionFctn::
+AliHBTMonPxDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("Px","Px");
+}
+
+/******************************************************************/
+
+ClassImp(AliHBTMonPyDistributionFctn)
+
+AliHBTMonPyDistributionFctn::
+AliHBTMonPyDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("Py","Py");
+}
+
+/******************************************************************/
+
+ClassImp(AliHBTMonPzDistributionFctn)
+
+AliHBTMonPzDistributionFctn::
+AliHBTMonPzDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("Pz","Pz");
+}
+
+/******************************************************************/
+
+ClassImp(AliHBTMonPDistributionFctn)
+
+AliHBTMonPDistributionFctn::
+AliHBTMonPDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("P","P");
+}
+
+
+/******************************************************************/
+
+ClassImp(AliHBTMonPtDistributionFctn)
+
+AliHBTMonPtDistributionFctn::
+AliHBTMonPtDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("Pt","Pt");
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonPxDistributionVsPtFctn )
+
+AliHBTMonPxDistributionVsPtFctn::
+AliHBTMonPxDistributionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PxDistVsPt","Px vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPyDistributionVsPtFctn )
+
+AliHBTMonPyDistributionVsPtFctn::
+AliHBTMonPyDistributionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PyDistVsPt","Py vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPzDistributionVsPtFctn )
+
+AliHBTMonPzDistributionVsPtFctn::
+AliHBTMonPzDistributionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PzDistVsPt","Pz vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPDistributionVsPtFctn )
+
+AliHBTMonPDistributionVsPtFctn::
+AliHBTMonPDistributionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PDistVsPt","P vs. Pt");
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp(AliHBTMonPhiDistributionFctn)
+
+AliHBTMonPhiDistributionFctn::
+AliHBTMonPhiDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("Phi","Phi");
+}
+/******************************************************************/
+ClassImp(AliHBTMonThetaDistributionFctn)
+
+AliHBTMonThetaDistributionFctn::
+AliHBTMonThetaDistributionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonOneParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("Theta","Theta");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPhiDistributionVsPtFctn )
+
+AliHBTMonPhiDistributionVsPtFctn::
+AliHBTMonPhiDistributionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PhiDistVsPt","Phi vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonThetaDistributionVsPtFctn )
+
+AliHBTMonThetaDistributionVsPtFctn::
+AliHBTMonThetaDistributionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonOneParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("ThetaDistVsPt","Theta vs. Pt");
+}
+/******************************************************************/
+/******************************************************************/
+
+
+
+
--- /dev/null
+#ifndef ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
+#define ALIHBTMONPXDISTRIBUTIONVSPTFCTN_H
+
+// added by Zbigniew.Chajecki@cern.ch
+// this classes create distribution functions of particle momentum
+
+class AliHBTMonPxDistributionFctn;
+class AliHBTMonPxDistributionVsPtFctn;
+class AliHBTMonPyDistributionFctn;
+class AliHBTMonPyDistributionVsPtFctn;
+class AliHBTMonPzDistributionFctn;
+class AliHBTMonPzDistributionVsPtFctn;
+class AliHBTMonPDistributionFctn;
+class AliHBTMonPDistributionVsPtFctn;
+class AliHBTMonPtDistributionFctn;
+
+#include "AliHBTMonitorFunction.h"
+/***********************************************************************/
+/***********************************************************************/
+/*************************************************************************************/
+
+class AliHBTMonPxDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonPxDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
+ virtual ~AliHBTMonPxDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->Px();}
+ public:
+ ClassDef(AliHBTMonPxDistributionFctn,1)
+
+};
+/*************************************************************************************/
+
+class AliHBTMonPyDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonPyDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
+ virtual ~AliHBTMonPyDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->Py();}
+ public:
+ ClassDef(AliHBTMonPyDistributionFctn,1)
+
+};
+/*************************************************************************************/
+
+class AliHBTMonPzDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonPzDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = -1.4);
+ virtual ~AliHBTMonPzDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->Pz();}
+ public:
+ ClassDef(AliHBTMonPzDistributionFctn,1)
+
+};
+/*************************************************************************************/
+
+class AliHBTMonPDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonPDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
+ virtual ~AliHBTMonPDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->P();}
+ public:
+ ClassDef(AliHBTMonPDistributionFctn,1)
+
+};
+/*************************************************************************************/
+
+class AliHBTMonPtDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonPtDistributionFctn(Int_t nbins = 200, Double_t maxXval = 1.4, Double_t minXval = 0.0);
+ virtual ~AliHBTMonPtDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->Pt();}
+ public:
+ ClassDef(AliHBTMonPtDistributionFctn,1)
+
+};
+
+/***********************************************************************/
+class AliHBTMonPxDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
+ {
+ public:
+ AliHBTMonPxDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
+ virtual ~AliHBTMonPxDistributionVsPtFctn(){}
+
+ void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Px();
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPxDistributionVsPtFctn,1)
+ };
+
+/***********************************************************************/
+class AliHBTMonPyDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
+ {
+ public:
+ AliHBTMonPyDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
+ virtual ~AliHBTMonPyDistributionVsPtFctn(){}
+
+ void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Py();
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPyDistributionVsPtFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPzDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
+ {
+ public:
+ AliHBTMonPzDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
+ virtual ~AliHBTMonPzDistributionVsPtFctn(){}
+
+ void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Pz();
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPzDistributionVsPtFctn,1)
+ };
+
+/***********************************************************************/
+class AliHBTMonPDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
+ {
+ public:
+ AliHBTMonPDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 1.4, Double_t minYval =-1.4);
+ virtual ~AliHBTMonPDistributionVsPtFctn(){}
+
+ void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->P();
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPDistributionVsPtFctn,1)
+ };
+
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+
+class AliHBTMonPhiDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonPhiDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
+ virtual ~AliHBTMonPhiDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->Phi();}
+ public:
+ ClassDef(AliHBTMonPhiDistributionFctn,1)
+
+};
+
+/***********************************************************************/
+class AliHBTMonThetaDistributionFctn: public AliHBTMonOneParticleFctn1D
+{
+ public:
+ AliHBTMonThetaDistributionFctn(Int_t nbins = 200, Double_t maxXval = 3.14, Double_t minXval = 0.0);
+ virtual ~AliHBTMonThetaDistributionFctn(){};
+ TH1* GetResult(){return fResult;}
+ protected:
+ Double_t GetValue(AliHBTParticle * particle) { return particle->Theta();}
+ public:
+ ClassDef(AliHBTMonThetaDistributionFctn,1)
+
+};
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTMonPhiDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
+ {
+ public:
+ AliHBTMonPhiDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
+ virtual ~AliHBTMonPhiDistributionVsPtFctn(){}
+
+ void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Phi();
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPhiDistributionVsPtFctn,1)
+ };
+
+/***********************************************************************/
+class AliHBTMonThetaDistributionVsPtFctn: public AliHBTMonOneParticleFctn2D
+ {
+ public:
+ AliHBTMonThetaDistributionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 3.14, Double_t minYval =0.0);
+ virtual ~AliHBTMonThetaDistributionVsPtFctn(){}
+
+ void GetValues(AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Theta();
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonThetaDistributionVsPtFctn,1)
+ };
+
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+
+#endif
--- /dev/null
+#include "AliHBTMonResolutionFctns.h"
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+ClassImp(AliHBTMonPxResolutionFctn)
+
+AliHBTMonPxResolutionFctn::
+AliHBTMonPxResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("PxResolution","PxResolution");
+}
+/******************************************************************/
+
+ClassImp(AliHBTMonPyResolutionFctn)
+
+AliHBTMonPyResolutionFctn::
+AliHBTMonPyResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("PyResolution","PyResolution");
+}
+/******************************************************************/
+
+ClassImp(AliHBTMonPzResolutionFctn)
+
+AliHBTMonPzResolutionFctn::
+AliHBTMonPzResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("PzResolution","PzResolution");
+}
+/******************************************************************/
+
+ClassImp(AliHBTMonPResolutionFctn)
+
+AliHBTMonPResolutionFctn::
+AliHBTMonPResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("PResolution","PResolution");
+}
+/******************************************************************/
+
+ClassImp(AliHBTMonPtResolutionFctn)
+
+AliHBTMonPtResolutionFctn::
+AliHBTMonPtResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("PtResolution","PtResolution");
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonPxResolutionVsPtFctn )
+
+AliHBTMonPxResolutionVsPtFctn::
+AliHBTMonPxResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PxResolVsPt","Px resolution vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPyResolutionVsPtFctn )
+
+AliHBTMonPyResolutionVsPtFctn::
+AliHBTMonPyResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PyResolVsPt","Py resolution vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPzResolutionVsPtFctn )
+
+AliHBTMonPzResolutionVsPtFctn::
+AliHBTMonPzResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PzResolVsPt","Pz resolution vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPResolutionVsPtFctn )
+
+AliHBTMonPResolutionVsPtFctn::
+AliHBTMonPResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PResolVsPt","P resolution vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonPtResolutionVsPtFctn )
+
+AliHBTMonPtResolutionVsPtFctn::
+AliHBTMonPtResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PtResolVsPt","Pt resolution vs. Pt");
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp(AliHBTMonPhiResolutionFctn)
+
+AliHBTMonPhiResolutionFctn::
+AliHBTMonPhiResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("PhiResolution","PhiResolution");
+}
+/******************************************************************/
+ClassImp(AliHBTMonThetaResolutionFctn)
+
+AliHBTMonThetaResolutionFctn::
+AliHBTMonThetaResolutionFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval)
+{
+ Rename("ThetaResolution","ThetaResolution");
+}
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonPhiResolutionVsPtFctn )
+
+AliHBTMonPhiResolutionVsPtFctn::
+AliHBTMonPhiResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("PhiResolVsPt","Phi resolution vs. Pt");
+}
+/******************************************************************/
+ClassImp( AliHBTMonThetaResolutionVsPtFctn )
+
+AliHBTMonThetaResolutionVsPtFctn::
+AliHBTMonThetaResolutionVsPtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTMonTwoParticleFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("ThetaResolVsPt","Theta resolution vs. Pt");
+}
+/******************************************************************/
+
+
+
+
--- /dev/null
+#ifndef ALIMONPXRESOLUTIONVSPTFCTN_H
+#define ALIMONPXRESOLUTIONVSPTFCTN_H
+
+// added by Zbigniew.Chajecki@cern.ch
+// this classes create resolution functions of particle momentum
+
+class AliHBTMonPxResolutionFctn;
+class AliHBTMonPyResolutionFctn;
+class AliHBTMonPzResolutionFctn;
+class AliHBTMonPResolutionFctn;
+class AliHBTMonPtResolutionFctn;
+class AliHBTMonPhiResolutionFctn;
+class AliHBTMonThetaResolutionFctn;
+
+class AliHBTMonPxResolutionVsPtFctn;
+class AliHBTMonPyResolutionVsPtFctn;
+class AliHBTMonPzResolutionVsPtFctn;
+class AliHBTMonPResolutionVsPtFctn;
+class AliHBTMonPtResolutionVsPtFctn;
+class AliHBTMonPhiResolutionVsPtFctn;
+class AliHBTMonThetaResolutionVsPtFctn;
+
+
+#include "AliHBTMonitorFunction.h"
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTMonPxResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonPxResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonPxResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->Px()-trackparticle->Px()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPxResolutionFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPyResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonPyResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonPyResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->Py()-trackparticle->Py()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPyResolutionFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPzResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonPzResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonPzResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->Pz()-trackparticle->Pz()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPzResolutionFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonPResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonPResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->P()-trackparticle->P()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPResolutionFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPtResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonPtResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonPtResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->Pt()-trackparticle->Pt()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPtResolutionFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTMonPxResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonPxResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonPxResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Px()-trackparticle->Px();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPxResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPyResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonPyResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonPyResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Py()-trackparticle->Py();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPyResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPzResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonPzResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonPzResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Pz()-trackparticle->Pz();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPzResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonPResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonPResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->P()-trackparticle->P();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonPtResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonPtResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonPtResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Pt()-trackparticle->Pt();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPtResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTMonPhiResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonPhiResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonPhiResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->Phi()-trackparticle->Phi()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPhiResolutionFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonThetaResolutionFctn: public AliHBTMonTwoParticleFctn1D
+ {
+ public:
+ AliHBTMonThetaResolutionFctn(Int_t nbins = 200, Double_t maxXval = 0.05, Double_t minXval = -0.05);
+ virtual ~AliHBTMonThetaResolutionFctn(){}
+
+ Double_t GetValue(AliHBTParticle * trackparticle,AliHBTParticle * partparticle)
+ {
+ return (partparticle->Theta()-trackparticle->Theta()) ;
+ }
+ TH1* GetResult(){return fResult;}
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonThetaResolutionFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTMonPhiResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonPhiResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonPhiResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Phi()-trackparticle->Phi();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonPhiResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+class AliHBTMonThetaResolutionVsPtFctn: public AliHBTMonTwoParticleFctn2D
+ {
+ public:
+ AliHBTMonThetaResolutionVsPtFctn(Int_t nXbins = 200, Double_t maxXval = 1.4, Double_t minXval = -0.1,
+ Int_t nYbins = 200, Double_t maxYval = 0.05, Double_t minYval =-0.05);
+ virtual ~AliHBTMonThetaResolutionVsPtFctn(){}
+ TH1* GetResult(){return fResult;}
+ void GetValues(AliHBTParticle* trackparticle, AliHBTParticle* partparticle, Double_t& x, Double_t& y)
+ {
+ x = partparticle->Pt();
+ y = partparticle->Theta()-trackparticle->Theta();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTMonThetaResolutionVsPtFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+
+#endif
--- /dev/null
+#include "AliHBTMonitorFunction.h"
+/******************************************************************/
+/*
+Base classes for monitor functions
+
+ monitor function
+ / \
+ / \
+ / \
+ / \
+ / \
+ / \
+ / \
+ one particle two particle
+ / | \ / | \
+ / | \ / | \
+ 1D 2D 3D 1D 2D 3D
+
+Zbigniew.Chajecki@cern.ch
+
+*/
+/******************************************************************/
+/******************************************************************/
+
+#include <iostream.h>
+ClassImp( AliHBTMonitorFunction )
+
+AliHBTMonitorFunction::AliHBTMonitorFunction()
+{
+ fParticleCut = new AliHBTEmptyParticleCut(); //dummy cut
+}
+/******************************************************************/
+AliHBTMonitorFunction::AliHBTMonitorFunction(const char* name,const char* title):TNamed(name,title)
+{
+ fParticleCut = new AliHBTEmptyParticleCut(); //dummy cut
+}
+/******************************************************************/
+
+AliHBTMonitorFunction::~AliHBTMonitorFunction()
+ {
+ if (fParticleCut) delete fParticleCut;
+ }
+/******************************************************************/
+
+void AliHBTMonitorFunction::
+Write()
+ {
+ if (GetResult()) GetResult()->Write();
+ }
+/******************************************************************/
+
+/******************************************************************/
+void AliHBTMonitorFunction::SetParticleCut(AliHBTParticleCut* cut)
+{
+//Sets new Particle Cut. Old one is deleted
+//Note that it is created new object instead of simple pointer set
+//I do not want to have pointer
+//to object created somewhere else
+//because in that case I could not believe that
+//it would always exist (sb could delete it)
+//so we have always own copy
+
+ if(!cut)
+ {
+ Error("AliHBTMonitorFunction::SetParticleCut","argument is NULL");
+ return;
+ }
+ delete fParticleCut;
+ fParticleCut = (AliHBTParticleCut*)cut->Clone();
+
+}
+
+/******************************************************************/
+
+void AliHBTMonitorFunction::
+Rename(const Char_t * name)
+ {
+ //renames the function and histograms
+ SetName(name);
+ SetTitle(name);
+
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+ GetResult()->SetName(numstr.Data());
+ GetResult()->SetTitle(numstr.Data());
+
+
+ }
+
+void AliHBTMonitorFunction::
+Rename(const Char_t * name, const Char_t * title)
+ {
+ //renames and retitle the function and histograms
+
+ SetName(name);
+ SetTitle(title);
+
+ TString numstrn = fName + " Result"; //name of the
+ //result histogram
+
+ TString numstrt = fTitle + " Result"; //title of the
+ //result histogram
+
+
+ GetResult()->SetName(numstrn.Data());
+ GetResult()->SetTitle(numstrt.Data());
+
+ }
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonOneParticleFctn ) //z.ch.
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonTwoParticleFctn ) //z.ch.
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonOneParticleFctn1D )
+AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D()
+ {
+ fResult = 0x0;
+ }
+
+AliHBTMonOneParticleFctn1D::
+AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval)
+ {
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
+ }
+
+AliHBTMonOneParticleFctn1D::
+AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
+ Int_t nbins, Double_t maxXval, Double_t minXval)
+ :AliHBTMonOneParticleFctn(name,title)
+{
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
+}
+/******************************************************************/
+AliHBTMonOneParticleFctn1D::~AliHBTMonOneParticleFctn1D()
+{
+ delete fResult;
+}
+/******************************************************************/
+
+void AliHBTMonOneParticleFctn1D::ProcessSameEventParticles(AliHBTParticle* particle)
+{
+ //Fills the result
+ particle = CheckParticle(particle);
+ if(particle) fResult->Fill(GetValue(particle));
+}
+/******************************************************************/
+/******************************************************************/
+
+ClassImp( AliHBTMonOneParticleFctn2D )
+
+AliHBTMonOneParticleFctn2D::
+AliHBTMonOneParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval ,
+ Int_t nYbins, Double_t maxYval, Double_t minYval)
+
+{
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH2D(numstr.Data(),numstr.Data(),
+ nXbins,minXval,maxXval,
+ nYbins,minYval,maxYval);
+
+}
+
+AliHBTMonOneParticleFctn2D::~AliHBTMonOneParticleFctn2D()
+{
+ delete fResult;
+}
+void AliHBTMonOneParticleFctn2D::ProcessSameEventParticles(AliHBTParticle* particle)
+{
+ particle = CheckParticle(particle);
+ if(particle)
+ {
+ Double_t x,y;
+ GetValues(particle,x,y);
+ fResult->Fill(x,y);
+ }
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+ClassImp( AliHBTMonOneParticleFctn3D)
+
+AliHBTMonOneParticleFctn3D::
+AliHBTMonOneParticleFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval,
+ Int_t nZbins, Double_t maxZval, Double_t minZval)
+
+{
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH3D(numstr.Data(),numstr.Data(),
+ nXbins,minXval,maxXval,
+ nYbins,minYval,maxYval,
+ nZbins,minZval,maxZval);
+
+}
+/******************************************************************/
+
+AliHBTMonOneParticleFctn3D::~AliHBTMonOneParticleFctn3D()
+{
+ delete fResult;
+}
+/******************************************************************/
+
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonTwoParticleFctn1D)
+
+AliHBTMonTwoParticleFctn1D::
+AliHBTMonTwoParticleFctn1D(Int_t nbins, Double_t maxval, Double_t minval)
+ {
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH1D(numstr.Data(),numstr.Data(),
+ nbins,minval,maxval);
+
+ }
+
+AliHBTMonTwoParticleFctn1D::
+AliHBTMonTwoParticleFctn1D(const Char_t* name, const Char_t* title,
+ Int_t nbins, Double_t maxval, Double_t minval)
+ :AliHBTMonTwoParticleFctn(name,title)
+ {
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH1D(numstr.Data(),numstr.Data(),
+ nbins,minval,maxval);
+
+ }
+
+
+/******************************************************************/
+AliHBTMonTwoParticleFctn1D::~AliHBTMonTwoParticleFctn1D()
+{
+ delete fResult;
+}
+/******************************************************************/
+void AliHBTMonTwoParticleFctn1D::
+ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
+{
+ partparticle = CheckParticle(partparticle);
+ trackparticle = CheckParticle(trackparticle);
+ if( partparticle && trackparticle)
+ {
+ Double_t x = GetValue(trackparticle,partparticle);
+ fResult->Fill(x);
+ }
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp( AliHBTMonTwoParticleFctn2D)
+
+
+AliHBTMonTwoParticleFctn2D::
+AliHBTMonTwoParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval ,
+ Int_t nYbins, Double_t maxYval, Double_t minYval)
+
+{
+ TString numstr = fName + " Result"; //title and name of the
+ //result histogram
+
+ fResult = new TH2D(numstr.Data(),numstr.Data(),
+ nXbins,minXval,maxXval,
+ nYbins,minYval,maxYval);
+
+}
+/******************************************************************/
+AliHBTMonTwoParticleFctn2D::~AliHBTMonTwoParticleFctn2D()
+{
+ delete fResult;
+}
+/******************************************************************/
+void AliHBTMonTwoParticleFctn2D::
+ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
+{
+ partparticle = CheckParticle(partparticle);
+ trackparticle = CheckParticle(trackparticle);
+ if( partparticle && trackparticle)
+ {
+ Double_t x,y;
+ GetValues(trackparticle,partparticle,x,y);
+ fResult->Fill(x,y);
+ }
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+ClassImp(AliHBTMonTwoParticleFctn3D)
+
+void AliHBTMonTwoParticleFctn3D::
+ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
+{
+ partparticle = CheckParticle(partparticle);
+ trackparticle = CheckParticle(trackparticle);
+ if( partparticle && trackparticle)
+ {
+ Double_t x,y,z;
+ GetValues(trackparticle,partparticle,x,y,z);
+ fResult->Fill(x,y,z);
+ }
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
--- /dev/null
+//Zbigniew.Chajecki@cern.ch
+
+#ifndef ALIMONITORFUNCTION_H
+#define ALIMONITORFUNCTION_H
+
+#include "AliHBTParticleCut.h"
+#include "AliHBTParticle.h"
+
+#include <TH2.h>
+#include <TH3.h>
+
+//class AliHBTAnalysis;
+
+class AliHBTMonitorFunction: public TNamed
+//Abstract base class for HBT functions
+{
+ public:
+ AliHBTMonitorFunction();
+ AliHBTMonitorFunction(const char* name,const char* title);
+ virtual ~AliHBTMonitorFunction();
+
+ virtual TH1* GetResult() = 0;
+
+ virtual void Write();
+
+ void Rename(const Char_t * name);
+ void Rename(const Char_t * name, const Char_t * title);
+
+ void SetParticleCut(AliHBTParticleCut*);
+
+ virtual AliHBTParticle* CheckParticle(AliHBTParticle* particle);
+
+ protected:
+ AliHBTParticleCut* fParticleCut;
+
+ public:
+ ClassDef(AliHBTMonitorFunction,1)
+};
+/******************************************************************/
+/******************************************************************/
+inline AliHBTParticle* AliHBTMonitorFunction::CheckParticle(AliHBTParticle* particle)
+{
+ //check if particle meets the cut criteria
+ if(fParticleCut->Pass(particle)) //if the particle is BAD
+ {
+ return 0x0;//it is BAD as well - so return
+ }
+ return particle;
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
+{
+ public:
+ AliHBTMonOneParticleFctn(){}
+ AliHBTMonOneParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
+ virtual ~AliHBTMonOneParticleFctn(){}
+
+ virtual void ProcessSameEventParticles(AliHBTParticle* particle) = 0;
+
+ protected:
+ public:
+ ClassDef(AliHBTMonOneParticleFctn,1)
+
+};
+/******************************************************************/
+class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
+{
+ public:
+ AliHBTMonOneParticleFctn1D();
+ AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
+ AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
+ Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
+ virtual ~AliHBTMonOneParticleFctn1D();
+
+ TH1* GetResult(){return fResult;}
+
+ void ProcessSameEventParticles(AliHBTParticle* particle);
+
+ protected:
+ virtual Double_t GetValue(AliHBTParticle* particle) = 0;
+
+ TH1D* fResult;
+
+ public:
+ ClassDef(AliHBTMonOneParticleFctn1D,2)
+};
+/******************************************************************/
+
+class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
+{
+ public:
+ AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
+ Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
+ ~AliHBTMonOneParticleFctn2D();
+
+ TH1* GetResult(){return fResult;}
+
+ void ProcessSameEventParticles(AliHBTParticle* particle);
+
+ protected:
+ virtual void GetValues(AliHBTParticle* particle, Double_t&, Double_t&) = 0;
+
+ TH2D* fResult;
+
+ public:
+ ClassDef(AliHBTMonOneParticleFctn2D,1)
+};
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
+{
+ public:
+ AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
+ Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
+ Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
+
+ virtual ~AliHBTMonOneParticleFctn3D();
+
+ TH1* GetResult(){return fResult;}
+
+ protected:
+ TH3D* fResult;
+
+ public:
+ ClassDef(AliHBTMonOneParticleFctn3D,1)
+};
+/******************************************************************/
+/******************************************************************/
+class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
+{
+ public:
+ AliHBTMonTwoParticleFctn(){};
+ AliHBTMonTwoParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
+ virtual ~AliHBTMonTwoParticleFctn(){};
+
+ virtual void
+ ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
+
+ protected:
+ public:
+ ClassDef(AliHBTMonTwoParticleFctn,1)
+
+};
+/******************************************************************/
+
+class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
+{
+ public:
+ AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
+ AliHBTMonTwoParticleFctn1D(const char*,const char*,
+ Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
+ ~AliHBTMonTwoParticleFctn1D();
+
+ TH1* GetResult(){return fResult;}
+
+ void ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
+
+ protected:
+ virtual Double_t GetValue(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
+
+ TH1D* fResult;
+
+ public:
+ ClassDef(AliHBTMonTwoParticleFctn1D,1)
+};
+/******************************************************************/
+class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
+{
+ public:
+ AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
+ Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
+ virtual ~AliHBTMonTwoParticleFctn2D();
+
+ TH1* GetResult(){return fResult;}
+
+ void ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
+ void ProcessDiffEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle){};
+
+
+ protected:
+ virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&) = 0;
+
+ TH2D* fResult;
+
+ public:
+ ClassDef(AliHBTMonTwoParticleFctn2D,1)
+};
+
+
+/******************************************************************/
+class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
+{
+ public:
+ AliHBTMonTwoParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
+ Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
+ Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
+ virtual ~AliHBTMonTwoParticleFctn3D(){}
+
+ TH1* GetResult(){return fResult;}
+
+ void ProcessSameEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
+ void ProcessDiffEventParticles(AliHBTParticle* trackparticle, AliHBTParticle* partparticle){};
+
+
+ protected:
+ virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&,Double_t&) = 0;
+
+ TH3D* fResult;
+
+ public:
+ ClassDef(AliHBTMonTwoParticleFctn3D,1)
+};
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+#endif
--- /dev/null
+#include "AliHBTQDistributionFctns.h"
+
+/******************************************************************/
+/******************************************************************/
+
+ClassImp( AliHBTQInvDistributionVsKtFctn )
+
+AliHBTQInvDistributionVsKtFctn::
+AliHBTQInvDistributionVsKtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTOnePairFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("QInvDistributionVsKt","Q_{Inv} Distribution vs. K_{t}");
+}
+
+/******************************************************************/
+/******************************************************************/
+
+ClassImp( AliHBTQOutDistributionVsKtFctn )
+
+AliHBTQOutDistributionVsKtFctn::
+AliHBTQOutDistributionVsKtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTOnePairFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("QOutDistributionVsKt","Q_{Out} Distribution vs. K_{t}");
+}
+
+/******************************************************************/
+/******************************************************************/
+
+ClassImp( AliHBTQSideDistributionVsKtFctn )
+
+AliHBTQSideDistributionVsKtFctn::
+AliHBTQSideDistributionVsKtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTOnePairFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("QSideDistributionVsKt","Q_{Side} Distribution vs. K_{t}");
+}
+
+/******************************************************************/
+/******************************************************************/
+
+ClassImp( AliHBTQLongDistributionVsKtFctn )
+
+AliHBTQLongDistributionVsKtFctn::
+AliHBTQLongDistributionVsKtFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
+ Int_t nYbins, Double_t maxYval, Double_t minYval):
+ AliHBTOnePairFctn2D(nXbins,maxXval,minXval,nYbins,maxYval,minYval)
+{
+ Rename("QLongDistributionVsKt","Q_{Long} Distribution vs. K_{t}");
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+
+
+
--- /dev/null
+#ifndef ALIHBTQOUTDISTRIBUTIONVSKTLFCTN_H
+#define ALIHBTQOUTDISTRIBUTIONVSKTLFCTN_H
+
+// added by Zbigniew.Chajecki@cern.ch
+// this classes create distribution functions of pair momentum
+
+class AliHBTQInvDistributionVsKtFctn; //QInvCMSLC Distribution Vs Kt
+class AliHBTQOutDistributionVsKtFctn; //QOutCMSLC Distribution Vs Kt
+class AliHBTQSideDistributionVsKtFctn; //QSideCMSLC Distribution Vs Kt
+class AliHBTQLongDistributionVsKtFctn; //QLongCMSLC Distribution Vs Kt
+
+#include "AliHBTFunction.h"
+
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTQOutDistributionVsKtFctn: public AliHBTOnePairFctn2D
+ {
+ public:
+ AliHBTQOutDistributionVsKtFctn(Int_t nXbins = 200, Double_t maxXval = 1., Double_t minXval = 0.0,
+ Int_t nYbins = 500, Double_t maxYval = .15, Double_t minYval =-0.15);
+ virtual ~AliHBTQOutDistributionVsKtFctn(){}
+ TH1* GetResult(){return GetNumerator();}
+ void GetValues(AliHBTPair* partpair, Double_t& x, Double_t& y)
+ {
+ y = partpair->GetQOutCMSLC();
+ x = partpair->GetKt();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTQOutDistributionVsKtFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+class AliHBTQSideDistributionVsKtFctn: public AliHBTOnePairFctn2D
+ {
+ public:
+ AliHBTQSideDistributionVsKtFctn(Int_t nXbins = 200, Double_t maxXval = 1.2, Double_t minXval = -0.1,
+ Int_t nYbins = 500, Double_t maxYval = 1.2, Double_t minYval =-1.2);
+ virtual ~AliHBTQSideDistributionVsKtFctn(){}
+ TH1* GetResult(){return GetNumerator();}
+ void GetValues(AliHBTPair* partpair, Double_t& x, Double_t& y)
+ {
+ y = partpair->GetQSideCMSLC();
+ x = partpair->GetKt();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTQSideDistributionVsKtFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+
+class AliHBTQLongDistributionVsKtFctn: public AliHBTOnePairFctn2D
+ {
+ public:
+ AliHBTQLongDistributionVsKtFctn(Int_t nXbins = 200, Double_t maxXval = 1.2, Double_t minXval = -0.1,
+ Int_t nYbins = 500, Double_t maxYval = 1.2, Double_t minYval =-1.2);
+ virtual ~AliHBTQLongDistributionVsKtFctn(){}
+ TH1* GetResult(){return GetNumerator();}
+ void GetValues(AliHBTPair* partpair, Double_t& x, Double_t& y)
+ {
+ y = partpair->GetQLongCMSLC();
+ x = partpair->GetKt();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTQLongDistributionVsKtFctn,1)
+ };
+/***********************************************************************/
+/***********************************************************************/
+
+class AliHBTQInvDistributionVsKtFctn: public AliHBTOnePairFctn2D
+ {
+ public:
+ AliHBTQInvDistributionVsKtFctn(Int_t nXbins = 200, Double_t maxXval = 1.2, Double_t minXval = -0.1,
+ Int_t nYbins = 500, Double_t maxYval = 1.2, Double_t minYval =-1.2);
+ virtual ~AliHBTQInvDistributionVsKtFctn(){}
+ TH1* GetResult(){return GetNumerator();}
+ void GetValues(AliHBTPair* partpair, Double_t& x, Double_t& y)
+ {
+ y = partpair->GetQInv();
+ x = partpair->GetKt();
+ }
+ protected:
+ private:
+ public:
+ ClassDef(AliHBTQInvDistributionVsKtFctn,1)
+ };
+
+/***********************************************************************/
+/***********************************************************************/
+
+#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff