TRolke

class TRolke : public TObject

    protected:

             Double_t EvalLikeMod1(Double_t mu, Int_t x, Int_t y, Int_t z, Double_t e, Double_t tau, Double_t b, Int_t m, Int_t what)
             Double_t EvalLikeMod2(Double_t mu, Int_t x, Int_t y, Double_t em, Double_t e, Double_t sde, Double_t tau, Double_t b, Int_t what)
             Double_t EvalLikeMod3(Double_t mu, Int_t x, Double_t bm, Double_t em, Double_t e, Double_t sde, Double_t sdb, Double_t b, Int_t what)
             Double_t EvalLikeMod4(Double_t mu, Int_t x, Int_t y, Double_t tau, Double_t b, Int_t what)
             Double_t EvalLikeMod5(Double_t mu, Int_t x, Double_t bm, Double_t sdb, Double_t b, Int_t what)
             Double_t EvalLikeMod6(Double_t mu, Int_t x, Int_t z, Double_t e, Double_t b, Int_t m, Int_t what)
             Double_t EvalLikeMod7(Double_t mu, Int_t x, Double_t em, Double_t e, Double_t sde, Double_t b, Int_t what)
      static Double_t EvalMonomial(Double_t x, const Int_t* coef, Int_t N)
      static Double_t EvalPolynomial(Double_t x, const Int_t* coef, Int_t N)
             Double_t Interval(Int_t x, Int_t y, Int_t z, Double_t bm, Double_t em, Double_t e, Int_t mid, Double_t sde, Double_t sdb, Double_t tau, Double_t b, Int_t m)
             Double_t LikeGradMod1(Double_t e, Double_t mu, Int_t x, Int_t y, Int_t z, Double_t tau, Int_t m)
             Double_t Likelihood(Double_t mu, Int_t x, Int_t y, Int_t z, Double_t bm, Double_t em, Double_t e, Int_t mid, Double_t sde, Double_t sdb, Double_t tau, Double_t b, Int_t m, Int_t what)
             Double_t LikeMod1(Double_t mu, Double_t b, Double_t e, Int_t x, Int_t y, Int_t z, Double_t tau, Int_t m)
             Double_t LikeMod2(Double_t mu, Double_t b, Double_t e, Int_t x, Int_t y, Double_t em, Double_t tau, Double_t v)
             Double_t LikeMod3(Double_t mu, Double_t b, Double_t e, Int_t x, Double_t bm, Double_t em, Double_t u, Double_t v)
             Double_t LikeMod4(Double_t mu, Double_t b, Int_t x, Int_t y, Double_t tau)
             Double_t LikeMod5(Double_t mu, Double_t b, Int_t x, Double_t bm, Double_t u)
             Double_t LikeMod6(Double_t mu, Double_t b, Double_t e, Int_t x, Int_t z, Int_t m)
             Double_t LikeMod7(Double_t mu, Double_t b, Double_t e, Int_t x, Double_t em, Double_t v)
                 void ProfLikeMod1(Double_t mu, Double_t& b, Double_t& e, Int_t x, Int_t y, Int_t z, Double_t tau, Int_t m)

    public:

                      TRolke(Double_t CL = 0.9, Option_t* option = "")
                      TRolke(const TRolke&)
              virtual ~TRolke()
             Double_t CalculateInterval(Int_t x, Int_t y, Int_t z, Double_t bm, Double_t em, Double_t e, Int_t mid, Double_t sde, Double_t sdb, Double_t tau, Double_t b, Int_t m)
       static TClass* Class()
             Double_t GetCL() const
             Double_t GetLowerLimit() const
                Int_t GetSwitch() const
             Double_t GetUpperLimit() const
      virtual TClass* IsA() const
              TRolke& operator=(const TRolke&)
                 void SetCL(Double_t CL)
                 void SetSwitch(Int_t sw)
         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
         Int_t fSwitch      0: for unbounded likelihood

Class Description

  TRolke

  This class computes confidence intervals for the rate of a Poisson
  in the presence of background and efficiency with a fully frequentist
  treatment of the uncertainties in the efficiency and background estimate
  using the profile likelihood method.

  The signal is always assumed to be Poisson.

  The method is very similar to the one used in MINUIT (MINOS).

  Two options are offered to deal with cases where the maximum likelihood
  estimate (MLE) is not in the physical region. Version "bounded likelihood"
  is the one used by MINOS if bounds for the physical region are chosen. Versi//  on "unbounded likelihood (the default) allows the MLE to be in the
  unphysical region. It has however better coverage.
  For more details consult the reference (see below).


   It allows the following Models:

       1: Background - Poisson, Efficiency - Binomial  (cl,x,y,z,tau,m)
       2: Background - Poisson, Efficiency - Gaussian  (cl,xd,y,em,tau,sde)
       3: Background - Gaussian, Efficiency - Gaussian (cl,x,bm,em,sd)
       4: Background - Poisson, Efficiency - known     (cl,x,y,tau,e)
       5: Background - Gaussian, Efficiency - known    (cl,x,y,z,sdb,e)
       6: Background - known, Efficiency - Binomial    (cl,x,z,m,b)
       7: Background - known, Efficiency - Gaussian    (cl,x,em,sde,b)

  Parameter definition:

  cl  =  Confidence level

  x = number of observed events

  y = number of background events

  z = number of simulated signal events

  em = measurement of the efficiency.

  bm = background estimate

  tau = ratio between signal and background region (in case background is
  observed) ratio between observed and simulated livetime in case
  background is determined from MC.

  sd(x) = sigma of the Gaussian

  e = true efficiency (in case known)

  b = expected background (in case known)

  m = number of MC runs

  mid = ID number of the model ...

  For a description of the method and its properties:

  W.Rolke, A. Lopez, J. Conrad and Fred James
  "Limits and Confidence Intervals in presence of nuisance parameters"
   http://lanl.arxiv.org/abs/physics/0403059

  Should I use TRolke, TFeldmanCousins, TLimit?
  ============================================
  1. I guess TRolke makes TFeldmanCousins obsolete?

  Certainly not. TFeldmanCousins is the fully frequentist construction and
  should be used in case of no (or negligible uncertainties). It is however
  not capable of treating uncertainties in nuisance parameters.
  TRolke is desined for this case and it is shown in the reference above
  that it has good coverage properties for most cases, ie it might be
  used where FeldmannCousins can't.

  2. What are the advantages of TRolke over TLimit?

  TRolke is fully frequentist. TLimit treats nuisance parameters Bayesian.
  For a coverage study of a Bayesian method refer to
  physics/0408039 (Tegenfeldt & J.C). However, this note studies
  the coverage of Feldman&Cousins with Bayesian treatment of nuisance
  parameters. To make a long story short: using the Bayesian method you
  might introduce a small amount of over-coverage (though I haven't shown it
  for TLimit). On the other hand, coverage of course is a not so interesting
  when you consider yourself a Bayesian.

 Author: Jan Conrad (CERN)

 see example in tutorial Rolke.C

 Copyright CERN 2004                Jan.Conrad@cern.ch

 Calculates the Confidence Interval

 Chooses between the different profile likelihood functions to use for the
 different models.
 Returns evaluation of the profile likelihood functions.

 Calculates the Profile Likelihood for MODEL 1:
  Poisson background/ Binomial Efficiency
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 1:
 Poisson background/ Binomial Efficiency

 Void needed to calculate estimates of efficiency and background for model 1

 Calculates the Profile Likelihood for MODEL 2:
  Poisson background/ Gauss Efficiency
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 2:
 Poisson background/Gauss Efficiency

 Calculates the Profile Likelihood for MODEL 3:
 Gauss  background/ Gauss Efficiency
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 3:
 Gauss background/Gauss Efficiency

 Calculates the Profile Likelihood for MODEL 4:
 Poiss  background/Efficiency known
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 4:
 Poiss background/Efficiency known

 Calculates the Profile Likelihood for MODEL 5:
 Gauss  background/Efficiency known
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 5:
 Gauss background/Efficiency known

 Calculates the Profile Likelihood for MODEL 6:
 Gauss  known/Efficiency binomial
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 6:
 background known/ Efficiency binomial

 Calculates the Profile Likelihood for MODEL 7:
 background known/Efficiency Gauss
 what = 1: Maximum likelihood estimate is returned
 what = 2: Profile Likelihood of Maxmimum Likelihood estimate is returned.
 what = 3: Profile Likelihood of Test hypothesis is returned
 otherwise parameters as described in the beginning of the class)

 Profile Likelihood function for MODEL 6:
 background known/ Efficiency binomial

 evaluate polynomial

 evaluate mononomial

Inline Functions

           Double_t GetUpperLimit() const
           Double_t GetLowerLimit() const
              Int_t GetSwitch() const
               void SetSwitch(Int_t sw)
           Double_t GetCL() const
               void SetCL(Double_t CL)
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
             TRolke TRolke(const TRolke&)
            TRolke& operator=(const TRolke&)