HBTAN/AliHBTFunction.h

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