HBTAN/AliHBTFunction.h

   1 #ifndef ALIHBTFUNCTION_H
   2 #define ALIHBTFUNCTION_H
   3
   4 /* Id: $ */
   5
   6 ///////////////////////////////////////////////////////
   7 //                                                   //
   8 // AliHBTFunction                                    //
   9 //                                                   //
  10 // Abstract Base Calss for all the function classes  //
  11 //                                                   //
  12 // Piotr.Skowronski@cern.ch                          //
  13 // http://alisoft.cern.ch/people/skowron/analyzer    //
  14 //                                                   //
  15 ///////////////////////////////////////////////////////
  16
  17 #include <TH1.h>
  18 #include <TH2D.h>
  19 #include <TH3D.h>
  20
  21 #include "AliAODPairCut.h"
  22 #include "AliHBTPair.h"
  23
  24
  25 class AliHBTAnalysis;
  26 class AliVAODParticleCut;
  27
  28 class AliHBTFunction: public TNamed
  29 {
  30   public:
  31     AliHBTFunction();
  32     AliHBTFunction(const char* name, const char* title);
  33     AliHBTFunction(const AliHBTFunction & source);
  34
  35     virtual ~AliHBTFunction();
  36
  37     AliHBTFunction & operator= (const AliHBTFunction & source);
  38
  39     virtual TH1* GetNumerator() const = 0;
  40     virtual TH1* GetDenominator() const = 0;
  41     virtual TH1* GetResult() = 0;
  42
  43     virtual void WriteFunction();
  44     virtual void InitFunction();
  45
  46     TH1* GetRatio(Double_t normfactor = 1.0);
  47     void Rename(const Char_t * name); //renames the function and histograms ==title is the same that name
  48     void Rename(const Char_t * name, const Char_t * title); //renames and retitle the function and histograms
  49
  50     void SetPairCut(AliAODPairCut* cut);
  51
  52     virtual AliHBTPair* CheckPair(AliHBTPair* pair);
  53     void  SetWriteNumAndDen(Bool_t flag = kFALSE){fWriteNumAndDen = flag;}
  54   protected:
  55     virtual void BuildHistos() = 0;//builds default histograms
  56     AliAODPairCut*   fPairCut;     //pair cut
  57     Bool_t           fWriteNumAndDen; //flag indicating whether numerator and denominator should be writted together with a result
  58     ClassDef(AliHBTFunction,3)
  59 };
  60 /******************************************************************/
  61 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
  62 {
  63   //check if pair and both particles meets the cut criteria
  64   if(fPairCut->Rejected(pair)) return 0x0; //if the pair is BAD
  65
  66 //   It is not allowed to change the order here beacause analysis enforce the order
  67
  68 //   {//it is BAD
  69 //    pair = pair->GetSwappedPair();
  70 //    if(pair)
  71 //     if(fPairCut->Rejected(pair)) //so try reverse combination
  72 //       {
  73 //        return 0x0;//it is BAD as well - so return
  74 //       }
  75 //   }
  76
  77   return pair;
  78 }
  79
  80 /******************************************************************/
  81 /******************************************************************/
  82 /******************************************************************/
  83 class AliHBTCorrelFunction
  84 {
  85   public:
  86     AliHBTCorrelFunction():fRatio(0x0){}
  87     AliHBTCorrelFunction(const AliHBTCorrelFunction& in):fRatio((in.fRatio)?(TH1*)in.fRatio->Clone():0x0){}
  88     virtual ~AliHBTCorrelFunction(){delete fRatio;}
  89
  90     AliHBTCorrelFunction& operator=(const AliHBTCorrelFunction& in);
  91
  92   protected:
  93     TH1* fRatio;//!pointer to the ratio(result)
  94
  95   ClassDef(AliHBTCorrelFunction,1)
  96 };
  97
  98 /******************************************************************/
  99 /******************************************************************/
 100 /******************************************************************/
 101
 102 //____________________
 103 ///////////////////////////////////////////////////////
 104 //                                                   //
 105 // AliHBTOnePairFctn                                 //
 106 //                                                   //
 107 // Abstract Base Calss for Functions that need       //
 108 // one pair to fill function                         //
 109 //                                                   //
 110 // Piotr.Skowronski@cern.ch                          //
 111 // http://alisoft.cern.ch/people/skowron/analyzer    //
 112 //                                                   //
 113 ///////////////////////////////////////////////////////
 114
 115 class AliHBTOnePairFctn
 116 {
 117   public:
 118     AliHBTOnePairFctn(){}
 119     virtual ~AliHBTOnePairFctn(){}
 120
 121     virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
 122     virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
 123
 124     virtual void Init() = 0;
 125     virtual void Write() = 0;
 126     virtual const char* Name() = 0;
 127
 128    ClassDef(AliHBTOnePairFctn,2)
 129 };
 130 /******************************************************************/
 131 /******************************************************************/
 132 /******************************************************************/
 133
 134 //____________________
 135 ///////////////////////////////////////////////////////
 136 //                                                   //
 137 // AliHBTTwoPairFctn                                 //
 138 //                                                   //
 139 // Abstract Base Calss for Functions that need       //
 140 // two pairs to fill function,                       //
 141 // one reconstructed track and corresponding         //
 142 // simulated pair                                    //
 143 // Basically resolution functions                    //
 144 // Lednicky's algorithm uses that as well            //
 145 //                                                   //
 146 // Piotr.Skowronski@cern.ch                          //
 147 // http://alisoft.cern.ch/people/skowron/analyzer    //
 148 //                                                   //
 149 ///////////////////////////////////////////////////////
 150
 151 class AliHBTTwoPairFctn
 152 {
 153   public:
 154     AliHBTTwoPairFctn(){};
 155     virtual ~AliHBTTwoPairFctn(){};
 156
 157     virtual void
 158     ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
 159     virtual void
 160     ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
 161
 162     virtual void Init() = 0;
 163     virtual void Write() = 0;
 164     virtual const char* Name() = 0;
 165
 166    ClassDef(AliHBTTwoPairFctn,2)
 167
 168 };
 169 /******************************************************************/
 170 /******************************************************************/
 171 /******************************************************************/
 172
 173 //____________________
 174 ///////////////////////////////////////////////////////
 175 //                                                   //
 176 // AliHBTFunction1D                                  //
 177 //                                                   //
 178 // Base Calss for 1-dimensinal Functions             //
 179 //                                                   //
 180 // Piotr.Skowronski@cern.ch                          //
 181 // http://alisoft.cern.ch/people/skowron/analyzer    //
 182 //                                                   //
 183 ///////////////////////////////////////////////////////
 184
 185
 186 class AliHBTFunction1D: public AliHBTFunction
 187 {
 188  public:
 189   AliHBTFunction1D();//default conmstructor
 190   AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval);
 191   AliHBTFunction1D(const Char_t *name, const Char_t *title);
 192   AliHBTFunction1D(const Char_t *name, const Char_t *title,
 193                    Int_t nbins, Float_t maxXval, Float_t minXval);
 194
 195   AliHBTFunction1D(const AliHBTFunction1D & source);
 196   AliHBTFunction1D & operator= (const AliHBTFunction1D& /*source*/);
 197
 198   virtual ~AliHBTFunction1D();
 199
 200   TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
 201   TH1* GetDenominator() const {return fDenominator;}//returns denominator histogram
 202
 203   Double_t Scale();
 204   void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
 205
 206  protected:
 207   //returns value to be histogrammed
 208   virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
 209   virtual void BuildHistos();
 210   Double_t Scale(TH1D* num,TH1D* den);
 211
 212   TH1D* fNumerator; // Numerator histogram
 213   TH1D* fDenominator; // Denumerator histogram
 214   UInt_t fNBinsToScale; // Number of bins to scale
 215
 216  private:
 217   //this must be declared before constructors because they are used as a default arguments
 218   static const Int_t fgkDefaultNBins;//default number of Bins in histograms
 219   static const Float_t fgkDefaultMin;//Default min value of histograms
 220   static const Float_t fgkDefaultMax;//Default max value of histograms
 221   static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
 222
 223   ClassDef(AliHBTFunction1D,2)
 224 };
 225
 226 /******************************************************************/
 227 /******************************************************************/
 228 /******************************************************************/
 229
 230 //____________________
 231 ///////////////////////////////////////////////////////
 232 //                                                   //
 233 // AliHBTFunction2D                                  //
 234 //                                                   //
 235 // Base Calss for 2-dimensinal Functions             //
 236 //                                                   //
 237 // Piotr.Skowronski@cern.ch                          //
 238 // http://alisoft.cern.ch/people/skowron/analyzer    //
 239 //                                                   //
 240 ///////////////////////////////////////////////////////
 241
 242 class AliHBTFunction2D: public AliHBTFunction
 243 {
 244  public:
 245   AliHBTFunction2D();
 246
 247   AliHBTFunction2D(const Char_t *name, const Char_t *title);
 248
 249   AliHBTFunction2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 250                       Int_t nYbins, Double_t maxYval, Double_t minYval);
 251
 252   AliHBTFunction2D(const Char_t *name, const Char_t *title,
 253                       Int_t nXbins, Double_t maxXval, Double_t minXval,
 254                       Int_t nYbins, Double_t maxYval, Double_t minYval);
 255
 256   AliHBTFunction2D(const AliHBTFunction2D & source);
 257
 258   AliHBTFunction2D & operator= (const AliHBTFunction2D & /*source*/);
 259
 260   virtual ~AliHBTFunction2D();
 261
 262   TH1* GetNumerator() const {return fNumerator;}
 263   TH1* GetDenominator() const {return fDenominator;}
 264
 265   void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
 266                               UInt_t yn = fgkDefaultNBinsToScaleY);
 267
 268   Double_t Scale();
 269  protected:
 270   virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
 271                            Int_t nybins, Float_t ymax, Float_t ymin);
 272   virtual void BuildHistos();
 273
 274   TH2D* fNumerator; // Numerator histogram
 275   TH2D* fDenominator; // Denominator histogram
 276
 277   //definition of area used for scaling -> Scale is calculated this
 278   //way that after division tale is on 1
 279   UInt_t fNBinsToScaleX;//number of bins on X axis
 280   UInt_t fNBinsToScaleY;//number of bins on Y axis
 281
 282  private:
 283   //this must be declared before constructors because they are used as a default arguments
 284   static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
 285   static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
 286   static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
 287   static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
 288   static const Float_t fgkDefaultMinY;//Default min value of histograms
 289   static const Float_t fgkDefaultMaxY;//Default max value of histograms
 290
 291   static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
 292   static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
 293
 294   ClassDef(AliHBTFunction2D,2)
 295 };
 296 /******************************************************************/
 297 /******************************************************************/
 298 /******************************************************************/
 299
 300 //____________________
 301 ///////////////////////////////////////////////////////
 302 //                                                   //
 303 // AliHBTFunction3D                               //
 304 //                                                   //
 305 // Base Calss for 3-dimensinal Functions that need   //
 306 // one pair to fill function                         //
 307 //                                                   //
 308 // Piotr.Skowronski@cern.ch                          //
 309 // http://alisoft.cern.ch/people/skowron/analyzer    //
 310 //                                                   //
 311 ///////////////////////////////////////////////////////
 312
 313 class AliHBTFunction3D: public AliHBTFunction
 314 {
 315  public:
 316   AliHBTFunction3D();
 317
 318   AliHBTFunction3D(const Char_t *name, const Char_t *title);
 319
 320   AliHBTFunction3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 321                    Int_t nYbins, Double_t maxYval, Double_t minYval,
 322                    Int_t nZbins, Double_t maxZval, Double_t minZval);
 323
 324   AliHBTFunction3D(const Char_t *name, const Char_t *title,
 325                    Int_t nXbins, Double_t maxXval, Double_t minXval,
 326                    Int_t nYbins, Double_t maxYval, Double_t minYval,
 327                    Int_t nZbins, Double_t maxZval, Double_t minZval);
 328
 329   AliHBTFunction3D(const AliHBTFunction3D & source);
 330   AliHBTFunction3D & operator= (const AliHBTFunction3D & /*source*/);
 331
 332   virtual ~AliHBTFunction3D();//destructor
 333
 334   TH1* GetNumerator() const {return fNumerator;}
 335   TH1* GetDenominator() const {return fDenominator;}
 336
 337
 338   void SetNumberOfBinsToScale(UInt_t xn = fgkDefaultNBinsToScaleX,
 339                               UInt_t yn = fgkDefaultNBinsToScaleY,
 340                               UInt_t zn = fgkDefaultNBinsToScaleZ);
 341
 342   Double_t Scale();
 343
 344  protected:
 345   virtual void BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
 346                            Int_t nybins, Float_t ymax, Float_t ymin,
 347                Int_t nzbins, Float_t zmax, Float_t zmin);
 348   virtual void BuildHistos();
 349
 350   TH3F* fNumerator; // Numerator histogram
 351   TH3F* fDenominator; // Denominator histogram
 352
 353   //definition of area used for scaling -> Scale is calculated this
 354   //way that after division tale is on 1
 355   UInt_t fNBinsToScaleX;//number of bins on X axis
 356   UInt_t fNBinsToScaleY;//number of bins on Y axis
 357   UInt_t fNBinsToScaleZ;//number of bins on Z axis
 358
 359  private:
 360   //this must be declared before constructors because they are used as a default arguments
 361   static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
 362   static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
 363   static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
 364   static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
 365   static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
 366   static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
 367   static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
 368   static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
 369   static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
 370
 371   static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
 372   static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
 373   static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
 374
 375   ClassDef(AliHBTFunction3D,2)
 376 };
 377 /******************************************************************/
 378 /******************************************************************/
 379 /******************************************************************/
 380
 381 //____________________
 382 ///////////////////////////////////////////////////////
 383 //                                                   //
 384 // AliHBTOnePairFctn1D                               //
 385 //                                                   //
 386 // Base Calss for 1-dimensinal Functions that need   //
 387 // one pair to fill function                         //
 388 //                                                   //
 389 // Piotr.Skowronski@cern.ch                          //
 390 // http://alisoft.cern.ch/people/skowron/analyzer    //
 391 //                                                   //
 392 ///////////////////////////////////////////////////////
 393
 394 class AliHBTOnePairFctn1D: public AliHBTOnePairFctn, public AliHBTFunction1D
 395 {
 396  public:
 397   AliHBTOnePairFctn1D(){}//default conmstructor
 398   AliHBTOnePairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
 399   AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title);
 400   AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title,
 401                       Int_t nbins, Float_t maxXval, Float_t minXval);
 402   virtual ~AliHBTOnePairFctn1D(){}
 403
 404   void ProcessSameEventParticles(AliHBTPair* pair);
 405   void ProcessDiffEventParticles(AliHBTPair* pair);
 406   void Write(){WriteFunction();}
 407   void Init(){InitFunction();}
 408   const char* Name(){return GetName();}
 409
 410  protected:
 411   //retruns velue to be histogrammed
 412   virtual Double_t GetValue(AliHBTPair* pair) const = 0;
 413   ClassDef(AliHBTOnePairFctn1D,2)
 414 };
 415 /******************************************************************/
 416 /******************************************************************/
 417 /******************************************************************/
 418
 419 //____________________
 420 ///////////////////////////////////////////////////////
 421 //                                                   //
 422 // AliHBTOnePairFctn2D                               //
 423 //                                                   //
 424 // Base Calss for 2-dimensinal Functions that need   //
 425 // one pair to fill function                         //
 426 //                                                   //
 427 // Piotr.Skowronski@cern.ch                          //
 428 // http://alisoft.cern.ch/people/skowron/analyzer    //
 429 //                                                   //
 430 ///////////////////////////////////////////////////////
 431
 432 class AliHBTOnePairFctn2D: public AliHBTOnePairFctn, public AliHBTFunction2D
 433 {
 434  public:
 435   AliHBTOnePairFctn2D(){}
 436
 437   AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title);
 438
 439   AliHBTOnePairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 440                       Int_t nYbins, Double_t maxYval, Double_t minYval);
 441
 442   AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title,
 443                       Int_t nXbins, Double_t maxXval, Double_t minXval,
 444                       Int_t nYbins, Double_t maxYval, Double_t minYval);
 445
 446   virtual ~AliHBTOnePairFctn2D(){}
 447
 448   void ProcessSameEventParticles(AliHBTPair* pair);
 449   void ProcessDiffEventParticles(AliHBTPair* pair);
 450   void Write(){WriteFunction();}
 451   void Init(){InitFunction();}
 452   const char* Name(){return GetName();}
 453  protected:
 454   virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y) const = 0;
 455   ClassDef(AliHBTOnePairFctn2D,2)
 456 };
 457 /******************************************************************/
 458 /******************************************************************/
 459 /******************************************************************/
 460
 461 //____________________
 462 ///////////////////////////////////////////////////////
 463 //                                                   //
 464 // AliHBTOnePairFctn3D                               //
 465 //                                                   //
 466 // Base Calss for 3-dimensinal Functions that need   //
 467 // one pair to fill function                         //
 468 //                                                   //
 469 // Piotr.Skowronski@cern.ch                          //
 470 // http://alisoft.cern.ch/people/skowron/analyzer    //
 471 //                                                   //
 472 ///////////////////////////////////////////////////////
 473
 474 class AliHBTOnePairFctn3D: public AliHBTOnePairFctn, public AliHBTFunction3D
 475 {
 476  public:
 477   AliHBTOnePairFctn3D(){}
 478
 479   AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title);
 480
 481   AliHBTOnePairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 482                       Int_t nYbins, Double_t maxYval, Double_t minYval,
 483                       Int_t nZbins, Double_t maxZval, Double_t minZval);
 484
 485   AliHBTOnePairFctn3D(const Char_t *name, const Char_t *title,
 486                       Int_t nXbins, Double_t maxXval, Double_t minXval,
 487                       Int_t nYbins, Double_t maxYval, Double_t minYval,
 488                       Int_t nZbins, Double_t maxZval, Double_t minZval);
 489
 490   virtual ~AliHBTOnePairFctn3D(){}//destructor
 491
 492   void ProcessSameEventParticles(AliHBTPair* pair);
 493   void ProcessDiffEventParticles(AliHBTPair* pair);
 494   void Write(){WriteFunction();}
 495   void Init(){InitFunction();}
 496   const char* Name(){return GetName();}
 497  protected:
 498   virtual void GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const = 0;
 499  ClassDef(AliHBTOnePairFctn3D,2)
 500 };
 501 /******************************************************************/
 502 /******************************************************************/
 503 /******************************************************************/
 504
 505 //____________________
 506 ///////////////////////////////////////////////////////
 507 //                                                   //
 508 // AliHBTTwoPairFctn1D                               //
 509 //                                                   //
 510 // Base Calss for 1-dimensinal Functions that need   //
 511 // two pair (simulated and reconstructed)            //
 512 // to fill function                                  //
 513 //                                                   //
 514 // Piotr.Skowronski@cern.ch                          //
 515 // http://alisoft.cern.ch/people/skowron/analyzer    //
 516 //                                                   //
 517 ///////////////////////////////////////////////////////
 518
 519 class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
 520 {
 521  public:
 522   AliHBTTwoPairFctn1D(){}//default conmstructor
 523   AliHBTTwoPairFctn1D(Int_t nbins, Float_t maxXval, Float_t minXval);
 524   AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title);
 525   AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title,
 526                       Int_t nbins, Float_t maxXval, Float_t minXval);
 527   virtual ~AliHBTTwoPairFctn1D(){}
 528
 529   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 530   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 531   void Write(){WriteFunction();}
 532   void Init(){InitFunction();}
 533   const char* Name(){return GetName();}
 534
 535  protected:
 536   virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const = 0;
 537
 538   ClassDef(AliHBTTwoPairFctn1D,2)
 539 };
 540 /******************************************************************/
 541 /******************************************************************/
 542 /******************************************************************/
 543
 544 //____________________
 545 ///////////////////////////////////////////////////////
 546 //                                                   //
 547 // AliHBTTwoPairFctn2D                               //
 548 //                                                   //
 549 // Base Calss for 2-dimensinal Functions that need   //
 550 // two pair (simulated and reconstructed)            //
 551 // to fill function                                  //
 552 //                                                   //
 553 // Piotr.Skowronski@cern.ch                          //
 554 // http://alisoft.cern.ch/people/skowron/analyzer    //
 555 //                                                   //
 556 ///////////////////////////////////////////////////////
 557
 558 class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
 559 {
 560  public:
 561   AliHBTTwoPairFctn2D(){}
 562
 563   AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title);
 564
 565   AliHBTTwoPairFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 566                       Int_t nYbins, Double_t maxYval, Double_t minYval);
 567
 568   AliHBTTwoPairFctn2D(const Char_t *name, const Char_t *title,
 569                       Int_t nXbins, Double_t maxXval, Double_t minXval,
 570                       Int_t nYbins, Double_t maxYval, Double_t minYval);
 571
 572   virtual ~AliHBTTwoPairFctn2D(){}
 573
 574   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 575   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 576   void Write(){WriteFunction();}
 577   void Init(){InitFunction();}
 578   const char* Name(){return GetName();}
 579
 580  protected:
 581   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) const = 0;
 582
 583   ClassDef(AliHBTTwoPairFctn2D,2)
 584 };
 585 /******************************************************************/
 586 /******************************************************************/
 587 /******************************************************************/
 588
 589 //____________________
 590 ///////////////////////////////////////////////////////
 591 //                                                   //
 592 // AliHBTTwoPairFctn3D                               //
 593 //                                                   //
 594 // Base Calss for 3-dimensinal Functions that need   //
 595 // two pair (simulated and reconstructed)            //
 596 // to fill function                                  //
 597 //                                                   //
 598 // Piotr.Skowronski@cern.ch                          //
 599 // http://alisoft.cern.ch/people/skowron/analyzer    //
 600 //                                                   //
 601 ///////////////////////////////////////////////////////
 602
 603 class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
 604 {
 605  public:
 606   AliHBTTwoPairFctn3D(){}
 607
 608   AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title);
 609
 610   AliHBTTwoPairFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 611                       Int_t nYbins, Double_t maxYval, Double_t minYval,
 612                       Int_t nZbins, Double_t maxZval, Double_t minZval);
 613
 614   AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title,
 615                       Int_t nXbins, Double_t maxXval, Double_t minXval,
 616                       Int_t nYbins, Double_t maxYval, Double_t minYval,
 617                       Int_t nZbins, Double_t maxZval, Double_t minZval);
 618
 619   virtual ~AliHBTTwoPairFctn3D(){}//destructor
 620
 621   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 622   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
 623   void Write(){WriteFunction();}
 624   void Init(){InitFunction();}
 625   const char* Name(){return GetName();}
 626
 627  protected:
 628   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) const = 0;
 629
 630   ClassDef(AliHBTTwoPairFctn3D,2)
 631 };
 632
 633 #endif