TFeldmanCousins

class TFeldmanCousins : public TObject

    protected:

         Int_t FindLimitsFromTable(Double_t mu)
      Double_t Prob(Int_t N, Double_t mu, Double_t B)

    public:

                       TFeldmanCousins(Double_t newCL = 0.9, TString options = )
                       TFeldmanCousins(const TFeldmanCousins&)
               virtual ~TFeldmanCousins()
              Double_t CalculateLowerLimit(Double_t Nobserved, Double_t Nbackground)
              Double_t CalculateUpperLimit(Double_t Nobserved, Double_t Nbackground)
        static TClass* Class()
              Double_t GetCL()
              Double_t GetLowerLimit()
              Double_t GetMuMax()
              Double_t GetMuMin()
              Double_t GetMuStep()
              Double_t GetNbackground()
              Double_t GetNMax()
              Double_t GetNobserved()
              Double_t GetUpperLimit()
       virtual TClass* IsA() const
      TFeldmanCousins& operator=(const TFeldmanCousins&)
                  void SetCL(Double_t newCL)
                  void SetMuMax(Double_t newMax = 50.0)
                  void SetMuMin(Double_t newMin = 0.0)
                  void SetMuStep(Double_t newMuStep = 0.005)
                  void SetNbackground(Double_t Nbg)
                  void SetNobserved(Double_t NObs)
          virtual void ShowMembers(TMemberInspector& insp, char* parent)
          virtual void Streamer(TBuffer& b)
                  void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

      Double_t fCL           confidence level as a fraction [e.g. 90% = 0.9]
      Double_t fUpperLimit   the calculated upper limit
      Double_t fLowerLimit   the calculated lower limit
      Double_t fNobserved    input number of observed events
      Double_t fNbackground  input number of background events
      Double_t fMuMin        minimum value of signal to use in calculating the tables
      Double_t fMuMax        maximum value of signal to use in calculating the tables
      Double_t fMuStep       the step in signal to use when generating tables
         Int_t fNMuStep      = (int)(fMuStep)
         Int_t fNMax         = (int)(fMuMax)
         Int_t fQUICK        take a short cut to speed up the process of generating a

Class Description

 TFeldmanCousins

 class to calculate the CL upper limit using
 the Feldman-Cousins method as described in PRD V57 #7, p3873-3889

 The default confidence interval calvculated using this method is 90%
 This is set either by having a default the constructor, or using the
 appropriate fraction when instantiating an object of this class (e.g. 0.9)

 The simple extension to a gaussian resolution function bounded at zero
 has not been addressed as yet -> `time is of the essence' as they write
 on the wall of the maze in that classic game ...

    VARIABLES THAT CAN BE ALTERED
    -----------------------------
 => depending on your desired precision: The intial values of fMuMin,
 fMuMax, fMuStep and fNMax are those used in the PRD:
   fMuMin = 0.0
   fMuMax = 50.0
   fMuStep= 0.005
 but there is total flexibility in changing this should you desire.


 see example of use in $ROOTSYS/tutorials/FeldmanCousins.C

 see note about: "Should I use TRolke, TFeldmanCousins, TLimit?"
  in the TRolke class description.

 Author: Adrian Bevan, Liverpool University

 Copyright Liverpool University 2001       bevan@slac.stanford.edu

 given Nobserved and Nbackground, try different values of mu that give lower limits that
 are consistent with Nobserved.  The closed interval (plus any stragglers) corresponds  
 to the F&C interval                                                                    

 given Nobserved and Nbackground, try different values of mu that give upper limits that
 are consistent with Nobserved.  The closed interval (plus any stragglers) corresponds  
 to the F&C interval                                                                    

 calculate the probability table for a given mu for n = 0, NMAX
 and return 1 if the number of observed events is consistent   
 with the CL bad                                               

 calculate the poissonian probability for   
 a mean of mu+B events with a variance of N 

Inline Functions

                Double_t GetUpperLimit()
                Double_t GetLowerLimit()
                Double_t GetNobserved()
                Double_t GetNbackground()
                Double_t GetCL()
                Double_t GetMuMin()
                Double_t GetMuMax()
                Double_t GetMuStep()
                Double_t GetNMax()
                    void SetNobserved(Double_t NObs)
                    void SetNbackground(Double_t Nbg)
                    void SetCL(Double_t newCL)
                    void SetMuMin(Double_t newMin = 0.0)
                 TClass* Class()
                 TClass* IsA() const
                    void ShowMembers(TMemberInspector& insp, char* parent)
                    void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)
         TFeldmanCousins TFeldmanCousins(const TFeldmanCousins&)
        TFeldmanCousins& operator=(const TFeldmanCousins&)