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