LL Weights Out Side Long Theoretical Functions and 2D Corr Fctns implemented
authorskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Aug 2003 14:43:04 +0000 (14:43 +0000)
committerskowron <skowron@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Aug 2003 14:43:04 +0000 (14:43 +0000)
HBTAN/AliHBTLLWeightFctn.cxx
HBTAN/AliHBTLLWeightFctn.h
HBTAN/AliHBTLLWeightTheorFctn.cxx
HBTAN/AliHBTLLWeightTheorFctn.h
HBTAN/HBTAnalysisLinkDef.h

index 0cc61f4..41c05b7 100644 (file)
@@ -1,5 +1,9 @@
+#include "AliHBTLLWeightFctn.h"
 /* $Id$ */
-
+//_________________________________________________________________________
+//
+// class 
+//
 //This class allows to obtain Q_inv correlation function with weights
 //calculated by Lednicky's alghorithm.
 //Numerator is filled with weighted events. Weights are attributed to reconstructed tracks.
@@ -8,7 +12,6 @@
 //One needs both pairs 
 //(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
 //Author: Ludmila Malinina, JINR (malinina@sunhe.jinr.ru)
-#include "AliHBTLLWeightFctn.h"
 #include "AliHBTLLWeights.h"
 #include "AliHBTLLWeightsPID.h"
 
@@ -19,14 +22,16 @@ ClassImp( AliHBTLLWeightQInvFctn )
   
 /****************************************************************/
 AliHBTLLWeightQInvFctn::AliHBTLLWeightQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
-           AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
+ AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
 {
 //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqinvcf","Q_{inv} Weight Correlation Function");
 }
 /****************************************************************/
 void  AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
-//Processes Particles and tracks Same different even
+  //process particles from same events (fills numerator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)     
@@ -50,8 +55,7 @@ void  AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, A
   }
 }
 /**************************************************************/
-TH1* AliHBTLLWeightQInvFctn::GetResult() 
-                                                                               
+TH1* AliHBTLLWeightQInvFctn::GetResult()
 { 
 //returns ratio of numerator and denominator                                    
  return GetRatio(Scale());                                                  
@@ -63,9 +67,18 @@ TH1* AliHBTLLWeightQInvFctn::GetResult()
 /**************************************************************************************/
 
 ClassImp(AliHBTLLWeightQOutFctn)
+    
+AliHBTLLWeightQOutFctn::AliHBTLLWeightQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
+{
+//ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqoutcf","Q_{out} Weight Correlation Function");
+}
 /****************************************************************/
 void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  //process particles from same events (fills numerator)  
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)     
@@ -80,6 +93,7 @@ void AliHBTLLWeightQOutFctn::ProcessSameEventParticles(AliHBTPair* trackpair, Al
 
 void AliHBTLLWeightQOutFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  //process particles from diff events (fills denominator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)  
@@ -100,10 +114,17 @@ TH1* AliHBTLLWeightQOutFctn::GetResult()
 /*************************************************************************************/ 
 
 ClassImp(AliHBTLLWeightQLongFctn)
+AliHBTLLWeightQLongFctn::AliHBTLLWeightQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
+{
+//ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqlongcf","Q_{long} Weight Correlation Function");
+}
 /****************************************************************/
-void  AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
-//Processes Particles and tracks Same different even
+  //process particles from same events (fills numerator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)     
@@ -116,8 +137,9 @@ void  AliHBTLLWeightQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair,
 } 
 /****************************************************************/
 
-void  AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTLLWeightQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  //process particles from diff events (fills denominator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)  
@@ -138,10 +160,19 @@ TH1* AliHBTLLWeightQLongFctn::GetResult()
 /*************************************************************************************/ 
 
 ClassImp(AliHBTLLWeightQSideFctn)
+/*************************************************************************************/ 
+
+AliHBTLLWeightQSideFctn::AliHBTLLWeightQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
+{
+//ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqsidecf","Q_{side} Weight Correlation Function");
+}
 /****************************************************************/
-void  AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
-//Processes Particles and tracks Same different even
+  //process particles from same events (fills numerator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)     
@@ -156,6 +187,7 @@ void  AliHBTLLWeightQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair,
 
 void  AliHBTLLWeightQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  //process particles from diff events (fills denominator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)  
@@ -173,12 +205,21 @@ TH1* AliHBTLLWeightQSideFctn::GetResult()
                                                               
 /*************************************************************************************/ 
 /*************************************************************************************/ 
+/*************************************************************************************/ 
 
 ClassImp(AliHBTLLWeightTwoKStarFctn)
+/*************************************************************************************/ 
+AliHBTLLWeightTwoKStarFctn::AliHBTLLWeightTwoKStarFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+ AliHBTTwoPairFctn1D(nbins,maxXval,minXval)
+{
+//ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wtwokstarcf","2*K^{*} Weight Correlation Function");
+}
 /****************************************************************/
-void  AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+void AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
-//Processes Particles and tracks Same different even
+  //process particles from same events (fills numerator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)     
@@ -193,6 +234,7 @@ void  AliHBTLLWeightTwoKStarFctn::ProcessSameEventParticles(AliHBTPair* trackpai
 
 void  AliHBTLLWeightTwoKStarFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  //process particles from diff events (fills denominator)
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)  
@@ -209,4 +251,149 @@ TH1* AliHBTLLWeightTwoKStarFctn::GetResult()
 }                    
                                                               
 /*************************************************************************************/ 
+/*************************************************************************************/ 
+/*************************************************************************************/ 
+
+ClassImp(AliHBTLLWeightQOutQSideFctn)
+/*************************************************************************************/ 
+    
+AliHBTLLWeightQOutQSideFctn::AliHBTLLWeightQOutQSideFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
+                                                         Int_t nybins, Double_t maxYval, Double_t minYval):
+ AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
+{
+  //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqoutqsidecf","Q_{out} Q_{side} Weight Correlation Function 2D");
+}    
+/*************************************************************************************/ 
+void AliHBTLLWeightQOutQSideFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  //process particles from same events (fills numerator)
+  trackpair = CheckPair(trackpair);
+  partpair  = CheckPair(partpair);
+  if ( trackpair && partpair)     
+  {
+    Double_t weightPID=1.;
+    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
+    Double_t weight=weightHBT*weightPID;
+    if(TMath::Abs(weight)<=10.) 
+      fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC(),weight);
+  }
+} 
+/****************************************************************/
+
+void AliHBTLLWeightQOutQSideFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  //process particles from diff events (fills denominator)
+  trackpair = CheckPair(trackpair);
+  partpair  = CheckPair(partpair);
+  if ( trackpair && partpair)  
+  {
+     fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQSideCMSLC());
+  }
+}
+/**************************************************************/
+TH1* AliHBTLLWeightQOutQSideFctn::GetResult()
+{
+  //returns result
+  return GetRatio(Scale());
+}
+
+/*************************************************************************************/ 
+/*************************************************************************************/ 
+/*************************************************************************************/ 
+
+ClassImp(AliHBTLLWeightQOutQLongFctn)
+/*************************************************************************************/ 
+    
+AliHBTLLWeightQOutQLongFctn::AliHBTLLWeightQOutQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
+                                                         Int_t nybins, Double_t maxYval, Double_t minYval):
+ AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
+{
+  //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqoutqlongcf","Q_{out} Q_{long} Weight Correlation Function 2D");
+}    
+/*************************************************************************************/ 
+void AliHBTLLWeightQOutQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  //process particles from same events (fills numerator)
+  trackpair = CheckPair(trackpair);
+  partpair  = CheckPair(partpair);
+  if ( trackpair && partpair)     
+  {
+    Double_t weightPID=1.;
+    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
+    Double_t weight=weightHBT*weightPID;
+    if(TMath::Abs(weight)<=10.) 
+      fNumerator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC(),weight);
+  }
+} 
+/****************************************************************/
+
+void AliHBTLLWeightQOutQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  //process particles from diff events (fills denominator)
+  trackpair = CheckPair(trackpair);
+  partpair  = CheckPair(partpair);
+  if ( trackpair && partpair)  
+  {
+     fDenominator->Fill(trackpair->GetQOutCMSLC(),trackpair->GetQLongCMSLC());
+  }
+}
+/**************************************************************/
+
+TH1* AliHBTLLWeightQOutQLongFctn::GetResult()
+{
+  //returns result
+  return GetRatio(Scale());
+}
+
+/*************************************************************************************/ 
+/*************************************************************************************/ 
+/*************************************************************************************/ 
 
+ClassImp(AliHBTLLWeightQSideQLongFctn)
+/*************************************************************************************/ 
+    
+AliHBTLLWeightQSideQLongFctn::AliHBTLLWeightQSideQLongFctn(Int_t nxbins, Double_t maxXval, Double_t minXval,
+                                                         Int_t nybins, Double_t maxYval, Double_t minYval):
+ AliHBTTwoPairFctn2D(nxbins,maxXval,minXval,nybins,maxYval,minYval)
+{
+  //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqsideqlongcf","Q_{side} Q_{long} Weight Correlation Function 2D");
+}    
+/*************************************************************************************/ 
+void AliHBTLLWeightQSideQLongFctn::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  //process particles from same events (fills numerator)
+  trackpair = CheckPair(trackpair);
+  partpair  = CheckPair(partpair);
+  if ( trackpair && partpair)     
+  {
+    Double_t weightPID=1.;
+    Double_t weightHBT=AliHBTLLWeights::Instance()->GetWeight(partpair);
+    Double_t weight=weightHBT*weightPID;
+    if(TMath::Abs(weight)<=10.) 
+      fNumerator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC(),weight);
+  }
+} 
+/****************************************************************/
+
+void AliHBTLLWeightQSideQLongFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
+{
+  //process particles from diff events (fills denominator)
+  trackpair = CheckPair(trackpair);
+  partpair  = CheckPair(partpair);
+  if ( trackpair && partpair)  
+  {
+     fDenominator->Fill(trackpair->GetQSideCMSLC(),trackpair->GetQLongCMSLC());
+  }
+}
+/**************************************************************/
+TH1* AliHBTLLWeightQSideQLongFctn::GetResult()
+{
+  //returns result
+  return GetRatio(Scale());
+}
index 2505073..3b88e09 100644 (file)
@@ -28,8 +28,7 @@ class AliHBTLLWeightQOutFctn: public AliHBTTwoPairFctn1D
 
   //  friend class AliHBTOnePairFctn1D;
  public:
-  AliHBTLLWeightQOutFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0):
-    AliHBTTwoPairFctn1D(nbins,maxXval,minXval){}
+  AliHBTLLWeightQOutFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTLLWeightQOutFctn(){};
   TH1* GetResult();
  protected:
@@ -42,12 +41,12 @@ class AliHBTLLWeightQOutFctn: public AliHBTTwoPairFctn1D
  
 };
 /*************************************************************************************/ 
+  
 class AliHBTLLWeightQLongFctn: public AliHBTTwoPairFctn1D
 {
   //  friend class AliHBTOnePairFctn1D;
  public:
-  AliHBTLLWeightQLongFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0):
-    AliHBTTwoPairFctn1D(nbins,maxXval,minXval){}
+  AliHBTLLWeightQLongFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTLLWeightQLongFctn(){};
   TH1* GetResult();
  protected:
@@ -60,12 +59,12 @@ class AliHBTLLWeightQLongFctn: public AliHBTTwoPairFctn1D
  
 };
 /*************************************************************************************/ 
+  
 class AliHBTLLWeightQSideFctn: public AliHBTTwoPairFctn1D
 {
   // friend class AliHBTOnePairFctn1D;
  public:
-  AliHBTLLWeightQSideFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0):
-    AliHBTTwoPairFctn1D(nbins,maxXval,minXval){}
+  AliHBTLLWeightQSideFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTLLWeightQSideFctn(){};
   TH1* GetResult();
  protected:
@@ -78,12 +77,12 @@ class AliHBTLLWeightQSideFctn: public AliHBTTwoPairFctn1D
   ClassDef(AliHBTLLWeightQSideFctn,1) 
 };
 /*************************************************************************************/ 
+  
 class AliHBTLLWeightTwoKStarFctn: public AliHBTTwoPairFctn1D
 {
   // friend class AliHBTOnePairFctn1D;
  public:
-  AliHBTLLWeightTwoKStarFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0):
-    AliHBTTwoPairFctn1D(nbins,maxXval,minXval){}
+  AliHBTLLWeightTwoKStarFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
   virtual ~AliHBTLLWeightTwoKStarFctn(){};
   TH1* GetResult();
  protected:
@@ -95,4 +94,63 @@ class AliHBTLLWeightTwoKStarFctn: public AliHBTTwoPairFctn1D
   ClassDef(AliHBTLLWeightTwoKStarFctn,1) 
 
 };
+/*************************************************************************************/ 
+
+class AliHBTLLWeightQOutQSideFctn: public AliHBTTwoPairFctn2D
+{
+
+  //  friend class AliHBTOnePairFctn1D;
+ public:
+  AliHBTLLWeightQOutQSideFctn(Int_t nxbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
+                              Int_t nybins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0);
+  virtual ~AliHBTLLWeightQOutQSideFctn(){};
+  TH1* GetResult();
+ protected:
+  void   ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+  void   ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+      
+  void GetValues(AliHBTPair* /*trackpair*/, AliHBTPair* /*partpair*/, Double_t& /*x*/, Double_t& /*y*/){}
+  ClassDef(AliHBTLLWeightQOutQSideFctn,1)
+};
+/*************************************************************************************/ 
+
+class AliHBTLLWeightQOutQLongFctn: public AliHBTTwoPairFctn2D
+{
+
+  //  friend class AliHBTOnePairFctn1D;
+ public:
+  AliHBTLLWeightQOutQLongFctn(Int_t nxbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
+                              Int_t nybins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0);
+  virtual ~AliHBTLLWeightQOutQLongFctn(){};
+  TH1* GetResult();
+ protected:
+  void   ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+  void   ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+      
+  void GetValues(AliHBTPair* /*trackpair*/, AliHBTPair* /*partpair*/, Double_t& /*x*/, Double_t& /*y*/){}
+  ClassDef(AliHBTLLWeightQOutQLongFctn,1)
+};
+
+/*************************************************************************************/ 
+
+class AliHBTLLWeightQSideQLongFctn: public AliHBTTwoPairFctn2D
+{
+
+  //  friend class AliHBTOnePairFctn1D;
+ public:
+  AliHBTLLWeightQSideQLongFctn(Int_t nxbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0,
+                              Int_t nybins = 100, Double_t maxYval = 0.15, Double_t minYval = 0.0);
+  virtual ~AliHBTLLWeightQSideQLongFctn(){};
+  TH1* GetResult();
+ protected:
+  void   ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+  void   ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
+      
+  void GetValues(AliHBTPair* /*trackpair*/, AliHBTPair* /*partpair*/, Double_t& /*x*/, Double_t& /*y*/){}
+  ClassDef(AliHBTLLWeightQSideQLongFctn,1)
+};
+
 #endif
index 3aa7a9c..b74e20f 100644 (file)
@@ -11,6 +11,9 @@
 #include "AliHBTLLWeights.h"
 
 //--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
+/*************************************************************/
+/*************************************************************/
+/*************************************************************/
 
 ClassImp(AliHBTLLWeightTheorQInvFctn)  
 /*************************************************************/
@@ -20,6 +23,8 @@ AliHBTLLWeightTheorQInvFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
   AliHBTOnePairFctn1D(nbins,maxXval,minXval)
 {
   //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqinvtheorcf","Q_{inv} Weight Theoretical Correlation Function");
 }
 /****************************************************************/
 void  AliHBTLLWeightTheorQInvFctn::ProcessSameEventParticles(AliHBTPair* partpair)
@@ -37,3 +42,95 @@ TH1* AliHBTLLWeightTheorQInvFctn::GetResult()
   return GetRatio(Scale());
 }                    
                                                               
+/*************************************************************/
+/*************************************************************/
+/*************************************************************/
+
+ClassImp(AliHBTLLWeightTheorQOutFctn)  
+/*************************************************************/
+
+AliHBTLLWeightTheorQOutFctn::
+AliHBTLLWeightTheorQOutFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+  AliHBTOnePairFctn1D(nbins,maxXval,minXval)
+{
+  //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqouttheorcf","Q_{out} Weight Theoretical Correlation Function");
+}
+/****************************************************************/
+void  AliHBTLLWeightTheorQOutFctn::ProcessSameEventParticles(AliHBTPair* partpair)
+{
+  //Processes Particles and tracks Same different even
+  partpair  = CheckPair(partpair);
+  Double_t weight = AliHBTLLWeights::Instance()->GetWeight(partpair);
+  if(TMath::Abs(weight)<=10.) fNumerator->Fill(partpair->GetQOutCMSLC(),weight);
+} 
+
+/**************************************************************/
+TH1* AliHBTLLWeightTheorQOutFctn::GetResult() 
+{
+  //returns ratio of numerator and denominator
+  return GetRatio(Scale());
+}                    
+
+/*************************************************************/
+/*************************************************************/
+/*************************************************************/
+
+ClassImp(AliHBTLLWeightTheorQSideFctn)  
+/*************************************************************/
+
+AliHBTLLWeightTheorQSideFctn::
+AliHBTLLWeightTheorQSideFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+  AliHBTOnePairFctn1D(nbins,maxXval,minXval)
+{
+  //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqsidetheorcf","Q_{side} Weight Theoretical Correlation Function");
+}
+/****************************************************************/
+void  AliHBTLLWeightTheorQSideFctn::ProcessSameEventParticles(AliHBTPair* partpair)
+{
+  //Processes Particles and tracks Same different even
+  partpair  = CheckPair(partpair);
+  Double_t weight = AliHBTLLWeights::Instance()->GetWeight(partpair);
+  if(TMath::Abs(weight)<=10.) fNumerator->Fill(partpair->GetQSideCMSLC(),weight);
+} 
+
+/**************************************************************/
+TH1* AliHBTLLWeightTheorQSideFctn::GetResult() 
+{
+  //returns ratio of numerator and denominator
+  return GetRatio(Scale());
+}                    
+
+/*************************************************************/
+/*************************************************************/
+/*************************************************************/
+
+ClassImp(AliHBTLLWeightTheorQLongFctn)  
+/*************************************************************/
+
+AliHBTLLWeightTheorQLongFctn::
+AliHBTLLWeightTheorQLongFctn(Int_t nbins, Double_t maxXval, Double_t minXval):
+  AliHBTOnePairFctn1D(nbins,maxXval,minXval)
+{
+  //ctor
+ fWriteNumAndDen = kTRUE;//change default behaviour
+ Rename("wqlongtheorcf","Q_{long} Weight Theoretical Correlation Function");
+}
+/****************************************************************/
+void  AliHBTLLWeightTheorQLongFctn::ProcessSameEventParticles(AliHBTPair* partpair)
+{
+  //Processes Particles and tracks Same different even
+  partpair  = CheckPair(partpair);
+  Double_t weight = AliHBTLLWeights::Instance()->GetWeight(partpair);
+  if(TMath::Abs(weight)<=10.) fNumerator->Fill(partpair->GetQLongCMSLC(),weight);
+} 
+
+/**************************************************************/
+TH1* AliHBTLLWeightTheorQLongFctn::GetResult() 
+{
+  //returns ratio of numerator and denominator
+  return GetRatio(Scale());
+}                    
index a18d545..7acd78e 100644 (file)
@@ -30,5 +30,53 @@ class AliHBTLLWeightTheorQInvFctn: public AliHBTOnePairFctn1D
 
   ClassDef(AliHBTLLWeightTheorQInvFctn,1)
 };
-  
+
+class AliHBTLLWeightTheorQOutFctn: public AliHBTOnePairFctn1D
+{
+
+  public:
+  AliHBTLLWeightTheorQOutFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
+  virtual  ~AliHBTLLWeightTheorQOutFctn(){}
+
+  TH1* GetResult(); 
+  void   ProcessSameEventParticles(AliHBTPair* partpair);
+      
+  Double_t GetValue(AliHBTPair* partpair)
+    { return partpair->GetQOutCMSLC();} //isn't used
+
+  ClassDef(AliHBTLLWeightTheorQOutFctn,1)
+};
+
+class AliHBTLLWeightTheorQSideFctn: public AliHBTOnePairFctn1D
+{
+
+  public:
+  AliHBTLLWeightTheorQSideFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
+  virtual  ~AliHBTLLWeightTheorQSideFctn(){}
+
+  TH1* GetResult(); 
+  void   ProcessSameEventParticles(AliHBTPair* partpair);
+      
+  Double_t GetValue(AliHBTPair* partpair)
+    { return partpair->GetQSideCMSLC();} //isn't used
+
+  ClassDef(AliHBTLLWeightTheorQSideFctn,1)
+};
+
+class AliHBTLLWeightTheorQLongFctn: public AliHBTOnePairFctn1D
+{
+
+  public:
+  AliHBTLLWeightTheorQLongFctn(Int_t nbins = 100, Double_t maxXval = 0.15, Double_t minXval = 0.0);
+  virtual  ~AliHBTLLWeightTheorQLongFctn(){}
+
+  TH1* GetResult(); 
+  void   ProcessSameEventParticles(AliHBTPair* partpair);
+      
+  Double_t GetValue(AliHBTPair* partpair)
+    { return partpair->GetQLongCMSLC();} //isn't used
+
+  ClassDef(AliHBTLLWeightTheorQLongFctn,1)
+};
+    
 #endif
index d4d25fa..44f11e7 100644 (file)
 #pragma link C++ class AliHBTLLWeightQSideFctn+;
 #pragma link C++ class AliHBTLLWeightQLongFctn+;
 #pragma link C++ class AliHBTLLWeightTwoKStarFctn+;
+#pragma link C++ class AliHBTLLWeightQOutQSideFctn+;
+#pragma link C++ class AliHBTLLWeightQOutQLongFctn+;
+#pragma link C++ class AliHBTLLWeightQSideQLongFctn+;
+
 #pragma link C++ class AliHBTLLWeightTheorQInvFctn+;
+#pragma link C++ class AliHBTLLWeightTheorQOutFctn+;
+#pragma link C++ class AliHBTLLWeightTheorQSideFctn+;
+#pragma link C++ class AliHBTLLWeightTheorQLongFctn+;
 #pragma link C++ class AliHBTLLWeightsPID+;
 #pragma link C++ class AliHBTPositionRandomizer+;
 #pragma link C++ class AliHBTRndm+;