Scaling to tail implemented

diff --git a/HBTAN/AliHBTFunction.cxx b/HBTAN/AliHBTFunction.cxx
index a80843f6ff26f445646f28de8aba8f374a66f5f0..a9cdaed851972aa0a506e5a4f7b14fc59a1e24c2 100644 (file)
--- a/HBTAN/AliHBTFunction.cxx
+++ b/HBTAN/AliHBTFunction.cxx
@@ -27,6 +27,7 @@ Base classes for HBT functions
 /******************************************************************/
 /******************************************************************/
 
+#include <iostream.h>
 ClassImp( AliHBTFunction )
 
 AliHBTFunction::AliHBTFunction()
@@ -41,18 +42,26 @@ Write()
    if (GetNumerator()) GetNumerator()->Write();
    if (GetDenominator()) GetDenominator()->Write();
    TH1* res = GetResult();
-   if (res) GetResult()->Write();
+   if (res) res->Write();
  }
 /******************************************************************/
 
 TH1* AliHBTFunction::
 GetRatio(Double_t normfactor)
  {
+   //if (gDebug>0) 
+   cout<<"Mormfactor is "<<normfactor<<" for "<<fName<<endl;
+   
+   if (normfactor == 0.0)
+    {
+      Error("GetRatio","Scaling Factor is 0. Null poiner returned");
+      return 0x0;
+    }
    TString str = fName + " ratio";
    TH1 *result = (TH1*)GetNumerator()->Clone(str.Data());
    
    result->SetTitle(str.Data());
-   result->Sumw2();
+   //result->Sumw2();
    
    result->Divide(GetNumerator(),GetDenominator(),normfactor);
    
@@ -169,6 +178,8 @@ AliHBTTwoPartFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval)
    fNumerator->Sumw2();
    fDenominator->Sumw2();
    
+   fNBinsToScale = 30;
+   
  }
 /******************************************************************/
 AliHBTTwoPartFctn1D::~AliHBTTwoPartFctn1D()
@@ -176,6 +187,76 @@ AliHBTTwoPartFctn1D::~AliHBTTwoPartFctn1D()
   delete fNumerator;
   delete fDenominator;
 }
+/******************************************************************/
+
+void AliHBTTwoPartFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
+{
+ //Fills the numerator
+   pair = CheckPair(pair);
+   if(pair) fNumerator->Fill(GetValue(pair));
+}
+/******************************************************************/
+void AliHBTTwoPartFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
+ {
+  //fills denumerator
+   pair = CheckPair(pair);
+   if(pair) fDenominator->Fill(GetValue(pair));
+
+  }
+/******************************************************************/
+Double_t AliHBTTwoPartFctn1D::Scale()
+{
+  if(!fNumerator) 
+   {
+     Error("Scale","No numerator");
+     return 0.0;
+   }
+  if(!fDenominator) 
+   {
+     Error("Scale","No denominator");
+     return 0.0;
+   }
+  
+  if(fNBinsToScale < 1) 
+   {
+    return 0.0;
+    Error("Scale","Number of bins for scaling is smaller thnan 1");
+   }
+  Int_t nbins = fNumerator->GetNbinsX();
+  if (fNBinsToScale > nbins) 
+   {
+    Error("Scale","Number of bins for scaling is bigger thnan number of bins in histograms");
+    return 0.0;
+   }
+  Double_t ratios[fNBinsToScale];
+
+  Int_t offset = nbins - fNBinsToScale - 1; 
+  Int_t i;
+  for ( i = offset; i< nbins; i++)
+   {
+    if ( fNumerator->GetBinContent(i) == 0.0 )
+     {
+       ratios[i - offset] = -1.0; //since we play with histograms negative is impossible 
+                                  //so it is good flag
+     }
+    else
+     {
+       ratios[i - offset] = fDenominator->GetBinContent(i)/fNumerator->GetBinContent(i);
+     }
+   }
+ 
+  Double_t sum = 0;
+  Int_t skipped = 0;
+  for (i = 0; i<fNBinsToScale; i++)
+   {
+    if (ratios[i] == -1.0) skipped++;
+    else sum += ratios[i];
+   }
+  cout<<"sum="<<sum<<" fNBinsToScale="<<fNBinsToScale<<" skipped="<<skipped<<endl;
+
+  return sum/(Double_t)(fNBinsToScale - skipped);
+} 
+
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/

diff --git a/HBTAN/AliHBTFunction.h b/HBTAN/AliHBTFunction.h
index d45571bbde26c83bfe6a710583c165dad2cffd45..d387a11801ec6029b2f6472b97497d9e00c6d59a 100644 (file)
--- a/HBTAN/AliHBTFunction.h
+++ b/HBTAN/AliHBTFunction.h
@@ -18,12 +18,12 @@ class AliHBTFunction: public TNamed
 {
   public:
     AliHBTFunction();
-    virtual ~AliHBTFunction(){}
+    virtual ~AliHBTFunction(){delete fPairCut;}
     
     virtual TH1* GetNumerator() =0;
     virtual TH1* GetDenominator() =0;
     virtual TH1* GetResult() = 0;
-    
+
     virtual void Write();
     
     TH1* GetRatio(Double_t normfactor = 1.0);
@@ -41,6 +41,7 @@ class AliHBTFunction: public TNamed
   public:  
    ClassDef(AliHBTFunction,1)
 };
+/******************************************************************/
 inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
 {
   //check if pair and both particles meets the cut criteria
@@ -55,8 +56,6 @@ inline AliHBTPair* AliHBTFunction::CheckPair(AliHBTPair* pair)
   return pair; 
 }
 
-
-
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
@@ -68,7 +67,8 @@ class AliHBTTwoPartFctn: public AliHBTFunction
     
     virtual void ProcessSameEventParticles(AliHBTPair* pair) = 0;
     virtual void ProcessDiffEventParticles(AliHBTPair* pair) = 0;
-    
+
+
     
   protected:
   public:  
@@ -88,6 +88,7 @@ class AliHBTFourPartFctn: public AliHBTFunction
     ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
     virtual void 
     ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
+
             
   protected:
   public:  
@@ -111,35 +112,20 @@ class AliHBTTwoPartFctn1D: public AliHBTTwoPartFctn
 
   void ProcessSameEventParticles(AliHBTPair* pair);
   void ProcessDiffEventParticles(AliHBTPair* pair);
-  
+  Double_t Scale();  
+  void SetNumberOfBinsToScale();
  protected:
   //retruns velue to be histogrammed
   virtual Double_t GetValue(AliHBTPair* pair) = 0; 
-  
+
   TH1D* fNumerator;
   TH1D* fDenominator;
+  Int_t fNBinsToScale;
   
  public:
-  ClassDef(AliHBTTwoPartFctn1D,1)
+  ClassDef(AliHBTTwoPartFctn1D,2)
 };
 
-inline void 
-AliHBTTwoPartFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
-{
- //Fills the numerator
-   pair = CheckPair(pair);
-   if(pair) fNumerator->Fill(GetValue(pair));
-}
-  
-  
-inline void
-AliHBTTwoPartFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
- {
-  //fills denumerator
-   pair = CheckPair(pair);
-   if(pair) fDenominator->Fill(GetValue(pair));
-
-  }
 /******************************************************************/
 /******************************************************************/
 /******************************************************************/
@@ -157,9 +143,10 @@ class AliHBTTwoPartFctn2D: public AliHBTTwoPartFctn
   void ProcessSameEventParticles(AliHBTPair* pair);
   void ProcessDiffEventParticles(AliHBTPair* pair);
  
-  virtual void GetValues(AliHBTPair* pair, Double_t&, Double_t&) = 0;
-  
+
  protected:
+  virtual void GetValues(AliHBTPair* pair, Double_t&, Double_t&) = 0;
+
   TH2D* fNumerator;
   TH2D* fDenominator;
   
@@ -210,9 +197,10 @@ class AliHBTFourPartFctn2D: public AliHBTFourPartFctn
   void ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
   void ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
  
-  virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&) = 0;
   
  protected:
+  virtual void GetValues(AliHBTPair*,AliHBTPair*, Double_t&, Double_t&) = 0;
+
   TH2D* fNumerator;
   TH2D* fDenominator;