library: libPhysics #include "TFeldmanCousins.h"

# TFeldmanCousins

class description - source file - inheritance tree (.pdf)

## class TFeldmanCousins : public TObject

| Inheritance Chart:
`TObject`
| <- | `TFeldmanCousins` |

        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

TFeldmanCousins(Double_t newFC, TString options)

~TFeldmanCousins()

Double_t CalculateLowerLimit(Double_t Nobserved, Double_t Nbackground)

     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

Double_t CalculateUpperLimit(Double_t Nobserved, Double_t Nbackground)

     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

Int_t FindLimitsFromTable( Double_t mu )

     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

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

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

void SetMuMax(Double_t newMax)

void SetMuStep(Double_t newMuStep)

### 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&)

Author: Adrian Bevan 2001
Last update: root/physics:$Name: $:$Id: TFeldmanCousins.cxx,v 1.9 2004/11/11 07:48:31 brun Exp $
Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *