HBTAN/AliHBTPIDPurityFctns.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 #include "AliHBTPIDPurityFctns.h"
  19 #include "AliLog.h"
  20
  21 //_______________________________________________________________________________
  22 /////////////////////////////////////////////////////////////////////////////////
  23 //
  24 // class AliHBTMonPhiResolutionVsPtFctn;
  25 // class AliHBTMonThetaResolutionVsPtFctn;
  26 //
  27 // file: AliHBTPIDPurityFctns.cxx AliHBTPIDPurityFctns.h
  28 //
  29 // Classes for calculating PID purity, efficiency and other things connected with PID
  30 // xxx
  31 // xxx
  32 //
  33 // added by Piotr.Skowronski@cern.ch
  34 //
  35 //////////////////////////////////////////////////////////////////////////////////
  36
  37
  38 /******************************************************************/
  39 /******************************************************************/
  40 /******************************************************************/
  41
  42 ClassImp(AliHBTMonPIDPurityVsPtFctn)
  43
  44 AliHBTMonPIDPurityVsPtFctn::AliHBTMonPIDPurityVsPtFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
  45  AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval),
  46  fGood(0x0),
  47  fAll(0x0)
  48 {
  49   //ctor
  50   Rename("pidpurityvspt","PIDPurityVsPt");
  51
  52 }
  53 /******************************************************************/
  54
  55 AliHBTMonPIDPurityVsPtFctn::AliHBTMonPIDPurityVsPtFctn(const AliHBTMonPIDPurityVsPtFctn& /*in*/):
  56  AliHBTMonTwoParticleFctn1D(),
  57  AliHBTCorrelFunction(),
  58  fGood(0x0),
  59  fAll(0x0)
  60 {
  61   //cpy constructor
  62   Error("AliHBTMonPIDPurityVsPtFctn(const AliHBTMonPIDPurityVsPtFctn&",
  63         "Functions can not be copied because of histogram names clashes");
  64 }
  65
  66 /******************************************************************/
  67
  68 AliHBTMonPIDPurityVsPtFctn::~AliHBTMonPIDPurityVsPtFctn()
  69 {
  70  //dtor
  71   delete fGood;
  72   delete fAll;
  73 }
  74 /******************************************************************/
  75
  76 AliHBTMonPIDPurityVsPtFctn& AliHBTMonPIDPurityVsPtFctn::operator=
  77                                    (const AliHBTMonPIDPurityVsPtFctn& /*in*/)
  78 {
  79 //assigment operator
  80   Error("operator=","Functions can not be copied because of histogram names clashes");
  81   return *this;
  82 }
  83 /******************************************************************/
  84
  85 Int_t AliHBTMonPIDPurityVsPtFctn::Write(const char*,Int_t, Int_t)
  86 {
  87 //Writes a fucntion results
  88  AliHBTMonitorFunction::Write();
  89  fGood->Write();
  90  fAll->Write();
  91  return 0;
  92 }
  93 /******************************************************************/
  94
  95 void AliHBTMonPIDPurityVsPtFctn::Init()
  96 {
  97 //Initializes fuction
  98   AliDebug(1,"Entering");
  99
 100   if (fResult == 0x0)
 101    {
 102       AliWarning("Function has NULL result histogram!");
 103       return;
 104    }
 105
 106   if (fGood == 0x0)
 107    {
 108      TString numstr = fName + " Good";  //title and name of the
 109                                            //result histogram
 110      TAxis* xax = fResult->GetXaxis();
 111      fGood = new TH1D(numstr,numstr,xax->GetNbins(),xax->GetXmin(),xax->GetXmax());
 112    }
 113
 114   if (fAll == 0x0)
 115    {
 116      TString numstr = fName + " All";  //title and name of the
 117                                            //result histogram
 118      TAxis* xax = fResult->GetXaxis();
 119      fAll = new TH1D(numstr,numstr,xax->GetNbins(),xax->GetXmin(),xax->GetXmax());
 120    }
 121
 122   fResult->Reset();
 123   fResult->SetDirectory(0x0);
 124   fResult->Sumw2();
 125   fGood->Reset();
 126   fGood->SetDirectory(0x0);
 127   fGood->Sumw2();
 128   fAll->Reset();
 129   fAll->SetDirectory(0x0);
 130   fAll->Sumw2();
 131
 132   AliDebug(1,"Done");
 133 }
 134
 135 /******************************************************************/
 136
 137 void AliHBTMonPIDPurityVsPtFctn::Rename(const Char_t * name)
 138 {
 139   //Rename fuctions and all histograms belonging to it
 140   SetName(name);
 141   SetTitle(name);
 142
 143   if (fResult)
 144    {
 145      TString numstr = fName + " Result";  //title and name of the result histogram
 146      fResult->SetName(numstr);
 147      fResult->SetTitle(numstr);
 148    }
 149
 150   if (fGood)
 151    {
 152      TString numstr = fName + " Good";
 153      fGood->SetName(numstr);
 154      fGood->SetTitle(numstr);
 155    }
 156
 157   if (fAll)
 158    {
 159      TString numstr = fName + " All";
 160      fAll->SetName(numstr);
 161      fAll->SetTitle(numstr);
 162    }
 163 }
 164 /******************************************************************/
 165
 166 void AliHBTMonPIDPurityVsPtFctn::Rename(const Char_t * name, const Char_t * title)
 167 {
 168  //renames and retitle the function and histograms
 169
 170   SetName(name);
 171   SetTitle(title);
 172
 173   if (fResult)
 174    {
 175      TString numstrn = fName + " Result";  //name of the result histogram
 176      TString numstrt = fTitle + " Result";  //title of the result histogram
 177      fResult->SetName(numstrn);
 178      fResult->SetTitle(numstrt);
 179    }
 180   if (fGood)
 181    {
 182      TString numstrn = fName + " Good";  //name of the Good histogram
 183      TString numstrt = fTitle + " Good";  //title of the Good histogram
 184      fGood->SetName(numstrn);
 185      fGood->SetTitle(numstrt);
 186    }
 187
 188   if (fAll)
 189    {
 190      TString numstrn = fName + " All";  //name of the All histogram
 191      TString numstrt = fTitle + " All";  //title of the All histogram
 192      fAll->SetName(numstrn);
 193      fAll->SetTitle(numstrt);
 194    }
 195
 196 }
 197 /******************************************************************/
 198
 199 TH1* AliHBTMonPIDPurityVsPtFctn::GetResult()
 200 {
 201   //Returns the result of the fuction
 202   //that is histogram with effciency and contamination
 203
 204   fResult->Divide(fGood,fAll);
 205   return fResult;
 206 }
 207 /******************************************************************/
 208
 209 void AliHBTMonPIDPurityVsPtFctn::Process(AliVAODParticle * track,AliVAODParticle * part)
 210 {
 211  //process the particle/track
 212  Double_t pt = part->Pt();
 213  fAll->Fill(pt);
 214  if (track->GetPdgCode() == part->GetPdgCode())
 215   {
 216     fGood->Fill(pt);
 217   }
 218 // else
 219 //  {
 220 //    Info("Process","Catched pid impurity ...");
 221 //  }
 222 }
 223
 224 /******************************************************************/
 225 /******************************************************************/
 226 /******************************************************************/
 227
 228 ClassImp(AliHBTMonPIDContaminationVsPtFctn)
 229
 230 AliHBTMonPIDContaminationVsPtFctn::AliHBTMonPIDContaminationVsPtFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 231  AliHBTMonTwoParticleFctn1D(nbins,maxXval,minXval),
 232  fWrong(0x0),
 233  fAll(0x0)
 234 {
 235   //ctor
 236   Rename("pidcontaminationvspt","PIDContaminationVsPt");
 237 }
 238 /******************************************************************/
 239
 240 AliHBTMonPIDContaminationVsPtFctn::AliHBTMonPIDContaminationVsPtFctn
 241                                           (const AliHBTMonPIDContaminationVsPtFctn& /*in*/):
 242  AliHBTMonTwoParticleFctn1D(),
 243  AliHBTCorrelFunction(),
 244  fWrong(0x0),
 245  fAll(0x0)
 246 {
 247   //cpy constructor
 248   Error("AliHBTMonPIDContaminationVsPtFctn(const AliHBTMonPIDContaminationVsPtFctn&",
 249         "Functions can not be copied because of histogram names clashes");
 250 }
 251
 252 /******************************************************************/
 253
 254 AliHBTMonPIDContaminationVsPtFctn::~AliHBTMonPIDContaminationVsPtFctn()
 255 {
 256  //dtor
 257   delete fWrong;
 258   delete fAll;
 259 }
 260 /******************************************************************/
 261
 262 AliHBTMonPIDContaminationVsPtFctn& AliHBTMonPIDContaminationVsPtFctn::operator=
 263                                            (const AliHBTMonPIDContaminationVsPtFctn& /*in*/)
 264 {
 265 //assigment operator
 266   Error("operator=","Functions can not be copied because of histogram names clashes");
 267   return *this;
 268 }
 269 /******************************************************************/
 270
 271 Int_t AliHBTMonPIDContaminationVsPtFctn::Write(const char*,Int_t, Int_t)
 272 {
 273  //Writes the function results
 274  AliHBTMonitorFunction::Write();
 275  fWrong->Write();
 276  fAll->Write();
 277  return 0;
 278 }
 279 /******************************************************************/
 280
 281 void AliHBTMonPIDContaminationVsPtFctn::Init()
 282 {
 283 //Initializes fuction
 284   AliDebug(1,"Entering");
 285
 286   if (fResult == 0x0)
 287    {
 288       AliWarning("Function has NULL result histogram!");
 289       return;
 290    }
 291
 292   if (fWrong == 0x0)
 293    {
 294      TString numstr = fName + " Wrong";  //title and name of the
 295                                            //result histogram
 296      TAxis* xax = fResult->GetXaxis();
 297      fWrong = new TH1D(numstr,numstr,xax->GetNbins(),xax->GetXmin(),xax->GetXmax());
 298    }
 299
 300   if (fAll == 0x0)
 301    {
 302      TString numstr = fName + " All";  //title and name of the
 303                                            //result histogram
 304      TAxis* xax = fResult->GetXaxis();
 305      fAll = new TH1D(numstr,numstr,xax->GetNbins(),xax->GetXmin(),xax->GetXmax());
 306    }
 307   fResult->Reset();
 308   fResult->SetDirectory(0x0);
 309   fResult->Sumw2();
 310   fWrong->Reset();
 311   fWrong->SetDirectory(0x0);
 312   fWrong->Sumw2();
 313   fAll->Reset();
 314   fAll->SetDirectory(0x0);
 315   fAll->Sumw2();
 316
 317   AliDebug(1,"Done");
 318 }
 319
 320 /******************************************************************/
 321
 322 void AliHBTMonPIDContaminationVsPtFctn::Rename(const Char_t * name)
 323 {
 324   //Rename fuctions and all histograms belonging to it
 325   SetName(name);
 326   SetTitle(name);
 327
 328   if (fResult)
 329    {
 330      TString numstr = fName + " Result";  //title and name of the result histogram
 331      fResult->SetName(numstr);
 332      fResult->SetTitle(numstr);
 333    }
 334   if (fWrong)
 335    {
 336      TString numstr = fName + " Wrong";
 337      fWrong->SetName(numstr);
 338      fWrong->SetTitle(numstr);
 339    }
 340
 341   if (fAll)
 342    {
 343      TString numstrn = fName + " All";  //name of the All histogram
 344      TString numstrt = fTitle + " All";  //title of the All histogram
 345      fAll->SetName(numstrn);
 346      fAll->SetTitle(numstrt);
 347    }
 348 }
 349 /******************************************************************/
 350
 351 void AliHBTMonPIDContaminationVsPtFctn::Rename(const Char_t * name, const Char_t * title)
 352 {
 353  //renames and retitle the function and histograms
 354
 355   SetName(name);
 356   SetTitle(title);
 357
 358   if (fResult)
 359    {
 360      TString numstrn = fName + " Result";  //name of the result histogram
 361      TString numstrt = fTitle + " Result";  //title of the result histogram
 362      fResult->SetName(numstrn);
 363      fResult->SetTitle(numstrt);
 364    }
 365   if (fWrong)
 366    {
 367      TString numstrn = fName + " Wrong";  //name of the Wrong histogram
 368      TString numstrt = fTitle + " Wrong";  //title of the Wrong histogram
 369      fWrong->SetName(numstrn);
 370      fWrong->SetTitle(numstrt);
 371    }
 372
 373   if (fAll)
 374    {
 375      TString numstr = fName + " All";
 376      fAll->SetName(numstr);
 377      fAll->SetTitle(numstr);
 378    }
 379
 380 }
 381 /******************************************************************/
 382
 383 TH1* AliHBTMonPIDContaminationVsPtFctn::GetResult()
 384 {
 385   //Returns the result of the fuction
 386   //that is histogram with effciency and contamination
 387
 388   fResult->Divide(fWrong,fAll);
 389   return fResult;
 390 }
 391 /******************************************************************/
 392
 393 void AliHBTMonPIDContaminationVsPtFctn::Process(AliVAODParticle * track, AliVAODParticle * part)
 394 {
 395  //process the particle/track
 396  Double_t pt = part->Pt();
 397  fAll->Fill(pt);
 398
 399  if (track->GetPdgCode() != part->GetPdgCode())
 400   {
 401 //    Info("Process","Catched contamination");
 402 //    track->Print();part->Print();
 403     fWrong->Fill(pt);
 404   }
 405 }
 406
 407 /******************************************************************/
 408 /******************************************************************/
 409 /******************************************************************/
 410 ClassImp(AliHBTQInvCorrelFctnPerfectPID)
 411
 412 AliHBTQInvCorrelFctnPerfectPID::AliHBTQInvCorrelFctnPerfectPID(Int_t nbins, Double_t maxXval, Double_t minXval):
 413  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 414 {
 415 //ctor
 416  fWriteNumAndDen = kTRUE;//change default behaviour
 417  Rename("qinvcfprfctpid","Q_{inv} Correlation Function Perfect PID");
 418 }
 419 /*************************************************************/
 420
 421 void AliHBTQInvCorrelFctnPerfectPID::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 422 {
 423 //Fills numerator
 424   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 425   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 426
 427   trackpair  = CheckPair(trackpair);
 428   if (trackpair == 0x0) return;
 429 //  partpair  = CheckPair(partpair);
 430   if (partpair == 0x0) return;
 431
 432   fNumerator->Fill(trackpair->GetQInv());
 433 }
 434
 435 /*************************************************************/
 436 void AliHBTQInvCorrelFctnPerfectPID::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 437 {
 438 //Fills numerator
 439   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 440   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 441
 442   trackpair  = CheckPair(trackpair);
 443   if (trackpair == 0x0) return;
 444 //  partpair  = CheckPair(partpair);
 445   if (partpair == 0x0) return;
 446
 447   fDenominator->Fill(trackpair->GetQInv());
 448 }
 449 /*************************************************************/
 450
 451 TH1* AliHBTQInvCorrelFctnPerfectPID::GetResult()
 452 {
 453  //returns the scaled ratio
 454
 455  delete fRatio;
 456  fRatio = GetRatio(Scale());
 457  return fRatio;
 458 }
 459 /*************************************************************/
 460 /******************************************************************/
 461 /******************************************************************/
 462 /******************************************************************/
 463
 464 ClassImp(AliHBTWeightQInvCorrelFctnPerfectPID)
 465
 466 AliHBTWeightQInvCorrelFctnPerfectPID::AliHBTWeightQInvCorrelFctnPerfectPID(Int_t nbins, Double_t maxXval, Double_t minXval):
 467  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 468 {
 469 //ctor
 470  fWriteNumAndDen = kTRUE;//change default behaviour
 471  Rename("wqinvcfprfctpid","Q_{inv} Weight Correlation Function Perfect PID");
 472 }
 473 /*************************************************************/
 474
 475 void AliHBTWeightQInvCorrelFctnPerfectPID::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 476 {
 477 //Fills numerator
 478   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 479   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 480
 481   trackpair  = CheckPair(trackpair);
 482   if (trackpair == 0x0) return;
 483 //  partpair  = CheckPair(partpair);
 484   if (partpair == 0x0) return;
 485
 486   fNumerator->Fill(trackpair->GetQInv(),partpair->GetWeight());
 487 }
 488
 489 /*************************************************************/
 490 void AliHBTWeightQInvCorrelFctnPerfectPID::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 491 {
 492 //Fills numerator
 493   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 494   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 495
 496   trackpair  = CheckPair(trackpair);
 497   if (trackpair == 0x0) return;
 498 //  partpair  = CheckPair(partpair);
 499   if (partpair == 0x0) return;
 500
 501   fDenominator->Fill(trackpair->GetQInv());
 502 }
 503 /*************************************************************/
 504
 505 TH1* AliHBTWeightQInvCorrelFctnPerfectPID::GetResult()
 506 {
 507  //returns the scaled ratio
 508
 509  delete fRatio;
 510  fRatio = GetRatio(Scale());
 511  return fRatio;
 512 }
 513
 514
 515 /******************************************************************/
 516 /******************************************************************/
 517 /******************************************************************/
 518
 519 ClassImp(AliHBTWeightQOutSQideQLongFctnPerfectPID)
 520
 521 AliHBTWeightQOutSQideQLongFctnPerfectPID::AliHBTWeightQOutSQideQLongFctnPerfectPID
 522   (Int_t nXbins, Double_t maxXval, Double_t minXval,
 523    Int_t nYbins, Double_t maxYval, Double_t minYval,
 524    Int_t nZbins, Double_t maxZval, Double_t minZval):
 525  AliHBTTwoPairFctn3D(nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval)
 526 {
 527   //ctor
 528   fWriteNumAndDen = kTRUE;//change default behaviour
 529   Rename("wqoslprfctpid","Q_{out}-Q_{side}-Q_{long} Weight Fctn with perfect PID");
 530 }
 531 /*************************************************************/
 532
 533 void AliHBTWeightQOutSQideQLongFctnPerfectPID::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 534 {
 535 //Fills numerator
 536   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 537   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 538
 539   trackpair  = CheckPair(trackpair);
 540   if (trackpair == 0x0) return;
 541 //  partpair  = CheckPair(partpair);
 542   if (partpair == 0x0) return;
 543
 544
 545   Double_t weight = partpair->GetWeight();
 546   Double_t out = trackpair->GetQOutLCMS();
 547   Double_t side = trackpair->GetQSideLCMS();
 548   Double_t lon = trackpair->GetQLongLCMS();
 549
 550   if (fAbs)
 551    {
 552      out = TMath::Abs(out);
 553      side = TMath::Abs(side);
 554      lon = TMath::Abs(lon);
 555    }
 556   fNumerator->Fill(out,side,lon,weight);
 557 }
 558 /*************************************************************/
 559
 560 void AliHBTWeightQOutSQideQLongFctnPerfectPID::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 561 {
 562 //Fills numerator
 563   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 564   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 565
 566   trackpair  = CheckPair(trackpair);
 567   if (trackpair == 0x0) return;
 568 //  partpair  = CheckPair(partpair);
 569   if (partpair == 0x0) return;
 570
 571   Double_t out = trackpair->GetQOutLCMS();
 572   Double_t side = trackpair->GetQSideLCMS();
 573   Double_t lon = trackpair->GetQLongLCMS();
 574
 575   if (fAbs)
 576    {
 577      out = TMath::Abs(out);
 578      side = TMath::Abs(side);
 579      lon = TMath::Abs(lon);
 580    }
 581   fDenominator->Fill(out,side,lon);
 582 }
 583 /******************************************************************/
 584
 585 TH1* AliHBTWeightQOutSQideQLongFctnPerfectPID::GetResult()
 586 {
 587  //returns the scaled ratio
 588  delete fRatio;
 589  fRatio = GetRatio(Scale());
 590  return fRatio;
 591 }
 592
 593
 594 /******************************************************************/
 595 /******************************************************************/
 596 /******************************************************************/
 597
 598 ClassImp(AliHBTQOutSQideQLongFctnPerfectPID)
 599
 600 AliHBTQOutSQideQLongFctnPerfectPID::AliHBTQOutSQideQLongFctnPerfectPID
 601    (Int_t nXbins, Double_t maxXval, Double_t minXval,
 602     Int_t nYbins, Double_t maxYval, Double_t minYval,
 603     Int_t nZbins, Double_t maxZval, Double_t minZval):
 604  AliHBTTwoPairFctn3D(nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval)
 605 {
 606   //ctor
 607   fWriteNumAndDen = kTRUE;//change default behaviour
 608   Rename("qoslprfctpid","Q_{out}-Q_{side}-Q_{long} Fctn with perfect PID");
 609 }
 610 /*************************************************************/
 611
 612 void AliHBTQOutSQideQLongFctnPerfectPID::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 613 {
 614 //Fills numerator
 615   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 616   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 617
 618   trackpair  = CheckPair(trackpair);
 619   if (trackpair == 0x0) return;
 620 //  partpair  = CheckPair(partpair);
 621   if (partpair == 0x0) return;
 622
 623   Double_t out = trackpair->GetQOutLCMS();
 624   Double_t side = trackpair->GetQSideLCMS();
 625   Double_t lon = trackpair->GetQLongLCMS();
 626
 627   if (fAbs)
 628    {
 629      out = TMath::Abs(out);
 630      side = TMath::Abs(side);
 631      lon = TMath::Abs(lon);
 632    }
 633   fNumerator->Fill(out,side,lon);
 634 }
 635 /*************************************************************/
 636
 637 void AliHBTQOutSQideQLongFctnPerfectPID::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 638 {
 639 //Fills numerator
 640   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 641   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 642
 643   trackpair  = CheckPair(trackpair);
 644   if (trackpair == 0x0) return;
 645 //  partpair  = CheckPair(partpair);
 646   if (partpair == 0x0) return;
 647
 648   Double_t out = trackpair->GetQOutLCMS();
 649   Double_t side = trackpair->GetQSideLCMS();
 650   Double_t lon = trackpair->GetQLongLCMS();
 651
 652   if (fAbs)
 653    {
 654      out = TMath::Abs(out);
 655      side = TMath::Abs(side);
 656      lon = TMath::Abs(lon);
 657    }
 658   fDenominator->Fill(out,side,lon);
 659 }
 660 /******************************************************************/
 661
 662 TH1* AliHBTQOutSQideQLongFctnPerfectPID::GetResult()
 663 {
 664  //returns the scaled ratio
 665  delete fRatio;
 666  fRatio = GetRatio(Scale());
 667  return fRatio;
 668 }
 669
 670 /******************************************************************/
 671 /******************************************************************/
 672 /******************************************************************/
 673
 674
 675
 676 ClassImp(AliHBTPairPIDProbVsQInvFctn)
 677
 678 AliHBTPairPIDProbVsQInvFctn::AliHBTPairPIDProbVsQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 679  AliHBTOnePairFctn1D(nbins,maxXval,minXval)
 680 {
 681  fWriteNumAndDen = kTRUE;//change default behaviour
 682  Rename("qinvpidpur","Q_{inv}  Function");
 683 }
 684 /******************************************************************/
 685
 686 TH1* AliHBTPairPIDProbVsQInvFctn::GetResult()
 687 {
 688  //returns the scaled ratio
 689  delete fRatio;
 690  fRatio = GetRatio(Scale());
 691  return fRatio;
 692 }
 693 /******************************************************************/
 694
 695 void AliHBTPairPIDProbVsQInvFctn::ProcessSameEventParticles(AliHBTPair* pair)
 696 {
 697  //Fills the numerator using pair from the same event
 698    pair = CheckPair(pair);
 699    if(pair) fNumerator->Fill(pair->GetQInv(),pair->GetPIDProb());
 700 }
 701 /******************************************************************/
 702
 703 void AliHBTPairPIDProbVsQInvFctn::ProcessDiffEventParticles(AliHBTPair* pair)
 704  {
 705   //Fills the denumerator using mixed pairs
 706    pair = CheckPair(pair);
 707    if(pair) fDenominator->Fill(pair->GetQInv(),pair->GetPIDProb());
 708   }
 709
 710 /******************************************************************/
 711 /******************************************************************/
 712 /******************************************************************/
 713
 714 ClassImp(AliHBTPairPIDProbVsQOutSQideQLongFctn)
 715
 716 AliHBTPairPIDProbVsQOutSQideQLongFctn::AliHBTPairPIDProbVsQOutSQideQLongFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
 717                                                    Int_t nYbins, Double_t maxYval, Double_t minYval,
 718                                                    Int_t nZbins, Double_t maxZval, Double_t minZval):
 719  AliHBTOnePairFctn3D(nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval)
 720 {
 721   //ctor
 722   fWriteNumAndDen = kTRUE;//change default behaviour
 723   Rename("qoslpidpur","Pair PID Probablilty .vs. Q_{out}-Q_{side}-Q_{long} Fctn");
 724 }
 725 /*************************************************************/
 726
 727 void AliHBTPairPIDProbVsQOutSQideQLongFctn::ProcessSameEventParticles(AliHBTPair* pair)
 728 {
 729 //Fills numerator
 730   pair  = CheckPair(pair);
 731   if (pair == 0x0) return;
 732   Double_t weight = pair->GetPIDProb();
 733   Double_t out = pair->GetQOutLCMS();
 734   Double_t side = pair->GetQSideLCMS();
 735   Double_t lon = pair->GetQLongLCMS();
 736
 737   if (fAbs)
 738    {
 739      out = TMath::Abs(out);
 740      side = TMath::Abs(side);
 741      lon = TMath::Abs(lon);
 742    }
 743
 744   fNumerator->Fill(out,side,lon,weight);
 745 }
 746 /*************************************************************/
 747
 748 void AliHBTPairPIDProbVsQOutSQideQLongFctn::ProcessDiffEventParticles(AliHBTPair* pair)
 749 {
 750 //Fills numerator
 751   pair  = CheckPair(pair);
 752   if (pair == 0x0) return;
 753   Double_t weight = pair->GetPIDProb();
 754   Double_t out = pair->GetQOutLCMS();
 755   Double_t side = pair->GetQSideLCMS();
 756   Double_t lon = pair->GetQLongLCMS();
 757
 758   if (fAbs)
 759    {
 760      out = TMath::Abs(out);
 761      side = TMath::Abs(side);
 762      lon = TMath::Abs(lon);
 763    }
 764
 765   fDenominator->Fill(out,side,lon,weight);
 766 }
 767 /*************************************************************/
 768
 769 TH1* AliHBTPairPIDProbVsQOutSQideQLongFctn::GetResult()
 770 {
 771  //returns the scaled ratio
 772
 773  delete fRatio;
 774  fRatio = GetRatio(Scale());
 775  return fRatio;
 776 }
 777
 778 /******************************************************************/
 779 /******************************************************************/
 780 /******************************************************************/
 781
 782 ClassImp(AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID)
 783
 784 AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID::AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID(Int_t nXbins, Double_t maxXval, Double_t minXval,
 785                                                    Int_t nYbins, Double_t maxYval, Double_t minYval,
 786                                                    Int_t nZbins, Double_t maxZval, Double_t minZval):
 787  AliHBTTwoPairFctn3D(nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval)
 788 {
 789 //ctor
 790 //Set Axis Title
 791  fWriteNumAndDen = kTRUE;
 792  Rename("tteffptthetaphipfctPID","P_{t} \\theta \\phi Two Track Efficiency Function");
 793  if(fNumerator)
 794   {
 795    fNumerator->GetXaxis()->SetTitle("\\Delta P_{t} [GeV]");
 796    fNumerator->GetYaxis()->SetTitle("\\Delta \\theta [rad]");
 797    fNumerator->GetZaxis()->SetTitle("\\Delta \\phi [rad]");
 798   }
 799
 800  if(fDenominator)
 801   {
 802    fDenominator->GetXaxis()->SetTitle("\\Delta P_{t} [GeV]");
 803    fDenominator->GetYaxis()->SetTitle("\\Delta \\theta [rad]");
 804    fDenominator->GetZaxis()->SetTitle("\\Delta \\phi [rad]");
 805   }
 806 }
 807 /******************************************************************/
 808
 809 void AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 810 {
 811 //Fills numerator
 812   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 813   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 814
 815   trackpair  = CheckPair(trackpair);
 816   if (trackpair == 0x0) return;
 817 //  partpair  = CheckPair(partpair);
 818   if (partpair == 0x0) return;
 819
 820   Double_t x = TMath::Abs(trackpair->GetDeltaPt());
 821   Double_t y = TMath::Abs(trackpair->GetDeltaTheta());
 822   Double_t z = TMath::Abs(trackpair->GetDeltaPhi());
 823   fNumerator->Fill(x,y,z);
 824 }
 825 /******************************************************************/
 826
 827 void AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 828 {
 829 //Fills numerator
 830   if (trackpair->Particle1()->GetPdgCode() != partpair->Particle1()->GetPdgCode()) return;
 831   if (trackpair->Particle2()->GetPdgCode() != partpair->Particle2()->GetPdgCode()) return;
 832
 833   trackpair  = CheckPair(trackpair);
 834   if (trackpair == 0x0) return;
 835 //  partpair  = CheckPair(partpair);
 836   if (partpair == 0x0) return;
 837
 838   Double_t x = TMath::Abs(trackpair->GetDeltaPt());
 839   Double_t y = TMath::Abs(trackpair->GetDeltaTheta());
 840   Double_t z = TMath::Abs(trackpair->GetDeltaPhi());
 841   fDenominator->Fill(x,y,z);
 842 }
 843 /******************************************************************/
 844
 845 TH1* AliHBTTwoTrackEffFctnPtThetaPhiPerfectPID::GetResult()
 846 {
 847 //returns ratio of numerator and denominator
 848  delete fRatio;
 849  fRatio = GetRatio(Scale());
 850  if(fRatio)
 851   {
 852    fRatio->GetXaxis()->SetTitle("\\Delta P_{t} [GeV]");
 853    fRatio->GetYaxis()->SetTitle("\\Delta \\theta [rad]");
 854    fRatio->GetZaxis()->SetTitle("\\Delta \\phi [rad]");
 855   }
 856  return fRatio;
 857 }
 858 /******************************************************************/
 859 /******************************************************************/
 860 /******************************************************************/
 861
 862 ClassImp(AliHBTPairPIDProbVsPtThetaPhiFctn)
 863
 864 AliHBTPairPIDProbVsPtThetaPhiFctn::AliHBTPairPIDProbVsPtThetaPhiFctn(Int_t nXbins, Double_t maxXval, Double_t minXval,
 865                                                    Int_t nYbins, Double_t maxYval, Double_t minYval,
 866                                                    Int_t nZbins, Double_t maxZval, Double_t minZval):
 867  AliHBTOnePairFctn3D(nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval)
 868 {
 869   //ctor
 870   fWriteNumAndDen = kTRUE;//change default behaviour
 871   Rename("ptthetaphipidpur","Pair PID Probablilty .vs. \\Delta P_{t}-\\Delta \\theta-\\Delta \\phi Fctn");
 872   if(fNumerator)
 873    {
 874     fNumerator->GetXaxis()->SetTitle("\\Delta P_{t} [GeV]");
 875     fNumerator->GetYaxis()->SetTitle("\\Delta \\theta [rad]");
 876     fNumerator->GetZaxis()->SetTitle("\\Delta \\phi [rad]");
 877    }
 878
 879   if(fDenominator)
 880    {
 881     fDenominator->GetXaxis()->SetTitle("\\Delta P_{t} [GeV]");
 882     fDenominator->GetYaxis()->SetTitle("\\Delta \\theta [rad]");
 883     fDenominator->GetZaxis()->SetTitle("\\Delta \\phi [rad]");
 884    }
 885
 886 }
 887 /*************************************************************/
 888
 889 void AliHBTPairPIDProbVsPtThetaPhiFctn::ProcessSameEventParticles(AliHBTPair* pair)
 890 {
 891 //Fills numerator
 892   pair  = CheckPair(pair);
 893   if (pair == 0x0) return;
 894   Double_t weight = pair->GetPIDProb();
 895   Double_t pt = TMath::Abs(pair->GetDeltaPt());
 896   Double_t theta = TMath::Abs(pair->GetDeltaTheta());
 897   Double_t phi = TMath::Abs(pair->GetDeltaPhi());
 898   fNumerator->Fill(pt,theta,phi,weight);
 899 }
 900 /*************************************************************/
 901
 902 void AliHBTPairPIDProbVsPtThetaPhiFctn::ProcessDiffEventParticles(AliHBTPair* pair)
 903 {
 904 //Fills numerator
 905   pair  = CheckPair(pair);
 906   if (pair == 0x0) return;
 907   Double_t weight = pair->GetPIDProb();
 908   Double_t pt = TMath::Abs(pair->GetDeltaPt());
 909   Double_t phi = TMath::Abs(pair->GetDeltaTheta());
 910   Double_t theta = TMath::Abs(pair->GetDeltaPhi());
 911   fDenominator->Fill(pt,theta,phi,weight);
 912 }
 913 /*************************************************************/
 914
 915 TH1* AliHBTPairPIDProbVsPtThetaPhiFctn::GetResult()
 916 {
 917  //returns the scaled ratio
 918
 919  delete fRatio;
 920  fRatio = GetRatio(Scale());
 921  if(fRatio)
 922   {
 923    fRatio->GetXaxis()->SetTitle("\\Delta P_{t} [GeV]");
 924    fRatio->GetYaxis()->SetTitle("\\Delta \\theta [rad]");
 925    fRatio->GetZaxis()->SetTitle("\\Delta \\phi [rad]");
 926   }
 927  return fRatio;
 928 }
 929