HBTAN/AliHBTLLWeightFctn.cxx

   1 #include "AliHBTLLWeightFctn.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 "AliHBTLLWeightsPID.h"
  16
  17 //--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
  18
  19 ClassImp( AliHBTLLWeightQInvFctn )
  20
  21
  22 /****************************************************************/
  23 AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(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  AliHBTLLWeightQInvFctn::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 weightHBT=partpair->GetLLWeight();
  40     Double_t weight=weightHBT*weightPID;
  41     if(TMath::Abs(weight)<=10.)fNumerator->Fill(trackpair->GetQInv(),weight);
  42   }
  43 }
  44 /****************************************************************/
  45
  46 void  AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
  47 {
  48   // Fills the denominator using mixed pairs
  49   trackpair = CheckPair(trackpair);
  50   partpair  = CheckPair(partpair);
  51   if ( trackpair && partpair)
  52   {
  53      fDenominator->Fill(trackpair->GetQInv());
  54   }
  55 }
  56 /**************************************************************/
  57 TH1* AliHBTLLWeightQInvFctn::GetResult()
  58 {
  59 //returns ratio of numerator and denominator
  60  return GetRatio(Scale());
  61 }
  62
  63 /**************************************************************************************/
  64 /**************************************************************************************/
  65 /**************************************************************************************/
  66 /**************************************************************************************/
  67
  68 ClassImp(AliHBTLLWeightQOutFctn)
  69
  70 AliHBTLLWeightQOutFctn::AliHBTLLWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
  71  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
  72 {
  73 //ctor
  74  fWriteNumAndDen = kTRUE;//change default behaviour
  75  Rename("wqoutcf","Q_{out} Weight Correlation Function");
  76 }
  77 /****************************************************************/
  78 void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
  79 {
  80   //process particles from same events (fills numerator)
  81   trackpair = CheckPair(trackpair);
  82   partpair  = CheckPair(partpair);
  83   if ( trackpair && partpair)
  84   {
  85     Double_t weightPID=1.;
  86     Double_t weightHBT=partpair->GetLLWeight();
  87     Double_t weight=weightHBT*weightPID;
  88     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQOutCMSLC(),weight);
  89   }
  90 }
  91 /****************************************************************/
  92
  93 void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
  94 {
  95   //process particles from diff events (fills denominator)
  96   trackpair = CheckPair(trackpair);
  97   partpair  = CheckPair(partpair);
  98   if ( trackpair && partpair)
  99   {
 100      fDenominator->Fill(trackpair->GetQOutCMSLC());
 101   }
 102 }
 103 /**************************************************************/
 104 TH1* AliHBTLLWeightQOutFctn::GetResult()
 105
 106 {
 107 //returns ratio of numerator and denominator
 108  return GetRatio(Scale());
 109 }
 110
 111 /*************************************************************************************/
 112 /*************************************************************************************/
 113 /*************************************************************************************/
 114
 115 ClassImp(AliHBTLLWeightQLongFctn)
 116 AliHBTLLWeightQLongFctn::AliHBTLLWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 117  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 118 {
 119 //ctor
 120  fWriteNumAndDen = kTRUE;//change default behaviour
 121  Rename("wqlongcf","Q_{long} Weight Correlation Function");
 122 }
 123 /****************************************************************/
 124 void AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 125 {
 126   //process particles from same events (fills numerator)
 127   trackpair = CheckPair(trackpair);
 128   partpair  = CheckPair(partpair);
 129   if ( trackpair && partpair)
 130   {
 131     Double_t weightPID=1.;
 132     Double_t weightHBT=partpair->GetLLWeight();
 133     Double_t weight=weightHBT*weightPID;
 134     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQLongCMSLC(),weight);
 135   }
 136 }
 137 /****************************************************************/
 138
 139 void AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 140 {
 141   //process particles from diff events (fills denominator)
 142   trackpair = CheckPair(trackpair);
 143   partpair  = CheckPair(partpair);
 144   if ( trackpair && partpair)
 145   {
 146      fDenominator->Fill(trackpair->GetQLongCMSLC());
 147   }
 148 }
 149 /**************************************************************/
 150 TH1* AliHBTLLWeightQLongFctn::GetResult()
 151
 152 {
 153 //returns ratio of numerator and denominator
 154  return GetRatio(Scale());
 155 }
 156
 157 /*************************************************************************************/
 158 /*************************************************************************************/
 159 /*************************************************************************************/
 160
 161 ClassImp(AliHBTLLWeightQSideFctn)
 162 /*************************************************************************************/
 163
 164 AliHBTLLWeightQSideFctn::AliHBTLLWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 165  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 166 {
 167 //ctor
 168  fWriteNumAndDen = kTRUE;//change default behaviour
 169  Rename("wqsidecf","Q_{side} Weight Correlation Function");
 170 }
 171 /****************************************************************/
 172 void AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 173 {
 174   //process particles from same events (fills numerator)
 175   trackpair = CheckPair(trackpair);
 176   partpair  = CheckPair(partpair);
 177   if ( trackpair && partpair)
 178   {
 179     Double_t weightPID=1.;
 180     Double_t weightHBT=partpair->GetLLWeight();
 181     Double_t weight=weightHBT*weightPID;
 182     if(TMath::Abs(weight)<=10.) fNumerator->Fill(trackpair->GetQSideCMSLC(),weight);
 183   }
 184 }
 185 /****************************************************************/
 186
 187 void  AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 188 {
 189   //process particles from diff events (fills denominator)
 190   trackpair = CheckPair(trackpair);
 191   partpair  = CheckPair(partpair);
 192   if ( trackpair && partpair)
 193   {
 194      fDenominator->Fill(trackpair->GetQSideCMSLC());
 195   }
 196 }
 197 /**************************************************************/
 198 TH1* AliHBTLLWeightQSideFctn::GetResult()
 199
 200 {
 201 //returns ratio of numerator and denominator
 202  return GetRatio(Scale());
 203 }
 204
 205 /*************************************************************************************/
 206 /*************************************************************************************/
 207 /*************************************************************************************/
 208
 209 ClassImp(AliHBTLLWeightTwoKStarFctn)
 210 /*************************************************************************************/
 211 AliHBTLLWeightTwoKStarFctn::AliHBTLLWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
 212  AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 213 {
 214 //ctor
 215  fWriteNumAndDen = kTRUE;//change default behaviour
 216  Rename("wtwokstarcf","2*K^{*} Weight Correlation Function");
 217 }
 218 /****************************************************************/
 219 void AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 220 {
 221   //process particles from same events (fills numerator)
 222   trackpair = CheckPair(trackpair);
 223   partpair  = CheckPair(partpair);
 224   if ( trackpair && partpair)
 225   {
 226     Double_t weightPID=1.;
 227     Double_t weightHBT=partpair->GetLLWeight();
 228     Double_t weight=weightHBT*weightPID;
 229     if(TMath::Abs(weight)<=10.) fNumerator->Fill(2.0*(trackpair->GetKStar()),weight);
 230   }
 231 }
 232 /****************************************************************/
 233
 234 void  AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 235 {
 236   //process particles from diff events (fills denominator)
 237   trackpair = CheckPair(trackpair);
 238   partpair  = CheckPair(partpair);
 239   if ( trackpair && partpair)
 240   {
 241      fDenominator->Fill(2.0*(trackpair->GetKStar()));
 242   }
 243 }
 244 /**************************************************************/
 245 TH1* AliHBTLLWeightTwoKStarFctn::GetResult()
 246
 247 {
 248 //returns ratio of numerator and denominator
 249  return GetRatio(Scale());
 250 }
 251
 252 /*************************************************************************************/
 253 /*************************************************************************************/
 254 /*************************************************************************************/
 255
 256 ClassImp(AliHBTLLWeightQOutQSideFctn)
 257 /*************************************************************************************/
 258
 259 AliHBTLLWeightQOutQSideFctn::AliHBTLLWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
 260                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
 261  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
 262 {
 263   //ctor
 264  fWriteNumAndDen = kTRUE;//change default behaviour
 265  Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
 266 }
 267 /*************************************************************************************/
 268 void AliHBTLLWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 269 {
 270   //process particles from same events (fills numerator)
 271   trackpair = CheckPair(trackpair);
 272   partpair  = CheckPair(partpair);
 273   if ( trackpair && partpair)
 274   {
 275     Double_t weightPID=1.;
 276     Double_t weightHBT=partpair->GetLLWeight();
 277     Double_t weight=weightHBT*weightPID;
 278     if(TMath::Abs(weight)<=10.)
 279       fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
 280   }
 281 }
 282 /****************************************************************/
 283
 284 void AliHBTLLWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 285 {
 286   //process particles from diff events (fills denominator)
 287   trackpair = CheckPair(trackpair);
 288   partpair  = CheckPair(partpair);
 289   if ( trackpair && partpair)
 290   {
 291      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
 292   }
 293 }
 294 /**************************************************************/
 295 TH1* AliHBTLLWeightQOutQSideFctn::GetResult()
 296 {
 297   //returns result
 298   return GetRatio(Scale());
 299 }
 300
 301 /*************************************************************************************/
 302 /*************************************************************************************/
 303 /*************************************************************************************/
 304
 305 ClassImp(AliHBTLLWeightQOutQLongFctn)
 306 /*************************************************************************************/
 307
 308 AliHBTLLWeightQOutQLongFctn::AliHBTLLWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
 309                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
 310  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
 311 {
 312   //ctor
 313  fWriteNumAndDen = kTRUE;//change default behaviour
 314  Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
 315 }
 316 /*************************************************************************************/
 317 void AliHBTLLWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 318 {
 319   //process particles from same events (fills numerator)
 320   trackpair = CheckPair(trackpair);
 321   partpair  = CheckPair(partpair);
 322   if ( trackpair && partpair)
 323   {
 324     Double_t weightPID=1.;
 325     Double_t weightHBT=partpair->GetLLWeight();
 326     Double_t weight=weightHBT*weightPID;
 327     if(TMath::Abs(weight)<=10.)
 328       fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
 329   }
 330 }
 331 /****************************************************************/
 332
 333 void AliHBTLLWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 334 {
 335   //process particles from diff events (fills denominator)
 336   trackpair = CheckPair(trackpair);
 337   partpair  = CheckPair(partpair);
 338   if ( trackpair && partpair)
 339   {
 340      fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
 341   }
 342 }
 343 /**************************************************************/
 344
 345 TH1* AliHBTLLWeightQOutQLongFctn::GetResult()
 346 {
 347   //returns result
 348   return GetRatio(Scale());
 349 }
 350
 351 /*************************************************************************************/
 352 /*************************************************************************************/
 353 /*************************************************************************************/
 354
 355 ClassImp(AliHBTLLWeightQSideQLongFctn)
 356 /*************************************************************************************/
 357
 358 AliHBTLLWeightQSideQLongFctn::AliHBTLLWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
 359                                                          Int_t nybins, Double_t maxYval, Double_t minYval):
 360  AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
 361 {
 362   //ctor
 363  fWriteNumAndDen = kTRUE;//change default behaviour
 364  Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
 365 }
 366 /*************************************************************************************/
 367 void AliHBTLLWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 368 {
 369   //process particles from same events (fills numerator)
 370   trackpair = CheckPair(trackpair);
 371   partpair  = CheckPair(partpair);
 372   if ( trackpair && partpair)
 373   {
 374     Double_t weightPID=1.;
 375     Double_t weightHBT=partpair->GetLLWeight();
 376     Double_t weight=weightHBT*weightPID;
 377     if(TMath::Abs(weight)<=10.)
 378       fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
 379   }
 380 }
 381 /****************************************************************/
 382
 383 void AliHBTLLWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 384 {
 385   //process particles from diff events (fills denominator)
 386   trackpair = CheckPair(trackpair);
 387   partpair  = CheckPair(partpair);
 388   if ( trackpair && partpair)
 389   {
 390      fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
 391   }
 392 }
 393 /**************************************************************/
 394 TH1* AliHBTLLWeightQSideQLongFctn::GetResult()
 395 {
 396   //returns result
 397   return GetRatio(Scale());
 398 }