HBTAN/AliHBTFunction.h

   1 //Piotr Skowronski@cern.ch
   2
   3 #ifndef ALIHBTFUNCTION_H
   4 #define ALIHBTFUNCTION_H
   5
   6 #include "AliHBTParticleCut.h"
   7 #include "AliHBTPairCut.h"
   8 #include "AliHBTPair.h"
   9
  10 #include <TH2.h>
  11 #include <TH3.h>
  12
  13
  14 class AliHBTAnalysis;
  15
  16 class AliHBTFunction: public TNamed
  17 //Abstract base class for HBT functions
  18 {
  19   public:
  20     AliHBTFunction();
  21     AliHBTFunction(const char* name,const char* title);
  22     virtual ~AliHBTFunction();
  23
  24     virtual TH1* GetNumerator() =0;
  25     virtual TH1* GetDenominator() =0;
  26     virtual TH1* GetResult() = 0;
  27
  28     virtual void Write();
  29
  30     TH1* GetRatio(Double_t normfactor = 1.0);
  31     void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
  32     void Rename(const Char_t * name, const Char_t * title); //renames and retitle the function and histograms
  33
  34     void SetPairCut(AliHBTPairCut*);
  35
  36     virtual AliHBTPair* CheckPair(AliHBTPair* pair);
  37
  38   protected:
  39
  40     AliHBTPairCut*      fPairCut;
  41
  42   public:
  43    ClassDef(AliHBTFunction,1)
  44 };
  45 /******************************************************************/
  46 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
  47 {
  48   //check if pair and both particles meets the cut criteria
  49   if(fPairCut->Pass(pair)) //if the pair is BAD
  50    {//it is BAD
  51     pair = pair->GetSwapedPair();
  52     if(pair)
  53      if(fPairCut->Pass(pair)) //so try reverse combination
  54        {
  55         return 0x0;//it is BAD as well - so return
  56        }
  57    }
  58   return pair;
  59 }
  60
  61 /******************************************************************/
  62 /******************************************************************/
  63 /******************************************************************/
  64 class AliHBTOnePairFctn: public AliHBTFunction
  65 {
  66   public:
  67     AliHBTOnePairFctn(){}
  68     AliHBTOnePairFctn(const Char_t *name, const Char_t *title):AliHBTFunction(name,title){}
  69     virtual ~AliHBTOnePairFctn(){}
  70
  71     virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
  72     virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
  73
  74
  75
  76   protected:
  77   public:
  78    ClassDef(AliHBTOnePairFctn,1)
  79
  80 };
  81 /******************************************************************/
  82 /******************************************************************/
  83 /******************************************************************/
  84 class AliHBTTwoPairFctn: public AliHBTFunction
  85 {
  86   public:
  87     AliHBTTwoPairFctn(){};
  88     AliHBTTwoPairFctn(const Char_t *name, const Char_t *title):AliHBTFunction(name,title){}
  89     virtual ~AliHBTTwoPairFctn(){};
  90
  91     virtual void
  92     ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
  93     virtual void
  94     ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
  95
  96
  97   protected:
  98   public:
  99    ClassDef(AliHBTTwoPairFctn,1)
 100
 101 };
 102 /******************************************************************/
 103 /******************************************************************/
 104 /******************************************************************/
 105
 106
 107 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn
 108 {
 109  public:
 110   AliHBTOnePairFctn1D();
 111   AliHBTOnePairFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
 112   AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
 113                       Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
 114   virtual ~AliHBTOnePairFctn1D();
 115
 116
 117   TH1* GetNumerator(){return fNumerator;}
 118   TH1* GetDenominator(){return fDenominator;}
 119
 120   void ProcessSameEventParticles(AliHBTPair* pair);
 121   void ProcessDiffEventParticles(AliHBTPair* pair);
 122   Double_t Scale();
 123   void SetNumberOfBinsToScale(Int_t n = 30){fNBinsToScale = n;}
 124  protected:
 125   //retruns velue to be histogrammed
 126   virtual Double_t GetValue(AliHBTPair* pair) = 0;
 127
 128   TH1D* fNumerator;
 129   TH1D* fDenominator;
 130   Int_t fNBinsToScale;
 131
 132  public:
 133   ClassDef(AliHBTOnePairFctn1D,2)
 134 };
 135
 136 /******************************************************************/
 137 /******************************************************************/
 138 /******************************************************************/
 139
 140 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn
 141 {
 142  public:
 143   AliHBTOnePairFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 144                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
 145   ~AliHBTOnePairFctn2D();
 146
 147   TH1* GetNumerator(){return fNumerator;}
 148   TH1* GetDenominator(){return fDenominator;}
 149
 150   void ProcessSameEventParticles(AliHBTPair* pair);
 151   void ProcessDiffEventParticles(AliHBTPair* pair);
 152
 153
 154  protected:
 155   virtual void GetValues(AliHBTPair* pair, Double_t&, Double_t&) = 0;
 156
 157   TH2D* fNumerator;
 158   TH2D* fDenominator;
 159
 160  public:
 161   ClassDef(AliHBTOnePairFctn2D,1)
 162 };
 163 /******************************************************************/
 164 /******************************************************************/
 165 /******************************************************************/
 166
 167 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn
 168 {
 169  public:
 170   AliHBTOnePairFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 171                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
 172                       Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
 173
 174   virtual ~AliHBTOnePairFctn3D();
 175
 176   TH1* GetNumerator(){return fNumerator;}
 177   TH1* GetDenominator(){return fDenominator;}
 178
 179  protected:
 180   TH3D* fNumerator;
 181   TH3D* fDenominator;
 182  public:
 183   ClassDef(AliHBTOnePairFctn3D,1)
 184 };
 185 /******************************************************************/
 186 /******************************************************************/
 187 /******************************************************************/
 188
 189 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn
 190 {
 191  public:
 192   AliHBTTwoPairFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
 193   AliHBTTwoPairFctn1D(const char*,const char*,
 194                       Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
 195   ~AliHBTTwoPairFctn1D();
 196
 197   TH1* GetNumerator(){return fNumerator;}
 198   TH1* GetDenominator(){return fDenominator;}
 199
 200   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 201   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 202
 203  protected:
 204   virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
 205
 206   TH1D* fNumerator;
 207   TH1D* fDenominator;
 208
 209  public:
 210   ClassDef(AliHBTTwoPairFctn1D,1)
 211 };
 212
 213
 214 /******************************************************************/
 215 /******************************************************************/
 216 /******************************************************************/
 217 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn
 218 {
 219  public:
 220   AliHBTTwoPairFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 221                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
 222   virtual ~AliHBTTwoPairFctn2D();
 223
 224   TH1* GetNumerator(){return fNumerator;}
 225   TH1* GetDenominator(){return fDenominator;}
 226
 227   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 228   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 229
 230
 231  protected:
 232   virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&) = 0;
 233
 234   TH2D* fNumerator;
 235   TH2D* fDenominator;
 236
 237  public:
 238   ClassDef(AliHBTTwoPairFctn2D,1)
 239 };
 240
 241
 242 /******************************************************************/
 243 /******************************************************************/
 244 /******************************************************************/
 245 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn
 246 {
 247  public:
 248   AliHBTTwoPairFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 249                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
 250                        Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
 251   virtual ~AliHBTTwoPairFctn3D(){}
 252
 253   TH1* GetNumerator(){return fNumerator;}
 254   TH1* GetDenominator(){return fDenominator;}
 255
 256   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 257   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 258
 259
 260  protected:
 261   virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&,Double_t&) = 0;
 262
 263   TH3D* fNumerator;
 264   TH3D* fDenominator;
 265
 266  public:
 267   ClassDef(AliHBTTwoPairFctn3D,1)
 268 };
 269
 270 /******************************************************************/
 271 /******************************************************************/
 272 /******************************************************************/
 273
 274
 275
 276 #endif