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   Double_t Scale();
 204   void SetNumberOfBinsToScale(Int_t n = 30){fNBinsToScale = n;}
 205
 206  protected:
 207   virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
 208
 209   TH1D* fNumerator;
 210   TH1D* fDenominator;
 211
 212   Int_t fNBinsToScale;
 213
 214  public:
 215   ClassDef(AliHBTTwoPairFctn1D,1)
 216 };
 217
 218
 219 /******************************************************************/
 220 /******************************************************************/
 221 /******************************************************************/
 222 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn
 223 {
 224  public:
 225   AliHBTTwoPairFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 226                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
 227   virtual ~AliHBTTwoPairFctn2D();
 228
 229   TH1* GetNumerator(){return fNumerator;}
 230   TH1* GetDenominator(){return fDenominator;}
 231
 232   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 233   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 234
 235
 236  protected:
 237   virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&) = 0;
 238
 239   TH2D* fNumerator;
 240   TH2D* fDenominator;
 241
 242  public:
 243   ClassDef(AliHBTTwoPairFctn2D,1)
 244 };
 245
 246
 247 /******************************************************************/
 248 /******************************************************************/
 249 /******************************************************************/
 250 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn
 251 {
 252  public:
 253   AliHBTTwoPairFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 254                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
 255                        Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
 256   virtual ~AliHBTTwoPairFctn3D(){}
 257
 258   TH1* GetNumerator(){return fNumerator;}
 259   TH1* GetDenominator(){return fDenominator;}
 260
 261   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 262   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 263
 264
 265  protected:
 266   virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&,Double_t&) = 0;
 267
 268   TH3D* fNumerator;
 269   TH3D* fDenominator;
 270
 271  public:
 272   ClassDef(AliHBTTwoPairFctn3D,1)
 273 };
 274
 275 /******************************************************************/
 276 /******************************************************************/
 277 /******************************************************************/
 278
 279
 280
 281 #endif