ROOT logo
// @(#)root/roostats:$Id: LikelihoodInterval.cxx 31876 2009-12-14 11:11:27Z brun $
// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
/*************************************************************************
 * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

/*****************************************************************************
 * Project: RooStats
 * Package: RooFit/RooStats  
 * @(#)root/roofit/roostats:$Id: LikelihoodInterval.cxx 31876 2009-12-14 11:11:27Z brun $
 * Authors:                     
 *   Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
 *
 *****************************************************************************/



//_________________________________________________
/*
BEGIN_HTML
<p>
LikelihoodInterval is a concrete implementation of the RooStats::ConfInterval interface.  
It implements a connected N-dimensional intervals based on the contour of a likelihood ratio.
The boundary of the inteval is equivalent to a MINUIT/MINOS contour about the maximum likelihood estimator
[<a href="#minuit">1</a>].
The interval does not need to be an ellipse (eg. it is not the HESSE error matrix).
The level used to make the contour is the same as that used in MINOS, eg. it uses Wilks' theorem, 
which states that under certain regularity conditions the function -2* log (profile likelihood ratio) is asymptotically distributed as a chi^2 with N-dof, where 
N is the number of parameters of interest.  
</p>

<p>
Note, a boundary on the parameter space (eg. s>= 0) or a degeneracy (eg. mass of signal if Nsig = 0) can lead to violations of the conditions necessary for Wilks' theorem to be true.
</p>

<p>
Also note, one can use any RooAbsReal as the function that will be used in the contour; however, the level of the contour
is based on Wilks' theorem as stated above.
</p>

<P>References</P>

<p><A NAME="minuit">1</A>
F.&nbsp;James., Minuit.Long writeup D506, CERN, 1998.
</p>
  
END_HTML
*/
//
//

#ifndef RooStats_LikelihoodInterval
#include "RooStats/LikelihoodInterval.h"
#endif
#include "RooStats/RooStatsUtils.h"

#include "RooAbsReal.h"
#include "RooMsgService.h"

#include "Math/WrappedFunction.h"
#include "Math/Minimizer.h"
#include "Math/Factory.h"
#include "Math/MinimizerOptions.h"
#include "RooFunctor.h"
#include "RooProfileLL.h"

#include <string>

/*
// for debugging
#include "RooNLLVar.h"
#include "RooProfileLL.h"
#include "RooDataSet.h"
#include "RooAbsData.h"
*/

ClassImp(RooStats::LikelihoodInterval) ;

using namespace RooStats;


//____________________________________________________________________
LikelihoodInterval::LikelihoodInterval(const char* name) :
   ConfInterval(name), fBestFitParams(0), fLikelihoodRatio(0)
{
   // Default constructor with name and title
}

//____________________________________________________________________
LikelihoodInterval::LikelihoodInterval(const char* name, RooAbsReal* lr, const RooArgSet* params,  RooArgSet * bestParams) :
   ConfInterval(name), 
   fParameters(*params), 
   fBestFitParams(bestParams), 
   fLikelihoodRatio(lr) 
{
   // Alternate constructor taking a pointer to the profile likelihood ratio, parameter of interest and 
   // optionally a snaphot of best parameter of interest for interval
}


//____________________________________________________________________
LikelihoodInterval::~LikelihoodInterval()
{
   // Destructor
   if (fBestFitParams) delete fBestFitParams; 
   if (fLikelihoodRatio) delete fLikelihoodRatio;
}


//____________________________________________________________________
Bool_t LikelihoodInterval::IsInInterval(const RooArgSet &parameterPoint) const 
{  
  // This is the main method to satisfy the RooStats::ConfInterval interface.  
  // It returns true if the parameter point is in the interval.

  RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ;
  // Method to determine if a parameter point is in the interval
  if( !this->CheckParameters(parameterPoint) ) {
    std::cout << "parameters don't match" << std::endl;
    return false; 
  }

  // make sure likelihood ratio is set
  if(!fLikelihoodRatio) {
    std::cout << "likelihood ratio not set" << std::endl;
    return false;
  }

  

  // set parameters
  SetParameters(&parameterPoint, fLikelihoodRatio->getVariables() );


  // evaluate likelihood ratio, see if it's bigger than threshold
  if (fLikelihoodRatio->getVal()<0){
    std::cout << "The likelihood ratio is < 0, indicates a bad minimum or numerical precision problems.  Will return true" << std::endl;
    return true;
  }


  // here we use Wilks' theorem.
  if ( TMath::Prob( 2* fLikelihoodRatio->getVal(), parameterPoint.getSize()) < (1.-fConfidenceLevel) )
    return false;


  //RooMsgService::instance().setGlobalKillBelow(RooFit::DEBUG) ;

  return true;
  
}

//____________________________________________________________________
RooArgSet* LikelihoodInterval::GetParameters() const
{  
  // returns list of parameters
   return new RooArgSet(fParameters); 
}

//____________________________________________________________________
Bool_t LikelihoodInterval::CheckParameters(const RooArgSet &parameterPoint) const
{  
  // check that the parameters are correct

  if (parameterPoint.getSize() != fParameters.getSize() ) {
    std::cout << "size is wrong, parameters don't match" << std::endl;
    return false;
  }
  if ( ! parameterPoint.equals( fParameters ) ) {
    std::cout << "size is ok, but parameters don't match" << std::endl;
    return false;
  }
  return true;
}



//____________________________________________________________________
Double_t LikelihoodInterval::LowerLimit(const RooRealVar& param) 
{  
   // compute the interval lower limit for the specified confidence level 
   // or size using  MINOS 
   // Note that both lower and upper limit are computed and cached internally so 
   // any subsequent calls (for the same CL will be fast to execute)

   double lower = param.getMin(); 
   double upper = param.getMax(); 
   FindLimits(param, lower, upper); 
   return lower; 
}

//____________________________________________________________________
Double_t LikelihoodInterval::UpperLimit(const RooRealVar& param) 
{  
   // compute the interval upper limit for the specified confidence level 
   // or size using  MINOS. 
   // Note that both lower and upper limit are computed and cached internally so 
   // any subsequent calls (for the same CL will be fast to execute)

   double lower = param.getMin(); 
   double upper = param.getMax(); 
   FindLimits(param, lower, upper); 
   return upper; 
}



void LikelihoodInterval::ResetLimits() { 
   // reset map with cached limits - called every time the test size or CL has been changed
   fLowerLimits.clear(); 
   fUpperLimits.clear(); 
}


bool LikelihoodInterval::CreateMinimizer() { 
   // internal function to create minimizer object needed to find contours or interval limits
   // (running MINOS). 
   // Minimizer must be Minuit or Minuit2

   RooProfileLL * profilell = dynamic_cast<RooProfileLL*>(fLikelihoodRatio);
   if (!profilell) return false; 

   RooAbsReal & nll  = profilell->nll(); 
   // bind the nll function in the right interface for the Minimizer class 
   // as a function of only the parameters (poi + nuisance parameters) 

   RooArgSet * partmp = profilell->getVariables();
   RooArgList params(*partmp);
   delete partmp;

   // need to restore values and errors for POI
   if (fBestFitParams) { 
      for (int i = 0; i < params.getSize(); ++i) { 
         RooRealVar & par =  (RooRealVar &) params[i];
         RooRealVar * fitPar =  (RooRealVar *) (fBestFitParams->find(par.GetName() ) );
         if (fitPar) {
            par.setVal( fitPar->getVal() );
            par.setError( fitPar->getVal() );
         }
      }
   }

   // now do binding of NLL with a functor for Minimizer 
   fFunctor = std::auto_ptr<RooFunctor>(new RooFunctor(nll, RooArgSet(), params )); 

   std::string minimType =  ROOT::Math::MinimizerOptions::DefaultMinimizerType();

   if (minimType != "Minuit" && minimType != "Minuit2") { 
      ccoutE(InputArguments) << minimType << "is wrong type of minimizer for getting interval limits or contours - must use Minuit or Minuit2" << std::endl;
      return false; 
   }
   // create minimizer class 
   fMinimizer = std::auto_ptr<ROOT::Math::Minimizer>(ROOT::Math::Factory::CreateMinimizer(minimType, "Migrad"));

   if (!fMinimizer.get()) return false;

   fMinFunc = std::auto_ptr<ROOT::Math::IMultiGenFunction>( new ROOT::Math::WrappedMultiFunction<RooFunctor &> (*fFunctor, fFunctor->nPar() ) );  
   fMinimizer->SetFunction(*fMinFunc); 

   // set minimizer parameters 
   assert( params.getSize() == int(fMinFunc->NDim()) ); 

   for (unsigned int i = 0; i < fMinFunc->NDim(); ++i) { 
      RooRealVar & v = (RooRealVar &) params[i]; 
      fMinimizer->SetLimitedVariable( i, v.GetName(), v.getVal(), v.getError(), v.getMin(), v.getMax() ); 
   }
   // for finding the contour need to find first global minimum
   bool iret = fMinimizer->Minimize();
   if (!iret || fMinimizer->X() == 0) { 
      ccoutE(Minimization) << "Error: Minimization failed  " << std::endl;
      return false; 
   }

   //std::cout << "print minimizer result..........." << std::endl;

   fMinimizer->PrintResults();
   return true; 
}

bool LikelihoodInterval::FindLimits(const RooRealVar & param, double &lower, double & upper) 
{
   // Method to find both lower and upper limits using MINOS
   // If cached values exist (limits have been already found) return them in that case

   std::map<std::string, double>::const_iterator itrl = fLowerLimits.find(param.GetName());
   std::map<std::string, double>::const_iterator itru = fUpperLimits.find(param.GetName());
   if ( itrl != fLowerLimits.end() && itru != fUpperLimits.end() ) { 
      lower = itrl->second;
      upper = itru->second; 
      return true; 
   }
      

   RooArgSet * partmp = fLikelihoodRatio->getVariables();
   RooArgList params(*partmp);
   delete partmp;
   int ix = params.index(&param); 
   if (ix < 0 ) { 
      ccoutE(InputArguments) << "Error - invalid parameter " << param.GetName() << " specified for finding the interval limits " << std::endl;
      return false; 
   }

   bool ret = true;
   if (!fMinimizer.get()) ret = CreateMinimizer(); 
   if (!ret) { 
      ccoutE(Eval) << "Error returned from minimization of likelihood function - cannot find interval limits " << std::endl;
      return false; 
   }

   assert(fMinimizer.get());
        
   // getting a 1D interval so ndf = 1
   double err_level = TMath::ChisquareQuantile(ConfidenceLevel(),1); // level for -2log LR
   err_level = err_level/2; // since we are using -log LR
   fMinimizer->SetErrorDef(err_level);
   
   unsigned int ivarX = ix; 

   fMinimizer->SetPrintLevel(1);
   double elow = 0; 
   double eup = 0;
   ret = fMinimizer->GetMinosError(ivarX, elow, eup );
   // WHEN error is zero normally is at limit
   if (elow == 0) { 
      lower = param.getMin();
      ccoutW(Minimization) << "Warning: lower value for " << param.GetName() << " is at limit " << lower << std::endl; 
   }
   else 
      lower = fMinimizer->X()[ivarX] + elow;  // elow is negative 

   if (eup == 0) { 
      ccoutW(Minimization) << "Warning: upper value for " << param.GetName() << " is at limit " << upper << std::endl; 
      upper = param.getMax();
   }
   else 
      upper = fMinimizer->X()[ivarX] + eup;

   if (!ret)  ccoutE(Minimization) << "Error  running Minos for parameter " << param.GetName() << std::endl;
   else { 
      // store limits in the map 
      // minos return error limit = minValue +/- error
      fLowerLimits[param.GetName()] = lower; 
      fUpperLimits[param.GetName()] = upper; 
   }
      

   return ret; 
}


Int_t LikelihoodInterval::GetContourPoints(const RooRealVar & paramX, const RooRealVar & paramY, Double_t * x, Double_t *y, Int_t npoints ) { 
   // use Minuit to find the contour of the likelihood function at the desired CL 

   // check the parameters 
   // variable index in minimizer
   // is index in the RooArgList obtained from the profileLL variables
   RooArgSet * partmp = fLikelihoodRatio->getVariables();
   RooArgList params(*partmp);
   delete partmp;
   int ix = params.index(&paramX); 
   int iy = params.index(&paramY); 
   if (ix < 0 || iy < 0) { 
      ccoutE(InputArguments) << "Error - invalid parameters specified for finding the contours; parX = " << paramX.GetName() 
             << " parY = " << paramY.GetName() << std::endl;
         return 0; 
   }

   bool ret = true; 
   if (!fMinimizer.get()) ret = CreateMinimizer(); 
   if (!ret) { 
      ccoutE(Eval) << "Error returned creating minimizer for likelihood function - cannot find contour points " << std::endl;
      return 0; 
   }

   assert(fMinimizer.get());
        
   // getting a 2D contour so ndf = 2
   double cont_level = TMath::ChisquareQuantile(ConfidenceLevel(),2); // level for -2log LR
   cont_level = cont_level/2; // since we are using -log LR
   fMinimizer->SetErrorDef(cont_level);
  
   unsigned int ncp = npoints; 
   unsigned int ivarX = ix; 
   unsigned int ivarY = iy; 
   ret = fMinimizer->Contour(ivarX, ivarY, ncp, x, y );
   if (!ret) { 
      ccoutE(Minimization) << "Error finding contour for parameters " << paramX.GetName() << " and " << paramY.GetName()  << std::endl;
      return 0; 
   }
   if (int(ncp) < npoints) {
      ccoutW(Minimization) << "Warning - Less points calculated in contours np = " << ncp << " / " << npoints << std::endl;
   }

   return ncp;
 }
 LikelihoodInterval.cxx:1
 LikelihoodInterval.cxx:2
 LikelihoodInterval.cxx:3
 LikelihoodInterval.cxx:4
 LikelihoodInterval.cxx:5
 LikelihoodInterval.cxx:6
 LikelihoodInterval.cxx:7
 LikelihoodInterval.cxx:8
 LikelihoodInterval.cxx:9
 LikelihoodInterval.cxx:10
 LikelihoodInterval.cxx:11
 LikelihoodInterval.cxx:12
 LikelihoodInterval.cxx:13
 LikelihoodInterval.cxx:14
 LikelihoodInterval.cxx:15
 LikelihoodInterval.cxx:16
 LikelihoodInterval.cxx:17
 LikelihoodInterval.cxx:18
 LikelihoodInterval.cxx:19
 LikelihoodInterval.cxx:20
 LikelihoodInterval.cxx:21
 LikelihoodInterval.cxx:22
 LikelihoodInterval.cxx:23
 LikelihoodInterval.cxx:24
 LikelihoodInterval.cxx:25
 LikelihoodInterval.cxx:26
 LikelihoodInterval.cxx:27
 LikelihoodInterval.cxx:28
 LikelihoodInterval.cxx:29
 LikelihoodInterval.cxx:30
 LikelihoodInterval.cxx:31
 LikelihoodInterval.cxx:32
 LikelihoodInterval.cxx:33
 LikelihoodInterval.cxx:34
 LikelihoodInterval.cxx:35
 LikelihoodInterval.cxx:36
 LikelihoodInterval.cxx:37
 LikelihoodInterval.cxx:38
 LikelihoodInterval.cxx:39
 LikelihoodInterval.cxx:40
 LikelihoodInterval.cxx:41
 LikelihoodInterval.cxx:42
 LikelihoodInterval.cxx:43
 LikelihoodInterval.cxx:44
 LikelihoodInterval.cxx:45
 LikelihoodInterval.cxx:46
 LikelihoodInterval.cxx:47
 LikelihoodInterval.cxx:48
 LikelihoodInterval.cxx:49
 LikelihoodInterval.cxx:50
 LikelihoodInterval.cxx:51
 LikelihoodInterval.cxx:52
 LikelihoodInterval.cxx:53
 LikelihoodInterval.cxx:54
 LikelihoodInterval.cxx:55
 LikelihoodInterval.cxx:56
 LikelihoodInterval.cxx:57
 LikelihoodInterval.cxx:58
 LikelihoodInterval.cxx:59
 LikelihoodInterval.cxx:60
 LikelihoodInterval.cxx:61
 LikelihoodInterval.cxx:62
 LikelihoodInterval.cxx:63
 LikelihoodInterval.cxx:64
 LikelihoodInterval.cxx:65
 LikelihoodInterval.cxx:66
 LikelihoodInterval.cxx:67
 LikelihoodInterval.cxx:68
 LikelihoodInterval.cxx:69
 LikelihoodInterval.cxx:70
 LikelihoodInterval.cxx:71
 LikelihoodInterval.cxx:72
 LikelihoodInterval.cxx:73
 LikelihoodInterval.cxx:74
 LikelihoodInterval.cxx:75
 LikelihoodInterval.cxx:76
 LikelihoodInterval.cxx:77
 LikelihoodInterval.cxx:78
 LikelihoodInterval.cxx:79
 LikelihoodInterval.cxx:80
 LikelihoodInterval.cxx:81
 LikelihoodInterval.cxx:82
 LikelihoodInterval.cxx:83
 LikelihoodInterval.cxx:84
 LikelihoodInterval.cxx:85
 LikelihoodInterval.cxx:86
 LikelihoodInterval.cxx:87
 LikelihoodInterval.cxx:88
 LikelihoodInterval.cxx:89
 LikelihoodInterval.cxx:90
 LikelihoodInterval.cxx:91
 LikelihoodInterval.cxx:92
 LikelihoodInterval.cxx:93
 LikelihoodInterval.cxx:94
 LikelihoodInterval.cxx:95
 LikelihoodInterval.cxx:96
 LikelihoodInterval.cxx:97
 LikelihoodInterval.cxx:98
 LikelihoodInterval.cxx:99
 LikelihoodInterval.cxx:100
 LikelihoodInterval.cxx:101
 LikelihoodInterval.cxx:102
 LikelihoodInterval.cxx:103
 LikelihoodInterval.cxx:104
 LikelihoodInterval.cxx:105
 LikelihoodInterval.cxx:106
 LikelihoodInterval.cxx:107
 LikelihoodInterval.cxx:108
 LikelihoodInterval.cxx:109
 LikelihoodInterval.cxx:110
 LikelihoodInterval.cxx:111
 LikelihoodInterval.cxx:112
 LikelihoodInterval.cxx:113
 LikelihoodInterval.cxx:114
 LikelihoodInterval.cxx:115
 LikelihoodInterval.cxx:116
 LikelihoodInterval.cxx:117
 LikelihoodInterval.cxx:118
 LikelihoodInterval.cxx:119
 LikelihoodInterval.cxx:120
 LikelihoodInterval.cxx:121
 LikelihoodInterval.cxx:122
 LikelihoodInterval.cxx:123
 LikelihoodInterval.cxx:124
 LikelihoodInterval.cxx:125
 LikelihoodInterval.cxx:126
 LikelihoodInterval.cxx:127
 LikelihoodInterval.cxx:128
 LikelihoodInterval.cxx:129
 LikelihoodInterval.cxx:130
 LikelihoodInterval.cxx:131
 LikelihoodInterval.cxx:132
 LikelihoodInterval.cxx:133
 LikelihoodInterval.cxx:134
 LikelihoodInterval.cxx:135
 LikelihoodInterval.cxx:136
 LikelihoodInterval.cxx:137
 LikelihoodInterval.cxx:138
 LikelihoodInterval.cxx:139
 LikelihoodInterval.cxx:140
 LikelihoodInterval.cxx:141
 LikelihoodInterval.cxx:142
 LikelihoodInterval.cxx:143
 LikelihoodInterval.cxx:144
 LikelihoodInterval.cxx:145
 LikelihoodInterval.cxx:146
 LikelihoodInterval.cxx:147
 LikelihoodInterval.cxx:148
 LikelihoodInterval.cxx:149
 LikelihoodInterval.cxx:150
 LikelihoodInterval.cxx:151
 LikelihoodInterval.cxx:152
 LikelihoodInterval.cxx:153
 LikelihoodInterval.cxx:154
 LikelihoodInterval.cxx:155
 LikelihoodInterval.cxx:156
 LikelihoodInterval.cxx:157
 LikelihoodInterval.cxx:158
 LikelihoodInterval.cxx:159
 LikelihoodInterval.cxx:160
 LikelihoodInterval.cxx:161
 LikelihoodInterval.cxx:162
 LikelihoodInterval.cxx:163
 LikelihoodInterval.cxx:164
 LikelihoodInterval.cxx:165
 LikelihoodInterval.cxx:166
 LikelihoodInterval.cxx:167
 LikelihoodInterval.cxx:168
 LikelihoodInterval.cxx:169
 LikelihoodInterval.cxx:170
 LikelihoodInterval.cxx:171
 LikelihoodInterval.cxx:172
 LikelihoodInterval.cxx:173
 LikelihoodInterval.cxx:174
 LikelihoodInterval.cxx:175
 LikelihoodInterval.cxx:176
 LikelihoodInterval.cxx:177
 LikelihoodInterval.cxx:178
 LikelihoodInterval.cxx:179
 LikelihoodInterval.cxx:180
 LikelihoodInterval.cxx:181
 LikelihoodInterval.cxx:182
 LikelihoodInterval.cxx:183
 LikelihoodInterval.cxx:184
 LikelihoodInterval.cxx:185
 LikelihoodInterval.cxx:186
 LikelihoodInterval.cxx:187
 LikelihoodInterval.cxx:188
 LikelihoodInterval.cxx:189
 LikelihoodInterval.cxx:190
 LikelihoodInterval.cxx:191
 LikelihoodInterval.cxx:192
 LikelihoodInterval.cxx:193
 LikelihoodInterval.cxx:194
 LikelihoodInterval.cxx:195
 LikelihoodInterval.cxx:196
 LikelihoodInterval.cxx:197
 LikelihoodInterval.cxx:198
 LikelihoodInterval.cxx:199
 LikelihoodInterval.cxx:200
 LikelihoodInterval.cxx:201
 LikelihoodInterval.cxx:202
 LikelihoodInterval.cxx:203
 LikelihoodInterval.cxx:204
 LikelihoodInterval.cxx:205
 LikelihoodInterval.cxx:206
 LikelihoodInterval.cxx:207
 LikelihoodInterval.cxx:208
 LikelihoodInterval.cxx:209
 LikelihoodInterval.cxx:210
 LikelihoodInterval.cxx:211
 LikelihoodInterval.cxx:212
 LikelihoodInterval.cxx:213
 LikelihoodInterval.cxx:214
 LikelihoodInterval.cxx:215
 LikelihoodInterval.cxx:216
 LikelihoodInterval.cxx:217
 LikelihoodInterval.cxx:218
 LikelihoodInterval.cxx:219
 LikelihoodInterval.cxx:220
 LikelihoodInterval.cxx:221
 LikelihoodInterval.cxx:222
 LikelihoodInterval.cxx:223
 LikelihoodInterval.cxx:224
 LikelihoodInterval.cxx:225
 LikelihoodInterval.cxx:226
 LikelihoodInterval.cxx:227
 LikelihoodInterval.cxx:228
 LikelihoodInterval.cxx:229
 LikelihoodInterval.cxx:230
 LikelihoodInterval.cxx:231
 LikelihoodInterval.cxx:232
 LikelihoodInterval.cxx:233
 LikelihoodInterval.cxx:234
 LikelihoodInterval.cxx:235
 LikelihoodInterval.cxx:236
 LikelihoodInterval.cxx:237
 LikelihoodInterval.cxx:238
 LikelihoodInterval.cxx:239
 LikelihoodInterval.cxx:240
 LikelihoodInterval.cxx:241
 LikelihoodInterval.cxx:242
 LikelihoodInterval.cxx:243
 LikelihoodInterval.cxx:244
 LikelihoodInterval.cxx:245
 LikelihoodInterval.cxx:246
 LikelihoodInterval.cxx:247
 LikelihoodInterval.cxx:248
 LikelihoodInterval.cxx:249
 LikelihoodInterval.cxx:250
 LikelihoodInterval.cxx:251
 LikelihoodInterval.cxx:252
 LikelihoodInterval.cxx:253
 LikelihoodInterval.cxx:254
 LikelihoodInterval.cxx:255
 LikelihoodInterval.cxx:256
 LikelihoodInterval.cxx:257
 LikelihoodInterval.cxx:258
 LikelihoodInterval.cxx:259
 LikelihoodInterval.cxx:260
 LikelihoodInterval.cxx:261
 LikelihoodInterval.cxx:262
 LikelihoodInterval.cxx:263
 LikelihoodInterval.cxx:264
 LikelihoodInterval.cxx:265
 LikelihoodInterval.cxx:266
 LikelihoodInterval.cxx:267
 LikelihoodInterval.cxx:268
 LikelihoodInterval.cxx:269
 LikelihoodInterval.cxx:270
 LikelihoodInterval.cxx:271
 LikelihoodInterval.cxx:272
 LikelihoodInterval.cxx:273
 LikelihoodInterval.cxx:274
 LikelihoodInterval.cxx:275
 LikelihoodInterval.cxx:276
 LikelihoodInterval.cxx:277
 LikelihoodInterval.cxx:278
 LikelihoodInterval.cxx:279
 LikelihoodInterval.cxx:280
 LikelihoodInterval.cxx:281
 LikelihoodInterval.cxx:282
 LikelihoodInterval.cxx:283
 LikelihoodInterval.cxx:284
 LikelihoodInterval.cxx:285
 LikelihoodInterval.cxx:286
 LikelihoodInterval.cxx:287
 LikelihoodInterval.cxx:288
 LikelihoodInterval.cxx:289
 LikelihoodInterval.cxx:290
 LikelihoodInterval.cxx:291
 LikelihoodInterval.cxx:292
 LikelihoodInterval.cxx:293
 LikelihoodInterval.cxx:294
 LikelihoodInterval.cxx:295
 LikelihoodInterval.cxx:296
 LikelihoodInterval.cxx:297
 LikelihoodInterval.cxx:298
 LikelihoodInterval.cxx:299
 LikelihoodInterval.cxx:300
 LikelihoodInterval.cxx:301
 LikelihoodInterval.cxx:302
 LikelihoodInterval.cxx:303
 LikelihoodInterval.cxx:304
 LikelihoodInterval.cxx:305
 LikelihoodInterval.cxx:306
 LikelihoodInterval.cxx:307
 LikelihoodInterval.cxx:308
 LikelihoodInterval.cxx:309
 LikelihoodInterval.cxx:310
 LikelihoodInterval.cxx:311
 LikelihoodInterval.cxx:312
 LikelihoodInterval.cxx:313
 LikelihoodInterval.cxx:314
 LikelihoodInterval.cxx:315
 LikelihoodInterval.cxx:316
 LikelihoodInterval.cxx:317
 LikelihoodInterval.cxx:318
 LikelihoodInterval.cxx:319
 LikelihoodInterval.cxx:320
 LikelihoodInterval.cxx:321
 LikelihoodInterval.cxx:322
 LikelihoodInterval.cxx:323
 LikelihoodInterval.cxx:324
 LikelihoodInterval.cxx:325
 LikelihoodInterval.cxx:326
 LikelihoodInterval.cxx:327
 LikelihoodInterval.cxx:328
 LikelihoodInterval.cxx:329
 LikelihoodInterval.cxx:330
 LikelihoodInterval.cxx:331
 LikelihoodInterval.cxx:332
 LikelihoodInterval.cxx:333
 LikelihoodInterval.cxx:334
 LikelihoodInterval.cxx:335
 LikelihoodInterval.cxx:336
 LikelihoodInterval.cxx:337
 LikelihoodInterval.cxx:338
 LikelihoodInterval.cxx:339
 LikelihoodInterval.cxx:340
 LikelihoodInterval.cxx:341
 LikelihoodInterval.cxx:342
 LikelihoodInterval.cxx:343
 LikelihoodInterval.cxx:344
 LikelihoodInterval.cxx:345
 LikelihoodInterval.cxx:346
 LikelihoodInterval.cxx:347
 LikelihoodInterval.cxx:348
 LikelihoodInterval.cxx:349
 LikelihoodInterval.cxx:350
 LikelihoodInterval.cxx:351
 LikelihoodInterval.cxx:352
 LikelihoodInterval.cxx:353
 LikelihoodInterval.cxx:354
 LikelihoodInterval.cxx:355
 LikelihoodInterval.cxx:356
 LikelihoodInterval.cxx:357
 LikelihoodInterval.cxx:358
 LikelihoodInterval.cxx:359
 LikelihoodInterval.cxx:360
 LikelihoodInterval.cxx:361
 LikelihoodInterval.cxx:362
 LikelihoodInterval.cxx:363
 LikelihoodInterval.cxx:364
 LikelihoodInterval.cxx:365
 LikelihoodInterval.cxx:366
 LikelihoodInterval.cxx:367
 LikelihoodInterval.cxx:368
 LikelihoodInterval.cxx:369
 LikelihoodInterval.cxx:370
 LikelihoodInterval.cxx:371
 LikelihoodInterval.cxx:372
 LikelihoodInterval.cxx:373
 LikelihoodInterval.cxx:374
 LikelihoodInterval.cxx:375
 LikelihoodInterval.cxx:376
 LikelihoodInterval.cxx:377
 LikelihoodInterval.cxx:378
 LikelihoodInterval.cxx:379
 LikelihoodInterval.cxx:380
 LikelihoodInterval.cxx:381
 LikelihoodInterval.cxx:382
 LikelihoodInterval.cxx:383
 LikelihoodInterval.cxx:384
 LikelihoodInterval.cxx:385
 LikelihoodInterval.cxx:386
 LikelihoodInterval.cxx:387
 LikelihoodInterval.cxx:388
 LikelihoodInterval.cxx:389
 LikelihoodInterval.cxx:390
 LikelihoodInterval.cxx:391
 LikelihoodInterval.cxx:392
 LikelihoodInterval.cxx:393
 LikelihoodInterval.cxx:394
 LikelihoodInterval.cxx:395
 LikelihoodInterval.cxx:396
 LikelihoodInterval.cxx:397
 LikelihoodInterval.cxx:398
 LikelihoodInterval.cxx:399