```// @(#)root/roostats:\$Id\$
// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
/*************************************************************************
*                                                                       *
* 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\$
* 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 "TMinuitMinimizer.h"

#include <string>
#include <algorithm>
#include <functional>
#include <ctype.h>   // need to use c version of toupper defined here

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

ClassImp(RooStats::LikelihoodInterval) ;

using namespace RooStats;
using namespace std;

//____________________________________________________________________
LikelihoodInterval::LikelihoodInterval(const char* name) :
ConfInterval(name), fBestFitParams(0), fLikelihoodRatio(0), fConfidenceLevel(0.95)
{
// 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),
fConfidenceLevel(0.95)
{
// 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.

RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow();
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;
RooMsgService::instance().setGlobalKillBelow(msglevel);
return false;
}

// make sure likelihood ratio is set
if(!fLikelihoodRatio) {
std::cout << "likelihood ratio not set" << std::endl;
RooMsgService::instance().setGlobalKillBelow(msglevel);
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;
RooMsgService::instance().setGlobalKillBelow(msglevel);
return true;
}

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

RooMsgService::instance().setGlobalKillBelow(msglevel);

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, bool & status)
{
// Compute lower limit, check first if limit has been computed
// status is a boolean flag which will b set to false in case of error
// and is true if calculation is successful
// in case of error return also a lower limit value of zero

double lower = 0;
double upper = 0;
status = FindLimits(param, lower, upper);
return lower;
}

//____________________________________________________________________
Double_t LikelihoodInterval::UpperLimit(const RooRealVar& param, bool & status)
{
// Compute upper limit, check first if limit has been computed
// status is a boolean flag which will b set to false in case of error
// and is true if calculation is successful
// in case of error return also a lower limit value of zero

double lower = 0;
double upper = 0;
status = 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();
// need to remove constant parameters
RemoveConstantParameters(partmp);

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->getError() );
}
}
}

// now do binding of NLL with a functor for Minimizer
if (RooStats::IsNLLOffset() ) {
ccoutI(InputArguments) << "LikelihoodInterval: using nll offset - set all RooAbsReal to hide the offset  " << std::endl;
RooAbsReal::setHideOffset(kFALSE); // need to keep this false
}
fFunctor = std::shared_ptr<RooFunctor>(new RooFunctor(nll, RooArgSet(), params ));

std::string minimType =  ROOT::Math::MinimizerOptions::DefaultMinimizerType();
std::transform(minimType.begin(), minimType.end(), minimType.begin(), (int(*)(int)) tolower );
*minimType.begin() = toupper( *minimType.begin());

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;
}
// do not use static instance of TMInuit which could interfere with RooFit
if (minimType == "Minuit")  TMinuitMinimizer::UseStaticMinuit(false);
// create minimizer class

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

fMinFunc = std::shared_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
// check first if limit has been computed
// otherwise compute limit using MINOS
// in case of failure lower and upper will mantain previous value (will not be modified)

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();
RemoveConstantParameters(partmp);
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;

double elow = 0;
double eup = 0;
ret = fMinimizer->GetMinosError(ivarX, elow, eup );
if (!ret)  {
ccoutE(Minimization) << "Error  running Minos for parameter " << param.GetName() << std::endl;
return false;
}

// 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;

// store limits in the map
// minos return error limit = minValue +/- error
fLowerLimits[param.GetName()] = lower;
fUpperLimits[param.GetName()] = upper;

return true;
}

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();
RemoveConstantParameters(partmp);
RooArgList params(*partmp);
delete partmp;
int ix = params.index(&paramX);
int iy = params.index(&paramY);
if (ix < 0 || iy < 0) {
coutE(InputArguments) << "LikelihoodInterval - 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) {
coutE(Eval) << "LikelihoodInterval - 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;
coutI(Minimization)  << "LikelihoodInterval - Finding the contour of " << paramX.GetName() << " ( " << ivarX << " ) and " << paramY.GetName() << " ( " << ivarY << " ) " << std::endl;
ret = fMinimizer->Contour(ivarX, ivarY, ncp, x, y );
if (!ret) {
coutE(Minimization) << "LikelihoodInterval - Error finding contour for parameters " << paramX.GetName() << " and " << paramY.GetName()  << std::endl;
return 0;
}
if (int(ncp) < npoints) {
coutW(Minimization) << "LikelihoodInterval -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
LikelihoodInterval.cxx:400
LikelihoodInterval.cxx:401
LikelihoodInterval.cxx:402
LikelihoodInterval.cxx:403
LikelihoodInterval.cxx:404
LikelihoodInterval.cxx:405
LikelihoodInterval.cxx:406
LikelihoodInterval.cxx:407
LikelihoodInterval.cxx:408
LikelihoodInterval.cxx:409
LikelihoodInterval.cxx:410
LikelihoodInterval.cxx:411
LikelihoodInterval.cxx:412
LikelihoodInterval.cxx:413
LikelihoodInterval.cxx:414
LikelihoodInterval.cxx:415
LikelihoodInterval.cxx:416
LikelihoodInterval.cxx:417
LikelihoodInterval.cxx:418
LikelihoodInterval.cxx:419
LikelihoodInterval.cxx:420
LikelihoodInterval.cxx:421
LikelihoodInterval.cxx:422
LikelihoodInterval.cxx:423
LikelihoodInterval.cxx:424
LikelihoodInterval.cxx:425
LikelihoodInterval.cxx:426
LikelihoodInterval.cxx:427
LikelihoodInterval.cxx:428