Monitor functions implemented by Z.Chajecki. Initial Revision
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 27 Sep 2002 15:51:54 +0000 (15:51 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 27 Sep 2002 15:51:54 +0000 (15:51 +0000)
HBTAN/AliHBTMonDistributionFctns.cxx [new file with mode: 0644]
HBTAN/AliHBTMonDistributionFctns.h [new file with mode: 0644]
HBTAN/AliHBTMonResolutionFctns.cxx [new file with mode: 0644]
HBTAN/AliHBTMonResolutionFctns.h [new file with mode: 0644]
HBTAN/AliHBTMonitorFunction.cxx [new file with mode: 0644]
HBTAN/AliHBTMonitorFunction.h [new file with mode: 0644]
HBTAN/AliHBTQDistributionFctns.cxx [new file with mode: 0644]
HBTAN/AliHBTQDistributionFctns.h [new file with mode: 0644]

diff --git a/HBTAN/AliHBTMonDistributionFctns.cxx b/HBTAN/AliHBTMonDistributionFctns.cxx
new file mode 100644 (file)
index 0000000..4f4705f
--- /dev/null
@@ -0,0 +1,149 @@
+#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");
+}
+/******************************************************************/
+/******************************************************************/
+
+
+
+
diff --git a/HBTAN/AliHBTMonDistributionFctns.h b/HBTAN/AliHBTMonDistributionFctns.h
new file mode 100644 (file)
index 0000000..593e9f4
--- /dev/null
@@ -0,0 +1,248 @@
+#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
diff --git a/HBTAN/AliHBTMonResolutionFctns.cxx b/HBTAN/AliHBTMonResolutionFctns.cxx
new file mode 100644 (file)
index 0000000..8cb5074
--- /dev/null
@@ -0,0 +1,154 @@
+#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");
+}
+/******************************************************************/
+
+
+
+
diff --git a/HBTAN/AliHBTMonResolutionFctns.h b/HBTAN/AliHBTMonResolutionFctns.h
new file mode 100644 (file)
index 0000000..e82caaa
--- /dev/null
@@ -0,0 +1,288 @@
+#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
diff --git a/HBTAN/AliHBTMonitorFunction.cxx b/HBTAN/AliHBTMonitorFunction.cxx
new file mode 100644 (file)
index 0000000..9ad2903
--- /dev/null
@@ -0,0 +1,327 @@
+#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);
+   }
+}
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
diff --git a/HBTAN/AliHBTMonitorFunction.h b/HBTAN/AliHBTMonitorFunction.h
new file mode 100644 (file)
index 0000000..98b9578
--- /dev/null
@@ -0,0 +1,225 @@
+//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
diff --git a/HBTAN/AliHBTQDistributionFctns.cxx b/HBTAN/AliHBTQDistributionFctns.cxx
new file mode 100644 (file)
index 0000000..ae28d0b
--- /dev/null
@@ -0,0 +1,62 @@
+#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}");
+}
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+
+
+
diff --git a/HBTAN/AliHBTQDistributionFctns.h b/HBTAN/AliHBTQDistributionFctns.h
new file mode 100644 (file)
index 0000000..df5fc2f
--- /dev/null
@@ -0,0 +1,96 @@
+#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