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