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