HBTAN/AliHBTWeightFctn.cxx

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