HBTAN/AliHBTMonitorFunction.h

   1 #ifndef ALIHBTMONITORFUNCTION_H
   2 #define ALIHBTMONITORFUNCTION_H
   3 //__________________________________________________________________
   4 ////////////////////////////////////////////////////////////////////
   5 //
   6 // class AliHBTMonitorFunction
   7 //
   8 // class AliHBTMonOneParticleFctn
   9 // class AliHBTMonTwoParticleFctn
  10 //
  11 // class AliHBTMonOneParticleFctn1D
  12 // class AliHBTMonOneParticleFctn2D
  13 // class AliHBTMonOneParticleFctn3D
  14 //
  15 // class AliHBTMonTwoParticleFctn1D
  16 // class AliHBTMonTwoParticleFctn2D
  17 // class AliHBTMonTwoParticleFctn3D
  18 //
  19 // Base Classes for monitoring functions
  20 // author: chajecki@if.pw.edu.pl
  21 //
  22 /******************************************************************/
  23 /*
  24 Base classes for monitor functions
  25
  26           monitor function
  27                /    \
  28               /      \
  29              /        \
  30             /          \
  31            /            \
  32           /              \
  33          /                \
  34    one particle     two particle
  35      /  |  \            /  |  \
  36     /   |   \          /   |   \
  37    1D  2D   3D        1D  2D   3D
  38
  39 Zbigniew.Chajecki@cern.ch
  40
  41 */
  42 ///////////////////////////////////////////////////////////////////////
  43
  44 #include "AliHBTParticleCut.h"
  45
  46 #include <TH2.h>
  47 #include <TH3.h>
  48
  49 class AliHBTParticle;
  50
  51 class AliHBTMonitorFunction: public TNamed
  52 //Abstract base class for HBT functions
  53 {
  54   public:
  55     AliHBTMonitorFunction();
  56     AliHBTMonitorFunction(const char* name,const char* title);
  57     AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/);
  58     virtual ~AliHBTMonitorFunction();
  59
  60     AliHBTMonitorFunction& operator=(const AliHBTMonitorFunction& /*in*/);
  61
  62
  63     virtual TH1* GetResult() = 0;
  64
  65     virtual void Write();
  66     virtual void Init(){}
  67     void Rename(const Char_t * name);
  68     void Rename(const Char_t * name, const Char_t * title);
  69
  70     void SetParticleCut(AliHBTParticleCut* cut);
  71
  72     virtual AliHBTParticle* CheckParticle(AliHBTParticle* particle) const;
  73
  74   protected:
  75     AliHBTParticleCut*      fParticleCut;//Particle cut
  76
  77   private:
  78    ClassDef(AliHBTMonitorFunction,1)
  79 };
  80 /******************************************************************/
  81 /******************************************************************/
  82 inline AliHBTParticle* AliHBTMonitorFunction::CheckParticle(AliHBTParticle* particle) const
  83 {
  84   //check if particle meets the cut criteria
  85   if(fParticleCut->Pass(particle)) //if the particle is BAD
  86    {
  87      return 0x0;//it is BAD as well - so return
  88    }
  89   return particle;
  90 }
  91
  92 /******************************************************************/
  93 /******************************************************************/
  94 /******************************************************************/
  95
  96 class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
  97 {
  98   public:
  99     AliHBTMonOneParticleFctn(){}
 100     AliHBTMonOneParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
 101     AliHBTMonOneParticleFctn(const AliHBTMonOneParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
 102     virtual ~AliHBTMonOneParticleFctn(){}
 103
 104     AliHBTMonOneParticleFctn& operator=(const AliHBTMonOneParticleFctn& /*in*/){MayNotUse("operator=");return *this;}
 105
 106     virtual void Process(AliHBTParticle* particle) = 0;
 107
 108   protected:
 109   private:
 110    ClassDef(AliHBTMonOneParticleFctn,1)
 111
 112 };
 113 /******************************************************************/
 114 class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
 115 {
 116  public:
 117   AliHBTMonOneParticleFctn1D();
 118   AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
 119   AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
 120                       Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
 121   AliHBTMonOneParticleFctn1D(const AliHBTMonOneParticleFctn1D& in):
 122                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 123
 124   virtual ~AliHBTMonOneParticleFctn1D();
 125
 126   AliHBTMonOneParticleFctn1D& operator=(const AliHBTMonOneParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}
 127   TH1* GetResult(){return fResult;}
 128
 129   void Process(AliHBTParticle* particle);
 130
 131  protected:
 132   virtual Double_t GetValue(AliHBTParticle* particle) = 0;
 133   TH1D* fResult;//histogram to be filled
 134  private:
 135   ClassDef(AliHBTMonOneParticleFctn1D,2)
 136 };
 137 /******************************************************************/
 138
 139 class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
 140 {
 141  public:
 142   AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 143                       Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
 144   AliHBTMonOneParticleFctn2D(const AliHBTMonOneParticleFctn2D& in):
 145                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 146   virtual ~AliHBTMonOneParticleFctn2D();
 147
 148   AliHBTMonOneParticleFctn2D& operator=(const AliHBTMonOneParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}
 149   TH1* GetResult(){return fResult;}
 150
 151   void Process(AliHBTParticle* particle);
 152
 153  protected:
 154   virtual void GetValues(AliHBTParticle* particle, Double_t&, Double_t&) = 0;
 155
 156   TH2D* fResult;//histogram to be filled
 157
 158  private:
 159   ClassDef(AliHBTMonOneParticleFctn2D,1)
 160 };
 161 /******************************************************************/
 162 /******************************************************************/
 163 /******************************************************************/
 164
 165 class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
 166 {
 167  public:
 168   AliHBTMonOneParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 169                       Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
 170                       Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15);
 171   AliHBTMonOneParticleFctn3D(const AliHBTMonOneParticleFctn3D& in):
 172                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 173
 174   virtual ~AliHBTMonOneParticleFctn3D();
 175
 176   AliHBTMonOneParticleFctn3D& operator=(const AliHBTMonOneParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}
 177   TH1* GetResult(){return fResult;}
 178
 179  protected:
 180   TH3D* fResult;//histogram to be filled
 181
 182  private:
 183   ClassDef(AliHBTMonOneParticleFctn3D,1)
 184 };
 185 /******************************************************************/
 186 /******************************************************************/
 187 class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
 188 {
 189   public:
 190     AliHBTMonTwoParticleFctn(){};
 191     AliHBTMonTwoParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
 192     AliHBTMonTwoParticleFctn(const AliHBTMonTwoParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
 193     virtual ~AliHBTMonTwoParticleFctn(){};
 194     AliHBTMonTwoParticleFctn& operator=(const AliHBTMonTwoParticleFctn& /*in*/){MayNotUse("operator=");return *this;}
 195
 196     virtual void
 197     Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
 198
 199   protected:
 200   private:
 201    ClassDef(AliHBTMonTwoParticleFctn,1)
 202
 203 };
 204 /******************************************************************/
 205
 206 class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
 207 {
 208  public:
 209   AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
 210   AliHBTMonTwoParticleFctn1D(const char* name,const char* title,
 211                       Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
 212   AliHBTMonTwoParticleFctn1D(const AliHBTMonTwoParticleFctn1D& in):
 213                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 214   virtual ~AliHBTMonTwoParticleFctn1D();
 215
 216   AliHBTMonTwoParticleFctn1D& operator=(const AliHBTMonTwoParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}
 217   TH1* GetResult(){return fResult;}
 218
 219   void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
 220
 221  protected:
 222   virtual Double_t GetValue(AliHBTParticle* trackparticle, AliHBTParticle* partparticle) = 0;
 223
 224   TH1D* fResult;//histogram to be filled
 225
 226  private:
 227   ClassDef(AliHBTMonTwoParticleFctn1D,1)
 228 };
 229 /******************************************************************/
 230 class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
 231 {
 232  public:
 233   AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 234                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
 235   AliHBTMonTwoParticleFctn2D(const AliHBTMonTwoParticleFctn2D& in):
 236                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 237   virtual ~AliHBTMonTwoParticleFctn2D();
 238
 239   AliHBTMonTwoParticleFctn2D& operator=(const AliHBTMonTwoParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}
 240   TH1* GetResult(){return fResult;}
 241
 242   void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
 243
 244  protected:
 245   virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&) = 0;
 246
 247   TH2D* fResult;//histogram to be filled
 248
 249  private:
 250   ClassDef(AliHBTMonTwoParticleFctn2D,1)
 251 };
 252
 253
 254 /******************************************************************/
 255 class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
 256 {
 257  public:
 258   AliHBTMonTwoParticleFctn3D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 259                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15,
 260                        Int_t nZbins = 200, Double_t maxZval = .15, Double_t minZval =-0.15){}
 261   AliHBTMonTwoParticleFctn3D(const AliHBTMonTwoParticleFctn3D& in):
 262                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 263   virtual ~AliHBTMonTwoParticleFctn3D(){}
 264
 265   AliHBTMonTwoParticleFctn3D& operator=(const AliHBTMonTwoParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}
 266   TH1* GetResult(){return fResult;}
 267
 268   void Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle);
 269
 270  protected:
 271   virtual void GetValues(AliHBTParticle*,AliHBTParticle*, Double_t&, Double_t&,Double_t&) = 0;
 272
 273   TH3D* fResult; //histogram to be filled
 274
 275  private:
 276   ClassDef(AliHBTMonTwoParticleFctn3D,1)
 277 };
 278
 279 /******************************************************************/
 280 /******************************************************************/
 281 /******************************************************************/
 282 /******************************************************************/
 283
 284 #endif