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 "AliAODParticleCut.h"
  45
  46 #include <TH2.h>
  47 #include <TH3.h>
  48
  49 class AliVAODParticle;
  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     Int_t Write(const char* /*x1*/ = "",Int_t /*x2*/ = 0, Int_t /*x3*/ = 0);
  66     Int_t Write(const char* x1 = "",Int_t x2 = 0, Int_t x3 = 0) const {return TObject::Write(x1,x2,x3);}
  67     virtual void Init();
  68     virtual const char* Name(){return GetName();}
  69     void Rename(const Char_t * name);
  70     void Rename(const Char_t * name, const Char_t * title);
  71
  72     void SetParticleCut(AliAODParticleCut* cut);
  73
  74     virtual AliVAODParticle* CheckParticle(AliVAODParticle* particle) const;
  75
  76   protected:
  77     AliAODParticleCut*      fParticleCut;//Particle cut
  78
  79   private:
  80    ClassDef(AliHBTMonitorFunction,1)
  81 };
  82 /******************************************************************/
  83 /******************************************************************/
  84 inline AliVAODParticle* AliHBTMonitorFunction::CheckParticle(AliVAODParticle* particle) const
  85 {
  86   //check if particle meets the cut criteria
  87   if(fParticleCut->Rejected(particle)) //if the particle is BAD
  88    {
  89      return 0x0;//it is BAD as well - so return
  90    }
  91   return particle;
  92 }
  93
  94 /******************************************************************/
  95 /******************************************************************/
  96 /******************************************************************/
  97
  98 class AliHBTMonOneParticleFctn: public AliHBTMonitorFunction
  99 {
 100   public:
 101     AliHBTMonOneParticleFctn(){}
 102     AliHBTMonOneParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
 103     AliHBTMonOneParticleFctn(const AliHBTMonOneParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
 104     virtual ~AliHBTMonOneParticleFctn(){}
 105
 106     AliHBTMonOneParticleFctn& operator=(const AliHBTMonOneParticleFctn& /*in*/){MayNotUse("operator=");return *this;}
 107
 108     virtual void Process(AliVAODParticle* particle) = 0;
 109
 110   protected:
 111   private:
 112    ClassDef(AliHBTMonOneParticleFctn,1)
 113
 114 };
 115 /******************************************************************/
 116 class AliHBTMonOneParticleFctn1D: public AliHBTMonOneParticleFctn
 117 {
 118  public:
 119   AliHBTMonOneParticleFctn1D();
 120   AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval);
 121   AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
 122                       Int_t nbins = 100, Double_t maxXval = 1.4, Double_t minXval = 0.0);
 123   AliHBTMonOneParticleFctn1D(const AliHBTMonOneParticleFctn1D& in):
 124                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 125
 126   virtual ~AliHBTMonOneParticleFctn1D();
 127
 128   AliHBTMonOneParticleFctn1D& operator=(const AliHBTMonOneParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}
 129   TH1* GetResult(){return this->fResult;}
 130
 131   void Process(AliVAODParticle* particle);
 132
 133  protected:
 134   virtual Double_t GetValue(AliVAODParticle* particle) const = 0;
 135   TH1D* fResult;//histogram to be filled
 136  private:
 137   ClassDef(AliHBTMonOneParticleFctn1D,2)
 138 };
 139 /******************************************************************/
 140
 141 class AliHBTMonOneParticleFctn2D: public AliHBTMonOneParticleFctn
 142 {
 143  public:
 144   AliHBTMonOneParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 145                       Int_t nYbins = 200, Double_t maxYval = 1.5, Double_t minYval =-0.1);
 146   AliHBTMonOneParticleFctn2D(const AliHBTMonOneParticleFctn2D& in):
 147                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 148   virtual ~AliHBTMonOneParticleFctn2D();
 149
 150   AliHBTMonOneParticleFctn2D& operator=(const AliHBTMonOneParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}
 151   TH1* GetResult(){return this->fResult;}
 152
 153   void Process(AliVAODParticle* particle);
 154
 155  protected:
 156   virtual void GetValues(AliVAODParticle* particle, Double_t&, Double_t&) const = 0;
 157
 158   TH2D* fResult;//histogram to be filled
 159
 160  private:
 161   ClassDef(AliHBTMonOneParticleFctn2D,1)
 162 };
 163 /******************************************************************/
 164 /******************************************************************/
 165 /******************************************************************/
 166
 167 class AliHBTMonOneParticleFctn3D: public AliHBTMonOneParticleFctn
 168 {
 169  public:
 170   AliHBTMonOneParticleFctn3D(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   AliHBTMonOneParticleFctn3D(const AliHBTMonOneParticleFctn3D& in):
 174                AliHBTMonOneParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 175
 176   virtual ~AliHBTMonOneParticleFctn3D();
 177
 178   AliHBTMonOneParticleFctn3D& operator=(const AliHBTMonOneParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}
 179   TH1* GetResult(){return this->fResult;}
 180
 181  protected:
 182   TH3D* fResult;//histogram to be filled
 183
 184  private:
 185   ClassDef(AliHBTMonOneParticleFctn3D,1)
 186 };
 187 /******************************************************************/
 188 /******************************************************************/
 189 class AliHBTMonTwoParticleFctn: public AliHBTMonitorFunction
 190 {
 191   public:
 192     AliHBTMonTwoParticleFctn(){};
 193     AliHBTMonTwoParticleFctn(const Char_t *name, const Char_t *title):AliHBTMonitorFunction(name,title){}
 194     AliHBTMonTwoParticleFctn(const AliHBTMonTwoParticleFctn& in):AliHBTMonitorFunction(in){MayNotUse("Cpy Ctor");}
 195     virtual ~AliHBTMonTwoParticleFctn(){};
 196     AliHBTMonTwoParticleFctn& operator=(const AliHBTMonTwoParticleFctn& /*in*/){MayNotUse("operator=");return *this;}
 197
 198     virtual void
 199     Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle) = 0;
 200
 201   protected:
 202   private:
 203    ClassDef(AliHBTMonTwoParticleFctn,1)
 204
 205 };
 206 /******************************************************************/
 207
 208 class AliHBTMonTwoParticleFctn1D: public AliHBTMonTwoParticleFctn
 209 {
 210  public:
 211   AliHBTMonTwoParticleFctn1D(Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
 212   AliHBTMonTwoParticleFctn1D(const char* name,const char* title,
 213                       Int_t nbins = 200, Double_t maxval = 1.5, Double_t minval = 0.0);
 214   AliHBTMonTwoParticleFctn1D(const AliHBTMonTwoParticleFctn1D& in):
 215                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 216   virtual ~AliHBTMonTwoParticleFctn1D();
 217
 218   AliHBTMonTwoParticleFctn1D& operator=(const AliHBTMonTwoParticleFctn1D& /*in*/){MayNotUse("operator=");return *this;}
 219   TH1* GetResult(){return this->fResult;}
 220
 221   void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
 222
 223  protected:
 224   virtual Double_t GetValue(AliVAODParticle* trackparticle, AliVAODParticle* partparticle) const = 0;
 225
 226   TH1D* fResult;//histogram to be filled
 227
 228  private:
 229   ClassDef(AliHBTMonTwoParticleFctn1D,1)
 230 };
 231 /******************************************************************/
 232 class AliHBTMonTwoParticleFctn2D: public AliHBTMonTwoParticleFctn
 233 {
 234  public:
 235   AliHBTMonTwoParticleFctn2D(Int_t nXbins = 200, Double_t maxXval = 1.5, Double_t minXval = 0.0,
 236                        Int_t nYbins = 200, Double_t maxYval = .15, Double_t minYval =-0.15);
 237   AliHBTMonTwoParticleFctn2D(const AliHBTMonTwoParticleFctn2D& in):
 238                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 239   virtual ~AliHBTMonTwoParticleFctn2D();
 240
 241   AliHBTMonTwoParticleFctn2D& operator=(const AliHBTMonTwoParticleFctn2D& /*in*/){MayNotUse("operator=");return *this;}
 242   TH1* GetResult(){return this->fResult;}
 243
 244   void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
 245
 246  protected:
 247   virtual void GetValues(AliVAODParticle*,AliVAODParticle*, Double_t&, Double_t&) const = 0;
 248
 249   TH2D* fResult;//histogram to be filled
 250
 251  private:
 252   ClassDef(AliHBTMonTwoParticleFctn2D,1)
 253 };
 254
 255
 256 /******************************************************************/
 257 class AliHBTMonTwoParticleFctn3D: public AliHBTMonTwoParticleFctn
 258 {
 259  public:
 260   AliHBTMonTwoParticleFctn3D(Int_t /*nXbins = 200*/, Double_t /*maxXval = 1.5*/, Double_t /*minXval = 0.0*/,
 261                              Int_t /*nYbins = 200*/, Double_t /*maxYval = .15*/, Double_t /*minYval =-0.15*/,
 262                              Int_t /*nZbins = 200*/, Double_t /*maxZval = .15*/, Double_t /*minZval =-0.15*/){}
 263   AliHBTMonTwoParticleFctn3D(const AliHBTMonTwoParticleFctn3D& in):
 264                AliHBTMonTwoParticleFctn(in),fResult(0x0){MayNotUse("Cpy Ctor");}
 265   virtual ~AliHBTMonTwoParticleFctn3D(){}
 266
 267   AliHBTMonTwoParticleFctn3D& operator=(const AliHBTMonTwoParticleFctn3D& /*in*/){MayNotUse("operator=");return *this;}
 268   TH1* GetResult(){return this->fResult;}
 269
 270   void Process(AliVAODParticle* trackparticle, AliVAODParticle* partparticle);
 271
 272  protected:
 273   virtual void GetValues(AliVAODParticle*,AliVAODParticle*, Double_t&, Double_t&,Double_t&) const = 0;
 274
 275   TH3D* fResult; //histogram to be filled
 276
 277  private:
 278   ClassDef(AliHBTMonTwoParticleFctn3D,1)
 279 };
 280
 281 /******************************************************************/
 282 /******************************************************************/
 283 /******************************************************************/
 284 /******************************************************************/
 285
 286 #endif