HBTAN/AliHBTMonitorFunction.h

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