TLimit

class TLimit

    protected:

      static TLimitDataSource* Fluctuate(TLimitDataSource* input, bool init, TRandom*)
               static Double_t LogLikelihood(Double_t s, Double_t b, Double_t d)

    public:

                        TLimit TLimit()
                        TLimit TLimit(const TLimit&)
                  virtual void ~TLimit()
                static TClass* Class()
      static TConfidenceLevel* ComputeLimit(TLimitDataSource* data, Int_t nmc = 50000, TRandom* generator = NULL, Double_t (*) (Double_t, Double_t,Double_t)  statistic = &(TLimit::LogLikelihood))
               virtual TClass* IsA() const
                  virtual void ShowMembers(TMemberInspector& insp, char* parent)
                  virtual void Streamer(TBuffer& b)
                          void StreamerNVirtual(TBuffer& b)

Data Members

    private:

             static TArrayD* fgTable      a log table... just to speed up calculation
      static TOrdCollection* fgSystNames  Collection of systematics names

Class Description

 TLimit

 Class to compute 95% CL limits

 class TLimit
 ------------

 Algorithm to compute 95% C.L. limits using the Likelihood ratio
 semi-bayesian method.
 It takes signal, background and data histograms wrapped in a
 TLimitDataSource as input and runs a set of Monte Carlo experiments in
 order to compute the limits. If needed, inputs are fluctuated according
 to systematics. The output is a TConfidenceLevel.

 class TLimitDataSource
 ----------------------

 Takes the signal, background and data histograms as well as different
 systematics sources to form the TLimit input.

  class TConfidenceLevel
  ----------------------

 Final result of the TLimit algorithm. It is created just after the
 time-consuming part and can be stored in a TFile for further processing.
 It contains light methods to return CLs, CLb and other interesting
 quantities.

 The actual algorithm...
 From an input (TLimitDataSource) it produces an output TConfidenceLevel.
 For this, nmc Monte Carlo experiments are performed.
 As usual, the larger this number, the longer the compute time,
 but the better the result.

   /*
   
   
Supposing that there is a plotfile.root file containing 3 histograms
           (signal, background and data), you can imagine doing things like:
   

   

    TFile* infile=new TFile("plotfile.root","READ");
    infile->cd();
    TH1D* sh=(TH1D*)infile->Get("signal");
    TH1D* bh=(TH1D*)infile->Get("background");
    TH1D* dh=(TH1D*)infile->Get("data");
    TLimitDataSource* mydatasource = new TLimitDataSource(sh,bh,dh);
    TConfidenceLevel *myconfidence = TLimit::ComputeLimit(mydatasource,50000);
    cout << "  CLs    : " << myconfidence->CLs()  << endl;
    cout << "  CLsb   : " << myconfidence->CLsb() << endl;
    cout << "  CLb    : " << myconfidence->CLb()  << endl;
    cout << "< CLs >  : " << myconfidence->GetExpectedCLs_b()  << endl;
    cout << "< CLsb > : " << myconfidence->GetExpectedCLsb_b() << endl;
    cout << "< CLb >  : " << myconfidence->GetExpectedCLb_b()  << endl;
    delete myconfidence;
    delete mydatasource;
    infile->Close();
   

 initialisation: create a sorted list of all the names of systematics

Inline Functions

             TLimit TLimit()
           Double_t LogLikelihood(Double_t s, Double_t b, Double_t d)
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
             TLimit TLimit(const TLimit&)
               void ~TLimit()