Corrections to obey the coding conventions
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2003 10:10:52 +0000 (10:10 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2003 10:10:52 +0000 (10:10 +0000)
HBTAN/AliHBTAnalysis.cxx
HBTAN/AliHBTAnalysis.h
HBTAN/AliHBTFunction.cxx
HBTAN/AliHBTFunction.h
HBTAN/AliHBTLLWeightFctn.cxx
HBTAN/AliHBTLLWeightFctn.h

index 6ffb51e..d6656d0 100644 (file)
@@ -85,7 +85,7 @@ AliHBTAnalysis::AliHBTAnalysis(const AliHBTAnalysis& in):
    Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
  }
 /*************************************************************************************/ 
-const AliHBTAnalysis& AliHBTAnalysis::operator=(const AliHBTAnalysis& right)
+AliHBTAnalysis& AliHBTAnalysis::operator=(const AliHBTAnalysis& right)
  {
 //operator =
    Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
index 46254ae..e6dc69a 100644 (file)
@@ -1,6 +1,8 @@
 #ifndef ALIHBTANALYSIS_H
 #define ALIHBTANALYSIS_H
 
+/* $Id$ */
+
 #include <TObject.h>
 
 class AliHBTParticleCut;
@@ -28,7 +30,7 @@ class AliHBTAnalysis: public TObject
    public:
      AliHBTAnalysis();
      AliHBTAnalysis(const AliHBTAnalysis& in);
-     const AliHBTAnalysis& operator=(const AliHBTAnalysis& right);
+     AliHBTAnalysis& operator=(const AliHBTAnalysis& right);
      virtual ~AliHBTAnalysis();
 
      virtual void Process(Option_t* option = "TracksAndParticles");
@@ -107,7 +109,7 @@ class AliHBTAnalysis: public TObject
      static const UInt_t fgkFctnArraySize;//!
      static const UInt_t fgkDefaultMixingInfo;//!
      static const Int_t  fgkDefaultBufferSize;//!
-   public:
+
      ClassDef(AliHBTAnalysis,0)
  };
 
index c34c805..c4840ed 100644 (file)
@@ -1,12 +1,13 @@
 #include "AliHBTFunction.h"
-//____________________
-//////////////////////////////////////////////////////////////////////
-//
+
+/* $Id: */
+
+//--------------------------------------------------------------------
 //AliHBTFunction
 //Author: Piotr Krzysztof Skowronski
 //Piotr.Skowronski@cern.ch
-/*Base classes for HBT functions
-
+//Base classes for HBT functions
+/*
  OnePairFctn       Function                  TwoPairFctn
    | \    \        /  |   \                      /|\   
    |  \    \      /   |    \                    / | \    
    |       / \       \|    |    \        /  \     |  \     \              
    |      /   \      /\    |     \      /    \    |   \     |              
    |     /     \    /  \   |      \    /      \   |    \    |               
-   |    /       \  /    \  |       \  /        \  |     \   |                 
+   |    /       \  /    \  |       \  /        \  |     \   |
    |   /         \/      \ |        \/          \ |      \  |               
  OnePair1D   OnePair2D  OnePair3D  TwoPair1D  TwoPair2D TwoPair3D
 
 
-
  four particle functions are intendent to be resolution functions:
  it is mecessary to have simulated particle pair corresponding to given
  recontructed track pair in order to calculate function simualted value 
  and recontructed value, to be further histogrammed
 */
-/////////////////////////////////////////////////////////////////////// 
+//--------------------------------------------------------------------- 
 
 #include <TH2.h>
 #include <TH3.h>
@@ -418,6 +417,7 @@ void AliHBTFunction2D::BuildHistos()
 void AliHBTFunction2D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
                                    Int_t nybins, Float_t ymax, Float_t ymin)
 {
+  //Builds numerator and denominator histograms (2d-case)
  TString numstr = fName + " Numerator";  //title and name of the 
                                            //numerator histogram
  TString denstr = fName + " Denominator";//title and name of the 
@@ -444,6 +444,9 @@ void AliHBTFunction2D::SetNumberOfBinsToScale(UInt_t xn, UInt_t yn)
 
 Double_t AliHBTFunction2D::Scale()
 {
+  // Calculates the factor that should be used to scale 
+  // quatience of fNumerator and fDenominator to 1 at 
+  // given region
   if (gDebug>0) Info("Scale","Enetered Scale()");
   if(!fNumerator) 
    {
@@ -612,6 +615,7 @@ void AliHBTFunction3D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
                                    Int_t nybins, Float_t ymax, Float_t ymin,
                       Int_t nzbins, Float_t zmax, Float_t zmin)
 {
+  //Builds numerator and denominator histograms (3d-case)
    TString numstr = fName + " Numerator";  //title and name of the 
                                            //numerator histogram
    TString denstr = fName + " Denominator";//title and name of the 
@@ -631,6 +635,9 @@ void AliHBTFunction3D::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
 
 Double_t AliHBTFunction3D::Scale()
 {
+  // Calculates the factor that should be used to scale 
+  // quatience of fNumerator and fDenominator to 1 at 
+  // given volume
   if (gDebug>0) Info("Scale","Enetered Scale()");
   if(!fNumerator) 
    {
@@ -758,14 +765,14 @@ AliHBTOnePairFctn1D::AliHBTOnePairFctn1D(const Char_t *name, const Char_t *title
 
 void AliHBTOnePairFctn1D::ProcessSameEventParticles(AliHBTPair* pair)
 {
- //Fills the numerator
+ //Fills the numerator using pair from the same event
    pair = CheckPair(pair);
    if(pair) fNumerator->Fill(GetValue(pair));
 }
 /******************************************************************/
 void AliHBTOnePairFctn1D::ProcessDiffEventParticles(AliHBTPair* pair)
  {
-  //fills denumerator
+  //Fills the denumerator using mixed pairs
    pair = CheckPair(pair);
    if(pair) fDenominator->Fill(GetValue(pair));
   }
@@ -813,6 +820,7 @@ AliHBTOnePairFctn2D::AliHBTOnePairFctn2D(const Char_t *name, const Char_t *title
 
 void AliHBTOnePairFctn2D::ProcessSameEventParticles(AliHBTPair* pair)
 {
+  // Fills the numerator using pairs from the same event
   pair = CheckPair(pair);
   if(pair) 
    { 
@@ -825,6 +833,7 @@ void AliHBTOnePairFctn2D::ProcessSameEventParticles(AliHBTPair* pair)
 
 void AliHBTOnePairFctn2D::ProcessDiffEventParticles(AliHBTPair* pair)
 {
+  // Fills the denumerator using mixed pairs
   pair = CheckPair(pair);
   if(pair) 
    { 
@@ -944,6 +953,7 @@ AliHBTTwoPairFctn1D::AliHBTTwoPairFctn1D(const Char_t *name, const Char_t *title
 
 void AliHBTTwoPairFctn1D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  // Fills the numerator using pairs from the same event
   partpair  = CheckPair(partpair);
   if( partpair ) 
    { 
@@ -955,6 +965,7 @@ void AliHBTTwoPairFctn1D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHB
 
 void AliHBTTwoPairFctn1D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  // Fills the denumerator usin mixed pairs
   partpair  = CheckPair(partpair);
   if( partpair )
    { 
@@ -1077,6 +1088,7 @@ AliHBTTwoPairFctn3D::AliHBTTwoPairFctn3D(const Char_t *name, const Char_t *title
 
 void AliHBTTwoPairFctn3D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  // Fills th numerator using pairs from the same event
   partpair  = CheckPair(partpair);
   if( partpair ) 
    { 
@@ -1089,6 +1101,7 @@ void AliHBTTwoPairFctn3D::ProcessSameEventParticles(AliHBTPair* trackpair, AliHB
 
 void AliHBTTwoPairFctn3D::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  // Fills the denumerator using mixed pairs
   partpair  = CheckPair(partpair);
   if( partpair ) 
    { 
index 206258e..ba890d4 100644 (file)
@@ -1,6 +1,8 @@
 #ifndef ALIHBTFUNCTION_H
 #define ALIHBTFUNCTION_H
-//____________________
+
+/* Id: $ */
+
 ///////////////////////////////////////////////////////
 //                                                   //
 // AliHBTFunction                                    //
@@ -30,6 +32,18 @@ class AliHBTFunction: public TNamed
     AliHBTFunction(const char* name,const char* title);
     virtual ~AliHBTFunction();
     
+  AliHBTFunction(const AliHBTFunction & source) {
+    // Copy constructor needed by the coding conventions byt not used
+    Fatal("AliHBTFunction(const AliHBTFunction & source)",
+         "not implemented");
+  }
+
+  AliHBTFunction & operator= (const AliHBTFunction & source) {
+    // Assignment needed by the coding conventions byt not used
+    Fatal("Assignment operator","not implemented");
+    return * this;
+  }
+
     virtual TH1* GetNumerator() const = 0;
     virtual TH1* GetDenominator() const = 0;
     virtual TH1* GetResult() = 0;
@@ -49,7 +63,6 @@ class AliHBTFunction: public TNamed
     virtual void BuildHistos() = 0;//builds default histograms
     AliHBTPairCut*   fPairCut;     //pair cut
     
-  public:  
    ClassDef(AliHBTFunction,2)
 };
 /******************************************************************/
@@ -97,8 +110,6 @@ class AliHBTOnePairFctn
     virtual void Init() = 0;
     virtual void Write() = 0;
     
-  protected:
-  public:  
    ClassDef(AliHBTOnePairFctn,2)
 };
 /******************************************************************/
@@ -136,8 +147,6 @@ class AliHBTTwoPairFctn
     virtual void Init() = 0;
     virtual void Write() = 0;
             
-  protected:
-  public:  
    ClassDef(AliHBTTwoPairFctn,2)
   
 };
@@ -160,19 +169,23 @@ class AliHBTTwoPairFctn
 
 class AliHBTFunction1D: public AliHBTFunction
 {
- private:
-  //this must be declared before constructors because they are used as a default arguments
-  static const Int_t fgkDefaultNBins;//default number of Bins in histograms
-  static const Float_t fgkDefaultMin;//Default min value of histograms
-  static const Float_t fgkDefaultMax;//Default max value of histograms
-  static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
-
  public:
   AliHBTFunction1D();//default conmstructor
   AliHBTFunction1D(Int_t nbins, Float_t maxXval, Float_t minXval);
   AliHBTFunction1D(const Char_t *name, const Char_t *title);
   AliHBTFunction1D(const Char_t *name, const Char_t *title,
                    Int_t nbins, Float_t maxXval, Float_t minXval);
+  AliHBTFunction1D(const AliHBTFunction1D & source) {
+    // Copy constructor needed by the coding conventions byt not used
+    Fatal("AliHBTFunction1D(const AliHBTFunction1D & source)",
+         "not implemented");
+  }
+  AliHBTFunction1D & operator= (const AliHBTFunction1D & source) {
+    // Assignment needed by the coding conventions byt not used
+    Fatal("Assignment operator","not implemented");
+    return * this;
+  }
+
   virtual ~AliHBTFunction1D();
   
   TH1* GetNumerator() const {return fNumerator;}//returns numerator histogram
@@ -182,16 +195,22 @@ class AliHBTFunction1D: public AliHBTFunction
   void SetNumberOfBinsToScale(Int_t n = fgkDefaultNBinsToScale){fNBinsToScale = n;}
 
  protected:
-  //retruns velue to be histogrammed
+  //returns value to be histogrammed
   virtual void BuildHistos(Int_t nbins, Float_t max, Float_t min);
   virtual void BuildHistos();
   Double_t Scale(TH1D* num,TH1D* den);
   
-  TH1D* fNumerator;
-  TH1D* fDenominator;
-  UInt_t fNBinsToScale;
+  TH1D* fNumerator; // Numerator histogram
+  TH1D* fDenominator; // Denumerator histogram
+  UInt_t fNBinsToScale; // Number of bins to scale
+
+ private:
+  //this must be declared before constructors because they are used as a default arguments
+  static const Int_t fgkDefaultNBins;//default number of Bins in histograms
+  static const Float_t fgkDefaultMin;//Default min value of histograms
+  static const Float_t fgkDefaultMax;//Default max value of histograms
+  static const UInt_t fgkDefaultNBinsToScale;//Default number of bins used for scaling to tale
 
- public:
   ClassDef(AliHBTFunction1D,2)
 };
 
@@ -213,18 +232,6 @@ class AliHBTFunction1D: public AliHBTFunction
  
 class AliHBTFunction2D: public AliHBTFunction
 {
- private:
-  //this must be declared before constructors because they are used as a default arguments
-  static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
-  static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
-  static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
-  static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
-  static const Float_t fgkDefaultMinY;//Default min value of histograms
-  static const Float_t fgkDefaultMaxY;//Default max value of histograms
-
-  static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
-  static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
-
  public:
   AliHBTFunction2D();
 
@@ -237,6 +244,18 @@ class AliHBTFunction2D: public AliHBTFunction
                       Int_t nXbins, Double_t maxXval, Double_t minXval, 
                       Int_t nYbins, Double_t maxYval, Double_t minYval);
          
+  AliHBTFunction2D(const AliHBTFunction2D & source) {
+    // Copy constructor needed by the coding conventions byt not used
+    Fatal("AliHBTFunction2D(const AliHBTFunction2D & source)",
+         "not implemented");
+  }
+
+  AliHBTFunction2D & operator= (const AliHBTFunction2D & source) {
+    // Assignment needed by the coding conventions byt not used
+    Fatal("Assignment operator","not implemented");
+    return * this;
+  }
+
   virtual ~AliHBTFunction2D();
   
   TH1* GetNumerator() const {return fNumerator;}
@@ -251,15 +270,26 @@ class AliHBTFunction2D: public AliHBTFunction
                            Int_t nybins, Float_t ymax, Float_t ymin);
   virtual void BuildHistos();
   
-  TH2D* fNumerator;
-  TH2D* fDenominator;
+  TH2D* fNumerator; // Numerator histogram
+  TH2D* fDenominator; // Denominator histogram
   
   //definition of area used for scaling -> Scale is calculated this 
   //way that after division tale is on 1
   UInt_t fNBinsToScaleX;//number of bins on X axis
   UInt_t fNBinsToScaleY;//number of bins on Y axis
 
- public:
+ private:
+  //this must be declared before constructors because they are used as a default arguments
+  static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
+  static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
+  static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
+  static const Int_t fgkDefaultNBinsY;//default number of Bins in histograms
+  static const Float_t fgkDefaultMinY;//Default min value of histograms
+  static const Float_t fgkDefaultMaxY;//Default max value of histograms
+
+  static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
+  static const UInt_t fgkDefaultNBinsToScaleY;//Default number of bins used for scaling to tale
+
   ClassDef(AliHBTFunction2D,2)
 };
 /******************************************************************/
@@ -281,22 +311,6 @@ class AliHBTFunction2D: public AliHBTFunction
 
 class AliHBTFunction3D: public AliHBTFunction
 {
- private:
-  //this must be declared before constructors because they are used as a default arguments
-  static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
-  static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
-  static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
-  static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
-  static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
-  static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
-  static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
-  static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
-  static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
-
-  static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
-  static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
-  static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
-  
  public:
   AliHBTFunction3D();
 
@@ -310,7 +324,19 @@ class AliHBTFunction3D: public AliHBTFunction
                    Int_t nXbins, Double_t maxXval, Double_t minXval, 
                    Int_t nYbins, Double_t maxYval, Double_t minYval, 
                    Int_t nZbins, Double_t maxZval, Double_t minZval);
-   
+
+  AliHBTFunction3D(const AliHBTFunction3D & source) {
+    // Copy constructor needed by the coding conventions byt not used
+    Fatal("AliHBTFunction3D(const AliHBTFunction3D & source)",
+         "not implemented");
+  }
+
+  AliHBTFunction3D & operator= (const AliHBTFunction3D & source) {
+    // Assignment needed by the coding conventions byt not used
+    Fatal("Assignment operator","not implemented");
+    return * this;
+  }
+
   virtual ~AliHBTFunction3D();//destructor
 
   TH1* GetNumerator() const {return fNumerator;}
@@ -329,8 +355,8 @@ class AliHBTFunction3D: public AliHBTFunction
               Int_t nzbins, Float_t zmax, Float_t zmin);
   virtual void BuildHistos();
   
-  TH3D* fNumerator;
-  TH3D* fDenominator;
+  TH3D* fNumerator; // Numerator histogram
+  TH3D* fDenominator; // Denominator histogram
   
   //definition of area used for scaling -> Scale is calculated this 
   //way that after division tale is on 1
@@ -338,7 +364,22 @@ class AliHBTFunction3D: public AliHBTFunction
   UInt_t fNBinsToScaleY;//number of bins on Y axis
   UInt_t fNBinsToScaleZ;//number of bins on Z axis
   
- public:
+ private:
+  //this must be declared before constructors because they are used as a default arguments
+  static const Int_t fgkDefaultNBinsX;//default number of Bins in X axis in histograms
+  static const Float_t fgkDefaultMinX;//Default min value of X axis in histograms
+  static const Float_t fgkDefaultMaxX;//Default max value of X axis inhistograms
+  static const Int_t fgkDefaultNBinsY;//default number of Bins in Y axis in histograms
+  static const Float_t fgkDefaultMinY;//Default min value of Y axis in histograms
+  static const Float_t fgkDefaultMaxY;//Default max value of Y axis inhistograms
+  static const Int_t fgkDefaultNBinsZ;//default number of Bins in Z axis in histograms
+  static const Float_t fgkDefaultMinZ;//Default min value of Z axis in histograms
+  static const Float_t fgkDefaultMaxZ;//Default max value of Z axis inhistograms
+
+  static const UInt_t fgkDefaultNBinsToScaleX;//Default number of X bins used for scaling to tale
+  static const UInt_t fgkDefaultNBinsToScaleY;//Default number of Y bins used for scaling to tale
+  static const UInt_t fgkDefaultNBinsToScaleZ;//Default number of Z bins used for scaling to tale
+  
   ClassDef(AliHBTFunction3D,2)
 };
 /******************************************************************/
@@ -495,7 +536,7 @@ class AliHBTTwoPairFctn1D: public AliHBTTwoPairFctn, public AliHBTFunction1D
   void Init(){AliHBTFunction::Init();}
  protected:
   virtual Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) = 0;
- public: 
+
   ClassDef(AliHBTTwoPairFctn1D,2)
 };
 /******************************************************************/
@@ -540,7 +581,6 @@ class AliHBTTwoPairFctn2D: public AliHBTTwoPairFctn, public AliHBTFunction2D
  protected:
   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y) = 0;
 
- public:
   ClassDef(AliHBTTwoPairFctn2D,2)
 };
 /******************************************************************/
@@ -587,7 +627,6 @@ class AliHBTTwoPairFctn3D: public AliHBTTwoPairFctn, public AliHBTFunction3D
  protected:
   virtual void GetValues(AliHBTPair* trackpair, AliHBTPair* partpair, Double_t& x, Double_t& y, Double_t& z) = 0;
 
- public:
   ClassDef(AliHBTTwoPairFctn3D,2)
 };
 
index 6fcb0e3..d2dc5a4 100644 (file)
@@ -1,8 +1,16 @@
+/* $Id$ */
+
+//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.
+//Weights are calculated with corresponding simulated particles momenta.
+//Denominator is filled with mixing unweighted reconstructed tracks.
+//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"
 
 //--for test--AliHBTLLWeightQInvFctn* yyy= new AliHBTLLWeightQInvFctn();
 
@@ -31,6 +39,7 @@ void  AliHBTLLWeightQInvFctn::ProcessSameEventParticles(AliHBTPair* trackpair, A
 
 void  AliHBTLLWeightQInvFctn::ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair)
 {
+  // Fills the denominator using mixed pairs
   trackpair = CheckPair(trackpair);
   partpair  = CheckPair(partpair);
   if ( trackpair && partpair)  
index f23a746..3200e91 100644 (file)
@@ -1,13 +1,9 @@
-//This function 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.
-//Weights are calculated with corresponding simulated particles momenta.
-//Denominator is filled with mixing unweighted reconstructed tracks.
-//One needs both pairs 
-//(simulated and recontructed), thus function is of class AliHBTTwoPairFctn1D.
-
-#ifndef ALIHBTLLWEIGHTFCTN_H
-#define ALIHBTLLWEIGHTFCTN_H
+#ifndef ALIHBTLLWEIGHTQINVFCTN_H
+#define ALIHBTLLWEIGHTQINVFCTN_H
+
+/* $Id$ */
+
+
 #include "AliHBTFunction.h"
 
 
@@ -25,14 +21,10 @@ class AliHBTLLWeightQInvFctn: public AliHBTTwoPairFctn1D
       void   ProcessSameEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
       void   ProcessDiffEventParticles(AliHBTPair* trackpair, AliHBTPair* partpair);
       
-      Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair)         
-           { return trackpair->GetQInv()-partpair->GetQInv();} //isn't use                                                                    
-       
-
-  protected:
-
+      Double_t GetValue(AliHBTPair* trackpair, AliHBTPair* partpair) const
+       { return trackpair->GetQInv()-partpair->GetQInv();} //isn't use                                                                    
   private:
-  public:
+
      ClassDef(AliHBTLLWeightQInvFctn,1)
 };