HBTAN/AliHBTWeightFctn.cxx

   1 #include "AliHBTWeightFctn.h"
   2 /* $Id$ */
   3 //_________________________________________________________________________
   4 //
   5 // class
   6 //
   7 //This class allows to obtain Q_inv correlation function with weights
   8 //calculated by Lednicky's alghorithm.
   9 //Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
  10 //Weights are calculated with corresponding simulated particles momenta.
  11 //Denominator is filled with mixing unweighted reconstructed tracks.
  12 //One needs both pairs
  13 //(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
  14 //Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
  15 #include "AliHBTWeightsPID.h"
  16
  17 //--for test--AliHBTWeightQInvFctn* yyy= new AliHBTWeightQInvFctn();
  18
  19 ClassImp( AliHBTWeightQInvFctn )
  20
  21
  22 /****************************************************************/
  23 AliHBTWeightQInvFctn::AliHBTWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
  24  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
  25 {
  26 //ctor
  27  fWriteNumAndDen = kTRUE;//change default behaviour
  28  Rename("wqinvcf","Q_{inv} Weight Correlation Function");
  29 }
  30 /****************************************************************/
  31 void  AliHBTWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
  32 {
  33   //process particles from same events (fills numerator)
  34   trackpair = CheckPair(trackpair);
  35   partpair  = CheckPair(partpair);
  36   if ( trackpair && partpair)
  37   {
  38 //    Double_t weightPID=1.;
  39     Double_t weight = 1.0;
  40     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
  41          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
  42       {
  43          weight=partpair->GetWeight();
  44       }
  45 //    Double_t weight=weightHBT*weightPID;
  46     fNumerator->Fill(trackpair->GetQInv(),weight);
  47   }
  48 }
  49 /****************************************************************/
  50
  51 void  AliHBTWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
  52 {
  53   // Fills the denominator using mixed pairs
  54   trackpair = CheckPair(trackpair);
  55   partpair  = CheckPair(partpair);
  56   if ( trackpair && partpair)
  57   {
  58      fDenominator->Fill(trackpair->GetQInv());
  59   }
  60 }
  61 /**************************************************************/
  62 TH1* AliHBTWeightQInvFctn::GetResult()
  63 {
  64 //returns ratio of numerator and denominator
  65  return GetRatio(Scale());
  66 }
  67
  68 /**************************************************************************************/
  69 /**************************************************************************************/
  70 /**************************************************************************************/
  71 /**************************************************************************************/
  72
  73 ClassImp(AliHBTWeightQOutFctn)
  74
  75 AliHBTWeightQOutFctn::AliHBTWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
  76  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
  77 {
  78 //ctor
  79  fWriteNumAndDen = kTRUE;//change default behaviour
  80  Rename("wqoutcf","Q_{out} Weight Correlation Function");
  81 }
  82 /****************************************************************/
  83 void AliHBTWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
  84 {
  85   //process particles from same events (fills numerator)
  86   trackpair = CheckPair(trackpair);
  87   partpair  = CheckPair(partpair);
  88   if ( trackpair && partpair)
  89   {
  90 //    Double_t weightPID=1.;
  91     Double_t weight = 1.0;
  92     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
  93          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
  94       {
  95          weight=partpair->GetWeight();
  96       }
  97 //    Double_t weight=weightHBT*weightPID;
  98     fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
  99   }
 100 }
 101 /****************************************************************/
 102
 103 void AliHBTWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 104 {
 105   //process particles from diff events (fills denominator)
 106   trackpair = CheckPair(trackpair);
 107   partpair  = CheckPair(partpair);
 108   if ( trackpair && partpair)
 109   {
 110      fDenominator->Fill(trackpair->GetQOutCMSLC());
 111   }
 112 }
 113 /**************************************************************/
 114 TH1* AliHBTWeightQOutFctn::GetResult()
 115
 116 {
 117 //returns ratio of numerator and denominator
 118  return GetRatio(Scale());
 119 }
 120
 121 /*************************************************************************************/
 122 /*************************************************************************************/
 123 /*************************************************************************************/
 124
 125 ClassImp(AliHBTWeightQLongFctn)
 126 AliHBTWeightQLongFctn::AliHBTWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 127  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 128 {
 129 //ctor
 130  fWriteNumAndDen = kTRUE;//change default behaviour
 131  Rename("wqlongcf","Q_{long} Weight Correlation Function");
 132 }
 133 /****************************************************************/
 134 void AliHBTWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 135 {
 136   //process particles from same events (fills numerator)
 137   trackpair = CheckPair(trackpair);
 138   partpair  = CheckPair(partpair);
 139   if ( trackpair && partpair)
 140   {
 141 //    Double_t weightPID=1.;
 142     Double_t weight = 1.0;
 143     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
 144          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
 145       {
 146          weight=partpair->GetWeight();
 147       }
 148 //    Double_t weight=weightHBT*weightPID;
 149     fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
 150   }
 151 }
 152 /****************************************************************/
 153
 154 void AliHBTWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 155 {
 156   //process particles from diff events (fills denominator)
 157   trackpair = CheckPair(trackpair);
 158   partpair  = CheckPair(partpair);
 159   if ( trackpair && partpair)
 160   {
 161      fDenominator->Fill(trackpair->GetQLongCMSLC());
 162   }
 163 }
 164 /**************************************************************/
 165 TH1* AliHBTWeightQLongFctn::GetResult()
 166
 167 {
 168 //returns ratio of numerator and denominator
 169  return GetRatio(Scale());
 170 }
 171
 172 /*************************************************************************************/
 173 /*************************************************************************************/
 174 /*************************************************************************************/
 175
 176 ClassImp(AliHBTWeightQSideFctn)
 177 /*************************************************************************************/
 178
 179 AliHBTWeightQSideFctn::AliHBTWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 180  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 181 {
 182 //ctor
 183  fWriteNumAndDen = kTRUE;//change default behaviour
 184  Rename("wqsidecf","Q_{side} Weight Correlation Function");
 185 }
 186 /****************************************************************/
 187 void AliHBTWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 188 {
 189   //process particles from same events (fills numerator)
 190   trackpair = CheckPair(trackpair);
 191   partpair  = CheckPair(partpair);
 192   if ( trackpair && partpair)
 193   {
 194 //    Double_t weightPID=1.;
 195     Double_t weight = 1.0;
 196     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
 197          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
 198       {
 199          weight=partpair->GetWeight();
 200       }
 201 //    Double_t weight=weightHBT*weightPID;
 202     fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
 203   }
 204 }
 205 /****************************************************************/
 206
 207 void  AliHBTWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 208 {
 209   //process particles from diff events (fills denominator)
 210   trackpair = CheckPair(trackpair);
 211   partpair  = CheckPair(partpair);
 212   if ( trackpair && partpair)
 213   {
 214      fDenominator->Fill(trackpair->GetQSideCMSLC());
 215   }
 216 }
 217 /**************************************************************/
 218 TH1* AliHBTWeightQSideFctn::GetResult()
 219
 220 {
 221 //returns ratio of numerator and denominator
 222  return GetRatio(Scale());
 223 }
 224
 225 /*************************************************************************************/
 226 /*************************************************************************************/
 227 /*************************************************************************************/
 228
 229 ClassImp(AliHBTWeightTwoKStarFctn)
 230 /*************************************************************************************/
 231 AliHBTWeightTwoKStarFctn::AliHBTWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 232  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 233 {
 234 //ctor
 235  fWriteNumAndDen = kTRUE;//change default behaviour
 236  Rename("wtwokstarcf","2*K^{*} Weight Correlation Function");
 237 }
 238 /****************************************************************/
 239 void AliHBTWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 240 {
 241   //process particles from same events (fills numerator)
 242   trackpair = CheckPair(trackpair);
 243   partpair  = CheckPair(partpair);
 244   if ( trackpair && partpair)
 245   {
 246 //    Double_t weightPID=1.;
 247     Double_t weight = 1.0;
 248     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
 249          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
 250       {
 251          weight=partpair->GetWeight();
 252       }
 253 //    Double_t weight=weightHBT*weightPID;
 254     fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
 255   }
 256 }
 257 /****************************************************************/
 258
 259 void  AliHBTWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 260 {
 261   //process particles from diff events (fills denominator)
 262   trackpair = CheckPair(trackpair);
 263   partpair  = CheckPair(partpair);
 264   if ( trackpair && partpair)
 265   {
 266      fDenominator->Fill(2.0*(trackpair->GetKStar()));
 267   }
 268 }
 269 /**************************************************************/
 270 TH1* AliHBTWeightTwoKStarFctn::GetResult()
 271
 272 {
 273 //returns ratio of numerator and denominator
 274  return GetRatio(Scale());
 275 }
 276
 277 /*************************************************************************************/
 278 /*************************************************************************************/
 279 /*************************************************************************************/
 280
 281 ClassImp(AliHBTWeightQOutQSideFctn)
 282 /*************************************************************************************/
 283
 284 AliHBTWeightQOutQSideFctn::AliHBTWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
 285                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
 286  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
 287 {
 288   //ctor
 289  fWriteNumAndDen = kTRUE;//change default behaviour
 290  Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
 291 }
 292 /*************************************************************************************/
 293 void AliHBTWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 294 {
 295   //process particles from same events (fills numerator)
 296   trackpair = CheckPair(trackpair);
 297   partpair  = CheckPair(partpair);
 298   if ( trackpair && partpair)
 299   {
 300 //    Double_t weightPID=1.;
 301     Double_t weight = 1.0;
 302     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
 303          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
 304       {
 305          weight=partpair->GetWeight();
 306       }
 307 //    Double_t weight=weightHBT*weightPID;
 308     fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
 309   }
 310 }
 311 /****************************************************************/
 312
 313 void AliHBTWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 314 {
 315   //process particles from diff events (fills denominator)
 316   trackpair = CheckPair(trackpair);
 317   partpair  = CheckPair(partpair);
 318   if ( trackpair && partpair)
 319   {
 320      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
 321   }
 322 }
 323 /**************************************************************/
 324 TH1* AliHBTWeightQOutQSideFctn::GetResult()
 325 {
 326   //returns result
 327   return GetRatio(Scale());
 328 }
 329
 330 /*************************************************************************************/
 331 /*************************************************************************************/
 332 /*************************************************************************************/
 333
 334 ClassImp(AliHBTWeightQOutQLongFctn)
 335 /*************************************************************************************/
 336
 337 AliHBTWeightQOutQLongFctn::AliHBTWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
 338                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
 339  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
 340 {
 341   //ctor
 342  fWriteNumAndDen = kTRUE;//change default behaviour
 343  Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
 344 }
 345 /*************************************************************************************/
 346 void AliHBTWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 347 {
 348   //process particles from same events (fills numerator)
 349   trackpair = CheckPair(trackpair);
 350   partpair  = CheckPair(partpair);
 351   if ( trackpair && partpair)
 352   {
 353 //    Double_t weightPID=1.;
 354     Double_t weight = 1.0;
 355     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
 356          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
 357       {
 358          weight=partpair->GetWeight();
 359       }
 360 //    Double_t weight=weightHBT*weightPID;
 361     fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
 362   }
 363 }
 364 /****************************************************************/
 365
 366 void AliHBTWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 367 {
 368   //process particles from diff events (fills denominator)
 369   trackpair = CheckPair(trackpair);
 370   partpair  = CheckPair(partpair);
 371   if ( trackpair && partpair)
 372   {
 373      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
 374   }
 375 }
 376 /**************************************************************/
 377
 378 TH1* AliHBTWeightQOutQLongFctn::GetResult()
 379 {
 380   //returns result
 381   return GetRatio(Scale());
 382 }
 383
 384 /*************************************************************************************/
 385 /*************************************************************************************/
 386 /*************************************************************************************/
 387
 388 ClassImp(AliHBTWeightQSideQLongFctn)
 389 /*************************************************************************************/
 390
 391 AliHBTWeightQSideQLongFctn::AliHBTWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
 392                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
 393  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
 394 {
 395   //ctor
 396  fWriteNumAndDen = kTRUE;//change default behaviour
 397  Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
 398 }
 399 /*************************************************************************************/
 400 void AliHBTWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 401 {
 402   //process particles from same events (fills numerator)
 403   trackpair = CheckPair(trackpair);
 404   partpair  = CheckPair(partpair);
 405   if ( trackpair && partpair)
 406   {
 407 //    Double_t weightPID=1.;
 408     Double_t weight = 1.0;
 409     if ( ( trackpair->Particle1()->GetPdgCode() == partpair->Particle1()->GetPdgCode()) &&
 410          ( trackpair->Particle2()->GetPdgCode() == partpair->Particle2()->GetPdgCode())    )
 411       {
 412          weight=partpair->GetWeight();
 413       }
 414 //    Double_t weight=weightHBT*weightPID;
 415     fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
 416   }
 417 }
 418 /****************************************************************/
 419
 420 void AliHBTWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 421 {
 422   //process particles from diff events (fills denominator)
 423   trackpair = CheckPair(trackpair);
 424   partpair  = CheckPair(partpair);
 425   if ( trackpair && partpair)
 426   {
 427      fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
 428   }
 429 }
 430 /**************************************************************/
 431 TH1* AliHBTWeightQSideQLongFctn::GetResult()
 432 {
 433   //returns result
 434   return GetRatio(Scale());
 435 }