]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - HBTAN/AliHBTFunction.h
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix for possible use of AliCFManager without containers, just cuts.
[u/mrichter/AliRoot.git] / HBTAN / AliHBTFunction.h
diff --git a/HBTAN/AliHBTFunction.h b/HBTAN/AliHBTFunction.h
index 0eb565509bb503e069fd8f69b94c60bb3fd284f9..43ae1ca172be7bc3c8542ca502b9dc8da22b547c 100644 (file)
--- a/HBTAN/AliHBTFunction.h
+++ b/HBTAN/AliHBTFunction.h
@@ -1,6 +1,6 @@
 #ifndef ALIHBTFUNCTION_H
 #define ALIHBTFUNCTION_H
-
+ 
 /* Id: $ */
 
 ///////////////////////////////////////////////////////
@@ -10,7 +10,7 @@
 // Abstract Base Calss for all the function classes  //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -18,12 +18,12 @@
 #include <TH2D.h>
 #include <TH3D.h>
 
-#include "AliHBTPairCut.h"
+#include "AliAODPairCut.h"
 #include "AliHBTPair.h"
 
 
 class AliHBTAnalysis;
-class AliHBTParticleCut;
+class AliVAODParticleCut;
 
 class AliHBTFunction: public TNamed
 {
@@ -40,39 +40,64 @@ class AliHBTFunction: public TNamed
     virtual TH1* GetDenominator() const = 0;
     virtual TH1* GetResult() = 0;
 
-    virtual void WriteFunction();
+    virtual Int_t WriteFunction();
     virtual void InitFunction();
     
     TH1* GetRatio(Double_t normfactor = 1.0);
     void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
     void Rename(const Char_t * name, const Char_t * title); //renames and retitle the function and histograms
     
-    void SetPairCut(AliHBTPairCut* cut);
+    void SetPairCut(AliAODPairCut* cut);
+    void UseAbsoluteValues(Bool_t flag){fAbs = flag;}
     
     virtual AliHBTPair* CheckPair(AliHBTPair* pair);
-    
+    void  SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
   protected:
     virtual void BuildHistos() = 0;//builds default histograms
-    AliHBTPairCut*   fPairCut;     //pair cut
+    AliAODPairCut*   fPairCut;     //pair cut
+    Bool_t           fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result
+    Bool_t           fAbs;//flag indicating if absolute values of qout, qside and qlong should be histogrammed
     
-    ClassDef(AliHBTFunction,2)
+    ClassDef(AliHBTFunction,3)
 };
 /******************************************************************/
 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
 {
   //check if pair and both particles meets the cut criteria
-  if(fPairCut->Pass(pair)) //if the pair is BAD
-   {//it is BAD 
-    pair = pair->GetSwapedPair();
-    if(pair)
-     if(fPairCut->Pass(pair)) //so try reverse combination
-       { 
-        return 0x0;//it is BAD as well - so return
-       }
-   }
+  if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD
+
+//   It is not allowed to change the order here beacause analysis enforce the order
+
+//   {//it is BAD 
+//    pair = pair->GetSwappedPair();
+//    if(pair)
+//     if(fPairCut->Rejected(pair)) //so try reverse combination
+//       { 
+//        return 0x0;//it is BAD as well - so return
+//       }
+//   }
+
   return pair; 
 }
 
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+class AliHBTCorrelFunction
+{
+  public:
+    AliHBTCorrelFunction():fRatio(0x0){}
+    AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
+    virtual ~AliHBTCorrelFunction(){delete fRatio;}
+    
+    AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
+   
+  protected:
+    TH1* fRatio;//!pointer to the ratio(result)
+    
+  ClassDef(AliHBTCorrelFunction,1)
+};
+
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
@@ -86,7 +111,7 @@ inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
 // one pair to fill function                         //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -100,7 +125,8 @@ class AliHBTOnePairFctn
     virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
 
     virtual void Init() = 0;
-    virtual void Write() = 0;
+    virtual Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0) = 0;
+    virtual const char* Name() = 0;
     
    ClassDef(AliHBTOnePairFctn,2)
 };
@@ -121,7 +147,7 @@ class AliHBTOnePairFctn
 // Lednicky's algorithm uses that as well            //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -137,7 +163,8 @@ class AliHBTTwoPairFctn
     ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
     
     virtual void Init() = 0;
-    virtual void Write() = 0;
+    virtual Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0) = 0;
+    virtual const char* Name() = 0;
             
    ClassDef(AliHBTTwoPairFctn,2)
   
@@ -154,7 +181,7 @@ class AliHBTTwoPairFctn
 // Base Calss for 1-dimensinal Functions             //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -211,7 +238,7 @@ class AliHBTFunction1D: public AliHBTFunction
 // Base Calss for 2-dimensinal Functions             //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
  
@@ -282,7 +309,7 @@ class AliHBTFunction2D: public AliHBTFunction
 // one pair to fill function                         //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -323,8 +350,8 @@ class AliHBTFunction3D: public AliHBTFunction
               Int_t nzbins, Float_t zmax, Float_t zmin);
   virtual void BuildHistos();
   
-  TH3D* fNumerator; // Numerator histogram
-  TH3D* fDenominator; // Denominator histogram
+  TH3F* fNumerator; // Numerator histogram
+  TH3F* fDenominator; // Denominator histogram
   
   //definition of area used for scaling -> Scale is calculated this 
   //way that after division tale is on 1
@@ -363,7 +390,7 @@ class AliHBTFunction3D: public AliHBTFunction
 // one pair to fill function                         //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -379,11 +406,14 @@ class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
 
   void ProcessSameEventParticles(AliHBTPair* pair);
   void ProcessDiffEventParticles(AliHBTPair* pair);
-  void Write(){WriteFunction();}
+  Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
+  Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
   void Init(){InitFunction();}
+  const char* Name(){return GetName();}
+  
  protected:
   //retruns velue to be histogrammed
-  virtual Double_t GetValue(AliHBTPair* pair) = 0; 
+  virtual Double_t GetValue(AliHBTPair* pair) const = 0; 
   ClassDef(AliHBTOnePairFctn1D,2)
 };
 /******************************************************************/
@@ -399,7 +429,7 @@ class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
 // one pair to fill function                         //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -421,10 +451,12 @@ class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
   
   void ProcessSameEventParticles(AliHBTPair* pair);
   void ProcessDiffEventParticles(AliHBTPair* pair);
-  void Write(){WriteFunction();}
+  Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
+  Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
   void Init(){InitFunction();}
+  const char* Name(){return GetName();}
  protected:
-  virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) = 0;
+  virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
   ClassDef(AliHBTOnePairFctn2D,2)
 };
 /******************************************************************/
@@ -440,7 +472,7 @@ class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
 // one pair to fill function                         //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -464,10 +496,12 @@ class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
 
   void ProcessSameEventParticles(AliHBTPair* pair);
   void ProcessDiffEventParticles(AliHBTPair* pair);
-  void Write(){WriteFunction();}
+  Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
+  Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
   void Init(){InitFunction();}
+  const char* Name(){return GetName();}
  protected:
-  virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) = 0;
+  virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
  ClassDef(AliHBTOnePairFctn3D,2)
 };
 /******************************************************************/
@@ -484,7 +518,7 @@ class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
 // to fill function                                  //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -500,11 +534,13 @@ class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
 
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  void Write(){WriteFunction();}
+  Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
+  Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
   void Init(){InitFunction();}
+  const char* Name(){return GetName();}
   
  protected:
-  virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
+  virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
 
   ClassDef(AliHBTTwoPairFctn1D,2)
 };
@@ -522,7 +558,7 @@ class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
 // to fill function                                  //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -544,11 +580,13 @@ class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
   
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  void Write(){WriteFunction();}
+  Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
+  Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
   void Init(){InitFunction();}
+  const char* Name(){return GetName();}
 
  protected:
-  virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) = 0;
+  virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
 
   ClassDef(AliHBTTwoPairFctn2D,2)
 };
@@ -566,7 +604,7 @@ class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
 // to fill function                                  //
 //                                                   //
 // Piotr.Skowronski@cern.ch                          //
-// http://alisoft.cern.ch/people/skowron/analyzer    //
+// http://aliweb.cern.ch/people/skowron/analyzer    //
 //                                                   //
 ///////////////////////////////////////////////////////
 
@@ -590,11 +628,13 @@ class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
 
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
-  void Write(){WriteFunction();}
+  Int_t Write(const char* /*x1*/ = 0,Int_t /*x2*/ = 0, Int_t /*x3*/ = 0){return WriteFunction();}
+  Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
   void Init(){InitFunction();}
+  const char* Name(){return GetName();}
 
  protected:
-  virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) = 0;
+  virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
 
   ClassDef(AliHBTTwoPairFctn3D,2)
 };