// @(#)root/roostats:$Id$
// Authors: Kevin Belasco        17/06/2009
// Authors: Kyle Cranmer         17/06/2009
/*************************************************************************
*                                                                       *
* For the licensing terms see $ROOTSYS/LICENSE. * * For the list of contributors see$ROOTSYS/README/CREDITS.             *
*************************************************************************/

//_________________________________________________
/*
BEGIN_HTML
<p>
MCMCInterval is a concrete implementation of the RooStats::ConfInterval
interface.  It takes as input Markov Chain of data points in the parameter
space generated by Monte Carlo using the Metropolis algorithm.  From the Markov
Chain, the confidence interval can be determined in two ways:
</p>

<p>
Using a Kernel-Estimated PDF: (not the default method)
</p>
<p>
A RooNDKeysPdf is constructed from the data set using adaptive kernel width.
With this RooNDKeysPdf F, we then integrate over the most likely domain in the
parameter space (tallest points in the posterior RooNDKeysPdf) until the target
confidence level is reached within an acceptable neighborhood as defined by
SetEpsilon(). More specifically: we calculate the following for different
cutoff values C until we reach the target confidence level: \int_{ F >= C } F
d{normset}.
Important note: this is not the default method because of a bug in constructing
the RooNDKeysPdf from a weighted data set.  Configure to use this method by
calling SetUseKeys(true), and the data set will be interpreted without weights.
</p>

<p>
Using a binned data set: (the default method)
</p>
This is the binned analog of the continuous integrative method that uses the
kernel-estimated PDF.  The points in the Markov Chain are put into a binned
data set and the interval is then calculated by adding the heights of the bins
in decreasing order until the desired level of confidence has been reached.
Note that this means the actual confidence level is >= the confidence level
prescribed by the client (unless the user calls SetHistStrict(kFALSE)).  This
method is the default but may not remain as such in future releases, so you may
wish to explicitly configure to use this method by calling SetUseKeys(false)
</p>

<p>
These are not the only ways for the confidence interval to be determined, and
other possibilities are being considered being added, especially for the
1-dimensional case.
</p>

<p>
One can ask an MCMCInterval for the lower and upper limits on a specific
parameter of interest in the interval.  Note that this works better for some
distributions (ones with exactly one local maximum) than others, and sometimes
has little value.
</p>
END_HTML
*/
//_________________________________________________

#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif

#ifndef ROOT_TMath
#include "TMath.h"
#endif

#ifndef RooStats_MCMCInterval
#include "RooStats/MCMCInterval.h"
#endif
#ifndef ROOSTATS_MarkovChain
#include "RooStats/MarkovChain.h"
#endif
#ifndef RooStats_Heaviside
#include "RooStats/Heaviside.h"
#endif
#ifndef ROO_DATA_HIST
#include "RooDataHist.h"
#endif
#ifndef ROO_KEYS_PDF
#include "RooNDKeysPdf.h"
#endif
#ifndef ROO_PRODUCT
#include "RooProduct.h"
#endif
#ifndef RooStats_RooStatsUtils
#include "RooStats/RooStatsUtils.h"
#endif
#ifndef ROO_REAL_VAR
#include "RooRealVar.h"
#endif
#ifndef ROO_ARG_LIST
#include "RooArgList.h"
#endif
#ifndef ROOT_TIterator
#include "TIterator.h"
#endif
#ifndef ROOT_TH1
#include "TH1.h"
#endif
#ifndef ROOT_TH1F
#include "TH1F.h"
#endif
#ifndef ROOT_TH2F
#include "TH2F.h"
#endif
#ifndef ROOT_TH3F
#include "TH3F.h"
#endif
#ifndef ROO_MSG_SERVICE
#include "RooMsgService.h"
#endif
#ifndef ROO_GLOBAL_FUNC
#include "RooGlobalFunc.h"
#endif
#ifndef ROOT_TObject
#include "TObject.h"
#endif
#ifndef ROOT_THnSparse
#include "THnSparse.h"
#endif
#ifndef ROO_NUMBER
#include "RooNumber.h"
#endif
//#ifndef ROOT_TFile
//#include "TFile.h"
//#endif

#include <cstdlib>
#include <string>
#include <algorithm>

ClassImp(RooStats::MCMCInterval);

using namespace RooFit;
using namespace RooStats;
using namespace std;

static const Double_t DEFAULT_EPSILON = 0.01;
static const Double_t DEFAULT_DELTA   = 10e-6;

MCMCInterval::MCMCInterval(const char* name)
: ConfInterval(name)
{
fConfidenceLevel = 0.0;
fHistConfLevel = 0.0;
fKeysConfLevel = 0.0;
fTFConfLevel = 0.0;
fFull = 0.0;
fChain = NULL;
fAxes = NULL;
fDataHist = NULL;
fSparseHist = NULL;
fVector.clear();
fKeysPdf = NULL;
fProduct = NULL;
fHeaviside = NULL;
fKeysDataHist = NULL;
fCutoffVar = NULL;
fHist = NULL;
fNumBurnInSteps = 0;
fHistCutoff = -1;
fKeysCutoff = -1;
fDimension = 1;
fUseKeys = kFALSE;
fUseSparseHist = kFALSE;
fIsHistStrict = kTRUE;
fEpsilon = DEFAULT_EPSILON;
fDelta = DEFAULT_DELTA;
fIntervalType = kShortest;
fTFLower = -1.0 * RooNumber::infinity();
fTFUpper = RooNumber::infinity();
fVecWeight = 0;
fLeftSideTF = -1;
}

MCMCInterval::MCMCInterval(const char* name,
const RooArgSet& parameters, MarkovChain& chain) : ConfInterval(name)
{
fNumBurnInSteps = 0;
fConfidenceLevel = 0.0;
fHistConfLevel = 0.0;
fKeysConfLevel = 0.0;
fTFConfLevel = 0.0;
fFull = 0.0;
fAxes = NULL;
fChain = &chain;
fDataHist = NULL;
fSparseHist = NULL;
fVector.clear();
fKeysPdf = NULL;
fProduct = NULL;
fHeaviside = NULL;
fKeysDataHist = NULL;
fCutoffVar = NULL;
fHist = NULL;
fHistCutoff = -1;
fKeysCutoff = -1;
fUseKeys = kFALSE;
fUseSparseHist = kFALSE;
fIsHistStrict = kTRUE;
fEpsilon = DEFAULT_EPSILON;
SetParameters(parameters);
fDelta = DEFAULT_DELTA;
fIntervalType = kShortest;
fTFLower = -1.0 * RooNumber::infinity();
fTFUpper = RooNumber::infinity();
fVecWeight = 0;
fLeftSideTF = -1;
}

MCMCInterval::~MCMCInterval()
{
// destructor
delete[] fAxes;
delete fHist;
delete fChain;
// kbelasco: check here for memory management errors
delete fDataHist;
delete fSparseHist;
delete fKeysPdf;
delete fProduct;
delete fHeaviside;
delete fKeysDataHist;
delete fCutoffVar;
}

struct CompareDataHistBins {
CompareDataHistBins(RooDataHist* hist) : fDataHist(hist) {}
bool operator() (Int_t bin1 , Int_t bin2) {
fDataHist->get(bin1);
Double_t n1 = fDataHist->weight();
fDataHist->get(bin2);
Double_t n2 = fDataHist->weight();
return (n1 < n2);
}
RooDataHist* fDataHist;
};

struct CompareSparseHistBins {
CompareSparseHistBins(THnSparse* hist) : fSparseHist(hist) {}
bool operator() (Long_t bin1, Long_t bin2) {
Double_t n1 = fSparseHist->GetBinContent(bin1);
Double_t n2 = fSparseHist->GetBinContent(bin2);
return (n1 < n2);
}
THnSparse* fSparseHist;
};

struct CompareVectorIndices {
CompareVectorIndices(MarkovChain* chain, RooRealVar* param) :
fChain(chain), fParam(param) {}
bool operator() (Int_t i, Int_t j) {
Double_t xi = fChain->Get(i)->getRealValue(fParam->GetName());
Double_t xj = fChain->Get(j)->getRealValue(fParam->GetName());
return (xi < xj);
}
MarkovChain* fChain;
RooRealVar* fParam;
};

// kbelasco: for this method, consider running DetermineInterval() if
// fKeysPdf==NULL, fSparseHist==NULL, fDataHist==NULL, or fVector.size()==0
// rather than just returning false.  Though this should not be an issue
// because nobody should be able to get an MCMCInterval that has their interval
// or posterior representation NULL/empty since they should only get this
// through the MCMCCalculator
Bool_t MCMCInterval::IsInInterval(const RooArgSet& point) const
{
if (fIntervalType == kShortest) {
if (fUseKeys) {
if (fKeysPdf == NULL)
return false;

// evaluate keyspdf at point and return whether >= cutoff
RooStats::SetParameters(&point, const_cast<RooArgSet *>(&fParameters));
return fKeysPdf->getVal(&fParameters) >= fKeysCutoff;
} else {
if (fUseSparseHist) {
if (fSparseHist == NULL)
return false;

// evalute sparse hist at bin where point lies and return
// whether >= cutoff
RooStats::SetParameters(&point,
const_cast<RooArgSet*>(&fParameters));
Long_t bin;
// kbelasco: consider making x static
Double_t* x = new Double_t[fDimension];
for (Int_t i = 0; i < fDimension; i++)
x[i] = fAxes[i]->getVal();
bin = fSparseHist->GetBin(x, kFALSE);
Double_t weight = fSparseHist->GetBinContent((Long64_t)bin);
delete[] x;
return (weight >= (Double_t)fHistCutoff);
} else {
if (fDataHist == NULL)
return false;

// evaluate data hist at bin where point lies and return whether
// >= cutoff
Int_t bin;
bin = fDataHist->getIndex(point);
fDataHist->get(bin);
return (fDataHist->weight() >= (Double_t)fHistCutoff);
}
}
} else if (fIntervalType == kTailFraction) {
if (fVector.size() == 0)
return false;

// return whether value of point is within the range
Double_t x = point.getRealValue(fAxes[0]->GetName());
if (fTFLower <= x && x <= fTFUpper)
return true;

return false;
}

coutE(InputArguments) << "Error in MCMCInterval::IsInInterval: "
<< "Interval type not set.  Returning false." << endl;
return false;
}

void MCMCInterval::SetConfidenceLevel(Double_t cl)
{
fConfidenceLevel = cl;
DetermineInterval();
}

// kbelasco: update this or just take it out
// kbelasco: consider keeping this around but changing the implementation
// to set the number of bins for each RooRealVar and then reacreating the
// histograms
//void MCMCInterval::SetNumBins(Int_t numBins)
//{
//   if (numBins > 0) {
//      fPreferredNumBins = numBins;
//      for (Int_t d = 0; d < fDimension; d++)
//         fNumBins[d] = numBins;
//   }
//   else {
//      coutE(Eval) << "* Error in MCMCInterval::SetNumBins: " <<
//                     "Negative number of bins given: " << numBins << endl;
//      return;
//   }
//
//   // If the histogram already exists, recreate it with the new bin numbers
//   if (fHist != NULL)
//      CreateHist();
//}

void MCMCInterval::SetAxes(RooArgList& axes)
{
Int_t size = axes.getSize();
if (size != fDimension) {
coutE(InputArguments) << "* Error in MCMCInterval::SetAxes: " <<
"number of variables in axes (" << size <<
") doesn't match number of parameters ("
<< fDimension << ")" << endl;
return;
}
for (Int_t i = 0; i < size; i++)
fAxes[i] = (RooRealVar*)axes.at(i);
}

void MCMCInterval::CreateKeysPdf()
{
// kbelasco: check here for memory leak.  does RooNDKeysPdf use
// the RooArgList passed to it or does it make a clone?
// also check for memory leak from chain, does RooNDKeysPdf clone that?
if (fAxes == NULL || fParameters.getSize() == 0) {
coutE(InputArguments) << "Error in MCMCInterval::CreateKeysPdf: "
<< "parameters have not been set." << endl;
return;
}

if (fNumBurnInSteps >= fChain->Size()) {
coutE(InputArguments) <<
"MCMCInterval::CreateKeysPdf: creation of Keys PDF failed: " <<
"Number of burn-in steps (num steps to ignore) >= number of steps " <<
"in Markov chain." << endl;
delete fKeysPdf;
delete fCutoffVar;
delete fHeaviside;
delete fProduct;
fKeysPdf = NULL;
fCutoffVar = NULL;
fHeaviside = NULL;
fProduct = NULL;
return;
}

RooDataSet* chain = fChain->GetAsDataSet(SelectVars(fParameters),
EventRange(fNumBurnInSteps, fChain->Size()));
RooArgList* paramsList = new RooArgList();
for (Int_t i = 0; i < fDimension; i++)

// kbelasco: check for memory leaks with chain.  who owns it? does
// RooNDKeysPdf take ownership?
fKeysPdf = new RooNDKeysPdf("keysPDF", "Keys PDF", *paramsList, *chain, "a");
fCutoffVar = new RooRealVar("cutoff", "cutoff", 0);
fHeaviside = new Heaviside("heaviside", "Heaviside", *fKeysPdf, *fCutoffVar);
fProduct = new RooProduct("product", "Keys PDF & Heaviside Product",
RooArgSet(*fKeysPdf, *fHeaviside));
}

void MCMCInterval::CreateHist()
{
if (fAxes == NULL || fChain == NULL) {
coutE(Eval) << "* Error in MCMCInterval::CreateHist(): " <<
"Crucial data member was NULL." << endl;
coutE(Eval) << "Make sure to fully construct/initialize." << endl;
return;
}
if (fHist != NULL)
delete fHist;

if (fNumBurnInSteps >= fChain->Size()) {
coutE(InputArguments) <<
"MCMCInterval::CreateHist: creation of histogram failed: " <<
"Number of burn-in steps (num steps to ignore) >= number of steps " <<
"in Markov chain." << endl;
fHist = NULL;
return;
}

if (fDimension == 1)
fHist = new TH1F("posterior", "MCMC Posterior Histogram",
fAxes[0]->numBins(), fAxes[0]->getMin(), fAxes[0]->getMax());

else if (fDimension == 2)
fHist = new TH2F("posterior", "MCMC Posterior Histogram",
fAxes[0]->numBins(), fAxes[0]->getMin(), fAxes[0]->getMax(),
fAxes[1]->numBins(), fAxes[1]->getMin(), fAxes[1]->getMax());

else if (fDimension == 3)
fHist = new TH3F("posterior", "MCMC Posterior Histogram",
fAxes[0]->numBins(), fAxes[0]->getMin(), fAxes[0]->getMax(),
fAxes[1]->numBins(), fAxes[1]->getMin(), fAxes[1]->getMax(),
fAxes[2]->numBins(), fAxes[2]->getMin(), fAxes[2]->getMax());

else {
coutE(Eval) << "* Error in MCMCInterval::CreateHist() : " <<
"TH1* couldn't handle dimension: " << fDimension << endl;
return;
}

// Fill histogram
Int_t size = fChain->Size();
const RooArgSet* entry;
for (Int_t i = fNumBurnInSteps; i < size; i++) {
entry = fChain->Get(i);
if (fDimension == 1)
((TH1F*)fHist)->Fill(entry->getRealValue(fAxes[0]->GetName()),
fChain->Weight());
else if (fDimension == 2)
((TH2F*)fHist)->Fill(entry->getRealValue(fAxes[0]->GetName()),
entry->getRealValue(fAxes[1]->GetName()),
fChain->Weight());
else
((TH3F*)fHist)->Fill(entry->getRealValue(fAxes[0]->GetName()),
entry->getRealValue(fAxes[1]->GetName()),
entry->getRealValue(fAxes[2]->GetName()),
fChain->Weight());
}

if (fDimension >= 1)
fHist->GetXaxis()->SetTitle(fAxes[0]->GetName());
if (fDimension >= 2)
fHist->GetYaxis()->SetTitle(fAxes[1]->GetName());
if (fDimension >= 3)
fHist->GetZaxis()->SetTitle(fAxes[2]->GetName());
}

void MCMCInterval::CreateSparseHist()
{
if (fAxes == NULL || fChain == NULL) {
coutE(InputArguments) << "* Error in MCMCInterval::CreateSparseHist(): "
<< "Crucial data member was NULL." << endl;
coutE(InputArguments) << "Make sure to fully construct/initialize."
<< endl;
return;
}
if (fSparseHist != NULL)
delete fSparseHist;

Double_t* min = new Double_t[fDimension];
Double_t* max = new Double_t[fDimension];
Int_t* bins = new Int_t[fDimension];
for (Int_t i = 0; i < fDimension; i++) {
min[i] = fAxes[i]->getMin();
max[i] = fAxes[i]->getMax();
bins[i] = fAxes[i]->numBins();
}
fSparseHist = new THnSparseF("posterior", "MCMC Posterior Histogram",
fDimension, bins, min, max);

delete[] min;
delete[] max;
delete[] bins;

// kbelasco: it appears we need to call Sumw2() just to get the
// histogram to keep a running total of the weight so that Getsumw doesn't
// just return 0
fSparseHist->Sumw2();

if (fNumBurnInSteps >= fChain->Size()) {
coutE(InputArguments) <<
"MCMCInterval::CreateSparseHist: creation of histogram failed: " <<
"Number of burn-in steps (num steps to ignore) >= number of steps " <<
"in Markov chain." << endl;
}

// Fill histogram
Int_t size = fChain->Size();
const RooArgSet* entry;
Double_t* x = new Double_t[fDimension];
for (Int_t i = fNumBurnInSteps; i < size; i++) {
entry = fChain->Get(i);
for (Int_t ii = 0; ii < fDimension; ii++)
x[ii] = entry->getRealValue(fAxes[ii]->GetName());
fSparseHist->Fill(x, fChain->Weight());
}
delete[] x;
}

void MCMCInterval::CreateDataHist()
{
if (fParameters.getSize() == 0 || fChain == NULL) {
coutE(Eval) << "* Error in MCMCInterval::CreateDataHist(): " <<
"Crucial data member was NULL or empty." << endl;
coutE(Eval) << "Make sure to fully construct/initialize." << endl;
return;
}

if (fNumBurnInSteps >= fChain->Size()) {
coutE(InputArguments) <<
"MCMCInterval::CreateDataHist: creation of histogram failed: " <<
"Number of burn-in steps (num steps to ignore) >= number of steps " <<
"in Markov chain." << endl;
fDataHist = NULL;
return;
}

fDataHist = fChain->GetAsDataHist(SelectVars(fParameters),
EventRange(fNumBurnInSteps, fChain->Size()));
}

void MCMCInterval::CreateVector(RooRealVar* param)
{
fVector.clear();
fVecWeight = 0;

if (fChain == NULL) {
coutE(InputArguments) << "* Error in MCMCInterval::CreateVector(): " <<
"Crucial data member (Markov chain) was NULL." << endl;
coutE(InputArguments) << "Make sure to fully construct/initialize."
<< endl;
return;
}

if (fNumBurnInSteps >= fChain->Size()) {
coutE(InputArguments) <<
"MCMCInterval::CreateVector: creation of vector failed: " <<
"Number of burn-in steps (num steps to ignore) >= number of steps " <<
"in Markov chain." << endl;
}

// Fill vector
Int_t size = fChain->Size() - fNumBurnInSteps;
fVector.resize(size);
Int_t i;
Int_t chainIndex;
for (i = 0; i < size; i++) {
chainIndex = i + fNumBurnInSteps;
fVector[i] = chainIndex;
fVecWeight += fChain->Weight(chainIndex);
}

stable_sort(fVector.begin(), fVector.end(),
CompareVectorIndices(fChain, param));
}

void MCMCInterval::SetParameters(const RooArgSet& parameters)
{
fParameters.removeAll();
fDimension = fParameters.getSize();
if (fAxes != NULL)
delete[] fAxes;
fAxes = new RooRealVar*[fDimension];
TIterator* it = fParameters.createIterator();
Int_t n = 0;
TObject* obj;
while ((obj = it->Next()) != NULL) {
if (dynamic_cast<RooRealVar*>(obj) != NULL)
fAxes[n] = (RooRealVar*)obj;
else
coutE(Eval) << "* Error in MCMCInterval::SetParameters: " <<
obj->GetName() << " not a RooRealVar*" << std::endl;
n++;
}
delete it;
}

void MCMCInterval::DetermineInterval()
{
switch (fIntervalType) {
case kShortest:
DetermineShortestInterval();
break;
case kTailFraction:
DetermineTailFractionInterval();
break;
default:
coutE(InputArguments) << "MCMCInterval::DetermineInterval(): " <<
"Error: Interval type not set" << endl;
break;
}
}

void MCMCInterval::DetermineShortestInterval()
{
if (fUseKeys)
DetermineByKeys();
else
DetermineByHist();
}

void MCMCInterval::DetermineTailFractionInterval()
{
if (fLeftSideTF < 0 || fLeftSideTF > 1) {
coutE(InputArguments) << "MCMCInterval::DetermineTailFractionInterval: "
<< "Fraction must be in the range [0, 1].  "
<< fLeftSideTF << "is not allowed." << endl;
return;
}

if (fDimension != 1) {
coutE(InputArguments) << "MCMCInterval::DetermineTailFractionInterval(): "
<< "Error: Can only find a tail-fraction interval for 1-D intervals"
<< endl;
return;
}

if (fAxes == NULL) {
coutE(InputArguments) << "MCMCInterval::DetermineTailFractionInterval(): "
<< "Crucial data member was NULL." << endl;
coutE(InputArguments) << "Make sure to fully construct/initialize."
<< endl;
return;
}

// kbelasco: fill in code here to find interval
//
// also make changes so that calling GetPosterior...() returns NULL
// when fIntervalType == kTailFraction, since there really
// is no posterior for this type of interval determination
if (fVector.size() == 0)
CreateVector(fAxes[0]);

if (fVector.size() == 0 || fVecWeight == 0) {
// if size is still 0, then creation failed.
// if fVecWeight == 0, then there are no entries (indicates the same
// error as fVector.size() == 0 because that only happens when
// fNumBurnInSteps >= fChain->Size())
// either way, reset and return
fVector.clear();
fTFLower = -1.0 * RooNumber::infinity();
fTFUpper = RooNumber::infinity();
fTFConfLevel = 0.0;
fVecWeight = 0;
return;
}

RooRealVar* param = fAxes[0];

Double_t c = fConfidenceLevel;
Double_t leftTailCutoff  = fVecWeight * (1 - c) * fLeftSideTF;
Double_t rightTailCutoff = fVecWeight * (1 - c) * (1 - fLeftSideTF);
Double_t leftTailSum  = 0;
Double_t rightTailSum = 0;

// kbelasco: consider changing these values to +infinty and -infinity
Double_t ll = param->getMin();
Double_t ul = param->getMax();

Double_t x;
Double_t w;

// save a lot of GetName() calls if compiler does not already optimize this
const char* name = param->GetName();

// find lower limit
Int_t i;
for (i = 0; i < (Int_t)fVector.size(); i++) {
x = fChain->Get(fVector[i])->getRealValue(name);
w = fChain->Weight();

if (TMath::Abs(leftTailSum + w - leftTailCutoff) <
TMath::Abs(leftTailSum - leftTailCutoff)) {
// moving the lower limit to x would bring us closer to the desired
// left tail size
ll = x;
leftTailSum += w;
} else
break;
}

// find upper limit
for (i = (Int_t)fVector.size() - 1; i >= 0; i--) {
x = fChain->Get(fVector[i])->getRealValue(name);
w = fChain->Weight();

if (TMath::Abs(rightTailSum + w - rightTailCutoff) <
TMath::Abs(rightTailSum - rightTailCutoff)) {
// moving the lower limit to x would bring us closer to the desired
// left tail size
ul = x;
rightTailSum += w;
} else
break;
}

fTFLower = ll;
fTFUpper = ul;
fTFConfLevel = 1 - (leftTailSum + rightTailSum) / fVecWeight;
}

void MCMCInterval::DetermineByKeys()
{
if (fKeysPdf == NULL)
CreateKeysPdf();

if (fKeysPdf == NULL) {
// if fKeysPdf is still NULL, then it means CreateKeysPdf failed
// so clear all the data members this function would normally determine
// and return
fFull = 0.0;
fKeysCutoff = -1;
fKeysConfLevel = 0.0;
return;
}

// now we have a keys pdf of the posterior

Double_t cutoff = 0.0;
fCutoffVar->setVal(cutoff);
RooAbsReal* integral = fProduct->createIntegral(fParameters, NormSet(fParameters));
Double_t full = integral->getVal(fParameters);
fFull = full;
delete integral;
if (full < 0.98) {
coutW(Eval) << "Warning: Integral of Keys PDF came out to " << full
<< " intead of expected value 1.  Will continue using this "
<< "factor to normalize further integrals of this PDF." << endl;
}

// kbelasco: Is there a better way to set the search range?
// from 0 to max value of Keys
// kbelasco: how to get max value?
//Double_t max = product.maxVal(product.getMaxVal(fParameters));

Double_t volume = 1.0;
TIterator* it = fParameters.createIterator();
RooRealVar* var;
while ((var = (RooRealVar*)it->Next()) != NULL)
volume *= (var->getMax() - var->getMin());
delete it;

Double_t topCutoff = full / volume;
Double_t bottomCutoff = topCutoff;
Double_t confLevel = CalcConfLevel(topCutoff, full);
if (AcceptableConfLevel(confLevel)) {
fKeysConfLevel = confLevel;
fKeysCutoff = topCutoff;
return;
}
Bool_t changed = kFALSE;
// find high end of range
while (confLevel > fConfidenceLevel) {
topCutoff *= 2.0;
confLevel = CalcConfLevel(topCutoff, full);
if (AcceptableConfLevel(confLevel)) {
fKeysConfLevel = confLevel;
fKeysCutoff = topCutoff;
return;
}
changed = kTRUE;
}
if (changed) {
bottomCutoff = topCutoff / 2.0;
} else {
changed = kFALSE;
bottomCutoff /= 2.0;
confLevel = CalcConfLevel(bottomCutoff, full);
if (AcceptableConfLevel(confLevel)) {
fKeysConfLevel = confLevel;
fKeysCutoff = bottomCutoff;
return;
}
while (confLevel < fConfidenceLevel) {
bottomCutoff /= 2.0;
confLevel = CalcConfLevel(bottomCutoff, full);
if (AcceptableConfLevel(confLevel)) {
fKeysConfLevel = confLevel;
fKeysCutoff = bottomCutoff;
return;
}
changed = kTRUE;
}
if (changed) {
topCutoff = bottomCutoff * 2.0;
}
}

coutI(Eval) << "range set: [" << bottomCutoff << ", " << topCutoff << "]"
<< endl;

cutoff = (topCutoff + bottomCutoff) / 2.0;
confLevel = CalcConfLevel(cutoff, full);

// need to use WithinDeltaFraction() because sometimes the integrating the
// posterior in this binary search seems to not have enough granularity to
// find an acceptable conf level (small no. of strange cases).
// WithinDeltaFraction causes the search to terminate when
// topCutoff is essentially equal to bottomCutoff (compared to the magnitude
// of their mean).
while (!AcceptableConfLevel(confLevel) &&
!WithinDeltaFraction(topCutoff, bottomCutoff)) {
if (confLevel > fConfidenceLevel)
bottomCutoff = cutoff;
else if (confLevel < fConfidenceLevel)
topCutoff = cutoff;
cutoff = (topCutoff + bottomCutoff) / 2.0;
coutI(Eval) << "cutoff range: [" << bottomCutoff << ", "
<< topCutoff << "]" << endl;
confLevel = CalcConfLevel(cutoff, full);
}

fKeysCutoff = cutoff;
fKeysConfLevel = confLevel;
}

void MCMCInterval::DetermineByHist()
{
if (fUseSparseHist)
DetermineBySparseHist();
else
DetermineByDataHist();
}

void MCMCInterval::DetermineBySparseHist()
{
Long_t numBins;
if (fSparseHist == NULL)
CreateSparseHist();

if (fSparseHist == NULL) {
// if fSparseHist is still NULL, then CreateSparseHist failed
fHistCutoff = -1;
fHistConfLevel = 0.0;
return;
}

numBins = (Long_t)fSparseHist->GetNbins();

std::vector<Long_t> bins(numBins);
for (Int_t ibin = 0; ibin < numBins; ibin++)
bins[ibin] = (Long_t)ibin;
std::stable_sort(bins.begin(), bins.end(), CompareSparseHistBins(fSparseHist));

Double_t nEntries = fSparseHist->GetSumw();
Double_t sum = 0;
Double_t content;
Int_t i;
// see above note on indexing to understand numBins - 3
for (i = numBins - 1; i >= 0; i--) {
content = fSparseHist->GetBinContent(bins[i]);
if ((sum + content) / nEntries >= fConfidenceLevel) {
fHistCutoff = content;
if (fIsHistStrict) {
sum += content;
i--;
break;
} else {
i++;
break;
}
}
sum += content;
}

if (fIsHistStrict) {
// keep going to find the sum
for ( ; i >= 0; i--) {
content = fSparseHist->GetBinContent(bins[i]);
if (content == fHistCutoff)
sum += content;
else
break; // content must be < fHistCutoff
}
} else {
// backtrack to find the cutoff and sum
for ( ; i < numBins; i++) {
content = fSparseHist->GetBinContent(bins[i]);
if (content > fHistCutoff) {
fHistCutoff = content;
break;
} else // content == fHistCutoff
sum -= content;
if (i == numBins - 1)
// still haven't set fHistCutoff correctly yet, and we have no bins
// left, so set fHistCutoff to something higher than the tallest bin
fHistCutoff = content + 1.0;
}
}

fHistConfLevel = sum / nEntries;
}

void MCMCInterval::DetermineByDataHist()
{
Int_t numBins;
if (fDataHist == NULL)
CreateDataHist();
if (fDataHist == NULL) {
// if fDataHist is still NULL, then CreateDataHist failed
fHistCutoff = -1;
fHistConfLevel = 0.0;
return;
}

numBins = fDataHist->numEntries();

std::vector<Int_t> bins(numBins);
for (Int_t ibin = 0; ibin < numBins; ibin++)
bins[ibin] = ibin;
std::stable_sort(bins.begin(), bins.end(), CompareDataHistBins(fDataHist));

Double_t nEntries = fDataHist->sum(kFALSE);
Double_t sum = 0;
Double_t content;
Int_t i;
for (i = numBins - 1; i >= 0; i--) {
fDataHist->get(bins[i]);
content = fDataHist->weight();
if ((sum + content) / nEntries >= fConfidenceLevel) {
fHistCutoff = content;
if (fIsHistStrict) {
sum += content;
i--;
break;
} else {
i++;
break;
}
}
sum += content;
}

if (fIsHistStrict) {
// keep going to find the sum
for ( ; i >= 0; i--) {
fDataHist->get(bins[i]);
content = fDataHist->weight();
if (content == fHistCutoff)
sum += content;
else
break; // content must be < fHistCutoff
}
} else {
// backtrack to find the cutoff and sum
for ( ; i < numBins; i++) {
fDataHist->get(bins[i]);
content = fDataHist->weight();
if (content > fHistCutoff) {
fHistCutoff = content;
break;
} else // content == fHistCutoff
sum -= content;
if (i == numBins - 1)
// still haven't set fHistCutoff correctly yet, and we have no bins
// left, so set fHistCutoff to something higher than the tallest bin
fHistCutoff = content + 1.0;
}
}

fHistConfLevel = sum / nEntries;
}

Double_t MCMCInterval::GetActualConfidenceLevel()
{
if (fIntervalType == kShortest) {
if (fUseKeys)
return fKeysConfLevel;
else
return fHistConfLevel;
} else if (fIntervalType == kTailFraction) {
return fTFConfLevel;
} else {
coutE(InputArguments) << "MCMCInterval::GetActualConfidenceLevel: "
<< "not implemented for this type of interval.  Returning 0." << endl;
return 0;
}
}

Double_t MCMCInterval::LowerLimit(RooRealVar& param)
{
switch (fIntervalType) {
case kShortest:
return LowerLimitShortest(param);
case kTailFraction:
return LowerLimitTailFraction(param);
default:
coutE(InputArguments) << "MCMCInterval::LowerLimit(): " <<
"Error: Interval type not set" << endl;
return RooNumber::infinity();
}
}

Double_t MCMCInterval::UpperLimit(RooRealVar& param)
{
switch (fIntervalType) {
case kShortest:
return UpperLimitShortest(param);
case kTailFraction:
return UpperLimitTailFraction(param);
default:
coutE(InputArguments) << "MCMCInterval::UpperLimit(): " <<
"Error: Interval type not set" << endl;
return RooNumber::infinity();
}
}

Double_t MCMCInterval::LowerLimitTailFraction(RooRealVar& /*param*/)
{
if (fTFLower == -1.0 * RooNumber::infinity())
DetermineTailFractionInterval();

return fTFLower;
}

Double_t MCMCInterval::UpperLimitTailFraction(RooRealVar& /*param*/)
{
if (fTFUpper == RooNumber::infinity())
DetermineTailFractionInterval();

return fTFUpper;
}

Double_t MCMCInterval::LowerLimitShortest(RooRealVar& param)
{
if (fUseKeys)
return LowerLimitByKeys(param);
else
return LowerLimitByHist(param);
}

Double_t MCMCInterval::UpperLimitShortest(RooRealVar& param)
{
if (fUseKeys)
return UpperLimitByKeys(param);
else
return UpperLimitByHist(param);
}

// Determine the lower limit for param on this interval
// using the binned data set
Double_t MCMCInterval::LowerLimitByHist(RooRealVar& param)
{
if (fUseSparseHist)
return LowerLimitBySparseHist(param);
else
return LowerLimitByDataHist(param);
}

// Determine the upper limit for param on this interval
// using the binned data set
Double_t MCMCInterval::UpperLimitByHist(RooRealVar& param)
{
if (fUseSparseHist)
return UpperLimitBySparseHist(param);
else
return UpperLimitByDataHist(param);
}

// Determine the lower limit for param on this interval
// using the binned data set
Double_t MCMCInterval::LowerLimitBySparseHist(RooRealVar& param)
{
if (fDimension != 1) {
coutE(InputArguments) << "In MCMCInterval::LowerLimitBySparseHist: "
<< "Sorry, will not compute lower limit unless dimension == 1" << endl;
return param.getMin();
}
if (fHistCutoff < 0)
DetermineBySparseHist(); // this initializes fSparseHist

if (fHistCutoff < 0) {
// if fHistCutoff < 0 still, then determination of interval failed
coutE(Eval) << "In MCMCInterval::LowerLimitBySparseHist: "
<< "couldn't determine cutoff.  Check that num burn in steps < num "
<< "steps in the Markov chain.  Returning param.getMin()." << endl;
return param.getMin();
}

std::vector<Int_t> coord(fDimension);
for (Int_t d = 0; d < fDimension; d++) {
if (strcmp(fAxes[d]->GetName(), param.GetName()) == 0) {
Long_t numBins = (Long_t)fSparseHist->GetNbins();
Double_t lowerLimit = param.getMax();
Double_t val;
for (Long_t i = 0; i < numBins; i++) {
if (fSparseHist->GetBinContent(i, &coord[0]) >= fHistCutoff) {
val = fSparseHist->GetAxis(d)->GetBinCenter(coord[d]);
if (val < lowerLimit)
lowerLimit = val;
}
}
return lowerLimit;
}
}
return param.getMin();
}

// Determine the lower limit for param on this interval
// using the binned data set
Double_t MCMCInterval::LowerLimitByDataHist(RooRealVar& param)
{
if (fHistCutoff < 0)
DetermineByDataHist(); // this initializes fDataHist

if (fHistCutoff < 0) {
// if fHistCutoff < 0 still, then determination of interval failed
coutE(Eval) << "In MCMCInterval::LowerLimitByDataHist: "
<< "couldn't determine cutoff.  Check that num burn in steps < num "
<< "steps in the Markov chain.  Returning param.getMin()." << endl;
return param.getMin();
}

for (Int_t d = 0; d < fDimension; d++) {
if (strcmp(fAxes[d]->GetName(), param.GetName()) == 0) {
Int_t numBins = fDataHist->numEntries();
Double_t lowerLimit = param.getMax();
Double_t val;
for (Int_t i = 0; i < numBins; i++) {
fDataHist->get(i);
if (fDataHist->weight() >= fHistCutoff) {
val = fDataHist->get()->getRealValue(param.GetName());
if (val < lowerLimit)
lowerLimit = val;
}
}
return lowerLimit;
}
}
return param.getMin();
}

// Determine the upper limit for param on this interval
// using the binned data set
Double_t MCMCInterval::UpperLimitBySparseHist(RooRealVar& param)
{
if (fDimension != 1) {
coutE(InputArguments) << "In MCMCInterval::UpperLimitBySparseHist: "
<< "Sorry, will not compute upper limit unless dimension == 1" << endl;
return param.getMax();
}
if (fHistCutoff < 0)
DetermineBySparseHist(); // this initializes fSparseHist

if (fHistCutoff < 0) {
// if fHistCutoff < 0 still, then determination of interval failed
coutE(Eval) << "In MCMCInterval::UpperLimitBySparseHist: "
<< "couldn't determine cutoff.  Check that num burn in steps < num "
<< "steps in the Markov chain.  Returning param.getMax()." << endl;
return param.getMax();
}

std::vector<Int_t> coord(fDimension);
for (Int_t d = 0; d < fDimension; d++) {
if (strcmp(fAxes[d]->GetName(), param.GetName()) == 0) {
Long_t numBins = (Long_t)fSparseHist->GetNbins();
Double_t upperLimit = param.getMin();
Double_t val;
for (Long_t i = 0; i < numBins; i++) {
if (fSparseHist->GetBinContent(i, &coord[0]) >= fHistCutoff) {
val = fSparseHist->GetAxis(d)->GetBinCenter(coord[d]);
if (val > upperLimit)
upperLimit = val;
}
}
return upperLimit;
}
}
return param.getMax();
}

// Determine the upper limit for param on this interval
// using the binned data set
Double_t MCMCInterval::UpperLimitByDataHist(RooRealVar& param)
{
if (fHistCutoff < 0)
DetermineByDataHist(); // this initializes fDataHist

if (fHistCutoff < 0) {
// if fHistCutoff < 0 still, then determination of interval failed
coutE(Eval) << "In MCMCInterval::UpperLimitByDataHist: "
<< "couldn't determine cutoff.  Check that num burn in steps < num "
<< "steps in the Markov chain.  Returning param.getMax()." << endl;
return param.getMax();
}

for (Int_t d = 0; d < fDimension; d++) {
if (strcmp(fAxes[d]->GetName(), param.GetName()) == 0) {
Int_t numBins = fDataHist->numEntries();
Double_t upperLimit = param.getMin();
Double_t val;
for (Int_t i = 0; i < numBins; i++) {
fDataHist->get(i);
if (fDataHist->weight() >= fHistCutoff) {
val = fDataHist->get()->getRealValue(param.GetName());
if (val > upperLimit)
upperLimit = val;
}
}
return upperLimit;
}
}
return param.getMax();
}

// Determine the lower limit for param on this interval
// using the keys pdf
Double_t MCMCInterval::LowerLimitByKeys(RooRealVar& param)
{
if (fKeysCutoff < 0)
DetermineByKeys();

if (fKeysDataHist == NULL)
CreateKeysDataHist();

if (fKeysCutoff < 0 || fKeysDataHist == NULL) {
// failure in determination of cutoff and/or creation of histogram
coutE(Eval) << "in MCMCInterval::LowerLimitByKeys(): "
<< "couldn't find lower limit, check that the number of burn in "
<< "steps < number of total steps in the Markov chain.  Returning "
<< "param.getMin()" << endl;
return param.getMin();
}

for (Int_t d = 0; d < fDimension; d++) {
if (strcmp(fAxes[d]->GetName(), param.GetName()) == 0) {
Int_t numBins = fKeysDataHist->numEntries();
Double_t lowerLimit = param.getMax();
Double_t val;
for (Int_t i = 0; i < numBins; i++) {
fKeysDataHist->get(i);
if (fKeysDataHist->weight() >= fKeysCutoff) {
val = fKeysDataHist->get()->getRealValue(param.GetName());
if (val < lowerLimit)
lowerLimit = val;
}
}
return lowerLimit;
}
}
return param.getMin();
}

// Determine the upper limit for param on this interval
// using the keys pdf
Double_t MCMCInterval::UpperLimitByKeys(RooRealVar& param)
{
if (fKeysCutoff < 0)
DetermineByKeys();

if (fKeysDataHist == NULL)
CreateKeysDataHist();

if (fKeysCutoff < 0 || fKeysDataHist == NULL) {
// failure in determination of cutoff and/or creation of histogram
coutE(Eval) << "in MCMCInterval::UpperLimitByKeys(): "
<< "couldn't find upper limit, check that the number of burn in "
<< "steps < number of total steps in the Markov chain.  Returning "
<< "param.getMax()" << endl;
return param.getMax();
}

for (Int_t d = 0; d < fDimension; d++) {
if (strcmp(fAxes[d]->GetName(), param.GetName()) == 0) {
Int_t numBins = fKeysDataHist->numEntries();
Double_t upperLimit = param.getMin();
Double_t val;
for (Int_t i = 0; i < numBins; i++) {
fKeysDataHist->get(i);
if (fKeysDataHist->weight() >= fKeysCutoff) {
val = fKeysDataHist->get()->getRealValue(param.GetName());
if (val > upperLimit)
upperLimit = val;
}
}
return upperLimit;
}
}
return param.getMax();
}

// Determine the approximate maximum value of the Keys PDF
Double_t MCMCInterval::GetKeysMax()
{
if (fKeysCutoff < 0)
DetermineByKeys();

if (fKeysDataHist == NULL)
CreateKeysDataHist();

if (fKeysDataHist == NULL) {
// failure in determination of cutoff and/or creation of histogram
coutE(Eval) << "in MCMCInterval::KeysMax(): "
<< "couldn't find Keys max value, check that the number of burn in "
<< "steps < number of total steps in the Markov chain.  Returning 0"
<< endl;
return 0;
}

Int_t numBins = fKeysDataHist->numEntries();
Double_t max = 0;
Double_t w;
for (Int_t i = 0; i < numBins; i++) {
fKeysDataHist->get(i);
w = fKeysDataHist->weight();
if (w > max)
max = w;
}

return max;
}

Double_t MCMCInterval::GetHistCutoff()
{
if (fHistCutoff < 0)
DetermineByHist();

return fHistCutoff;
}

Double_t MCMCInterval::GetKeysPdfCutoff()
{
if (fKeysCutoff < 0)
DetermineByKeys();

// kbelasco: if fFull hasn't been set (because Keys creation failed because
// fNumBurnInSteps >= fChain->Size()) then this will return infinity, which
// seems ok to me since it will indicate error

return fKeysCutoff / fFull;
}

Double_t MCMCInterval::CalcConfLevel(Double_t cutoff, Double_t full)
{
RooAbsReal* integral;
Double_t confLevel;
fCutoffVar->setVal(cutoff);
integral = fProduct->createIntegral(fParameters, NormSet(fParameters));
confLevel = integral->getVal(fParameters) / full;
coutI(Eval) << "cutoff = " << cutoff << ", conf = " << confLevel << endl;
//cout << "tmp: cutoff = " << cutoff << ", conf = " << confLevel << endl;
delete integral;
return confLevel;
}

TH1* MCMCInterval::GetPosteriorHist()
{
if(fConfidenceLevel == 0)
coutE(InputArguments) << "Error in MCMCInterval::GetPosteriorHist: "
<< "confidence level not set " << endl;
if (fHist == NULL)
CreateHist();

if (fHist == NULL)
// if fHist is still NULL, then CreateHist failed
return NULL;

return (TH1*) fHist->Clone("MCMCposterior_hist");
}

RooNDKeysPdf* MCMCInterval::GetPosteriorKeysPdf()
{
if (fConfidenceLevel == 0)
coutE(InputArguments) << "Error in MCMCInterval::GetPosteriorKeysPdf: "
<< "confidence level not set " << endl;
if (fKeysPdf == NULL)
CreateKeysPdf();

if (fKeysPdf == NULL)
// if fKeysPdf is still NULL, then it means CreateKeysPdf failed
return NULL;

return (RooNDKeysPdf*) fKeysPdf->Clone("MCMCPosterior_keys");
}

RooProduct* MCMCInterval::GetPosteriorKeysProduct()
{
if (fConfidenceLevel == 0)
coutE(InputArguments) << "MCMCInterval::GetPosteriorKeysProduct: "
<< "confidence level not set " << endl;
if (fProduct == NULL) {
CreateKeysPdf();
DetermineByKeys();
}

if (fProduct == NULL)
// if fProduct is still NULL, then it means CreateKeysPdf failed
return NULL;

return (RooProduct*) fProduct->Clone("MCMCPosterior_keysproduct");
}

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

Bool_t MCMCInterval::AcceptableConfLevel(Double_t confLevel)
{
return (TMath::Abs(confLevel - fConfidenceLevel) < fEpsilon);
}

Bool_t MCMCInterval::WithinDeltaFraction(Double_t a, Double_t b)
{
return (TMath::Abs(a - b) < TMath::Abs(fDelta * (a + b)/2));
}

void MCMCInterval::CreateKeysDataHist()
{
if (fAxes == NULL)
return;
if (fProduct == NULL)
DetermineByKeys();
if (fProduct == NULL)
// if fProduct still NULL, then creation failed
return;

//RooAbsBinning** savedBinning = new RooAbsBinning*[fDimension];
Int_t* savedBins = new Int_t[fDimension];
Int_t i;
Double_t numBins;
RooRealVar* var;

// kbelasco: Note - the accuracy is only increased here if the binning for
// each RooRealVar is uniform

// kbelasco: look into why saving the binnings and replacing them doesn't
// work (replaces with 1 bin always).
// Note: this code modifies the binning for the parameters (if they are
// uniform) and sets them back to what they were.  If the binnings are not
// uniform, this code does nothing.

// first scan through fAxes to make sure all binnings are uniform, or else
// we can't change the number of bins because there seems to be an error
// when setting the binning itself rather than just the number of bins
Bool_t tempChangeBinning = true;
for (i = 0; i < fDimension; i++) {
if (!fAxes[i]->getBinning(NULL, false, false).isUniform()) {
tempChangeBinning = false;
break;
}
}

// kbelasco: for 1 dimension this should be fine, but for more dimensions
// the total nubmer of bins in the histogram increases exponentially with
// the dimension, so don't do this above 1-D for now.
if (fDimension >= 2)
tempChangeBinning = false;

if (tempChangeBinning) {
// set high nubmer of bins for high accuracy on lower/upper limit by keys
for (i = 0; i < fDimension; i++) {
var = fAxes[i];
//savedBinning[i] = &var->getBinning("__binning_clone", false, true);
savedBins[i] = var->getBinning(NULL, false, false).numBins();
numBins = (var->getMax() - var->getMin()) / fEpsilon;
var->setBins((Int_t)numBins);
}
}

fKeysDataHist = new RooDataHist("_productDataHist",
"Keys PDF & Heaviside Product Data Hist", fParameters);
fKeysDataHist = fProduct->fillDataHist(fKeysDataHist, &fParameters, 1.);

if (tempChangeBinning) {
// set the binning back to normal
for (i = 0; i < fDimension; i++)
//fAxes[i]->setBinning(*savedBinning[i], NULL);
//fAxes[i]->setBins(savedBinning[i]->numBins(), NULL);
fAxes[i]->setBins(savedBins[i], NULL);
}

//delete[] savedBinning;
delete[] savedBins;
}

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

if (parameterPoint.getSize() != fParameters.getSize() ) {
coutE(Eval) << "MCMCInterval: size is wrong, parameters don't match" << std::endl;
return kFALSE;
}
if ( ! parameterPoint.equals( fParameters ) ) {
coutE(Eval) << "MCMCInterval: size is ok, but parameters don't match" << std::endl;
return kFALSE;
}
return kTRUE;
}

MCMCInterval.cxx:1
MCMCInterval.cxx:2
MCMCInterval.cxx:3
MCMCInterval.cxx:4
MCMCInterval.cxx:5
MCMCInterval.cxx:6
MCMCInterval.cxx:7
MCMCInterval.cxx:8
MCMCInterval.cxx:9
MCMCInterval.cxx:10
MCMCInterval.cxx:11
MCMCInterval.cxx:12
MCMCInterval.cxx:13
MCMCInterval.cxx:14
MCMCInterval.cxx:15
MCMCInterval.cxx:16
MCMCInterval.cxx:17
MCMCInterval.cxx:18
MCMCInterval.cxx:19
MCMCInterval.cxx:20
MCMCInterval.cxx:21
MCMCInterval.cxx:22
MCMCInterval.cxx:23
MCMCInterval.cxx:24
MCMCInterval.cxx:25
MCMCInterval.cxx:26
MCMCInterval.cxx:27
MCMCInterval.cxx:28
MCMCInterval.cxx:29
MCMCInterval.cxx:30
MCMCInterval.cxx:31
MCMCInterval.cxx:32
MCMCInterval.cxx:33
MCMCInterval.cxx:34
MCMCInterval.cxx:35
MCMCInterval.cxx:36
MCMCInterval.cxx:37
MCMCInterval.cxx:38
MCMCInterval.cxx:39
MCMCInterval.cxx:40
MCMCInterval.cxx:41
MCMCInterval.cxx:42
MCMCInterval.cxx:43
MCMCInterval.cxx:44
MCMCInterval.cxx:45
MCMCInterval.cxx:46
MCMCInterval.cxx:47
MCMCInterval.cxx:48
MCMCInterval.cxx:49
MCMCInterval.cxx:50
MCMCInterval.cxx:51
MCMCInterval.cxx:52
MCMCInterval.cxx:53
MCMCInterval.cxx:54
MCMCInterval.cxx:55
MCMCInterval.cxx:56
MCMCInterval.cxx:57
MCMCInterval.cxx:58
MCMCInterval.cxx:59
MCMCInterval.cxx:60
MCMCInterval.cxx:61
MCMCInterval.cxx:62
MCMCInterval.cxx:63
MCMCInterval.cxx:64
MCMCInterval.cxx:65
MCMCInterval.cxx:66
MCMCInterval.cxx:67
MCMCInterval.cxx:68
MCMCInterval.cxx:69
MCMCInterval.cxx:70
MCMCInterval.cxx:71
MCMCInterval.cxx:72
MCMCInterval.cxx:73
MCMCInterval.cxx:74
MCMCInterval.cxx:75
MCMCInterval.cxx:76
MCMCInterval.cxx:77
MCMCInterval.cxx:78
MCMCInterval.cxx:79
MCMCInterval.cxx:80
MCMCInterval.cxx:81
MCMCInterval.cxx:82
MCMCInterval.cxx:83
MCMCInterval.cxx:84
MCMCInterval.cxx:85
MCMCInterval.cxx:86
MCMCInterval.cxx:87
MCMCInterval.cxx:88
MCMCInterval.cxx:89
MCMCInterval.cxx:90
MCMCInterval.cxx:91
MCMCInterval.cxx:92
MCMCInterval.cxx:93
MCMCInterval.cxx:94
MCMCInterval.cxx:95
MCMCInterval.cxx:96
MCMCInterval.cxx:97
MCMCInterval.cxx:98
MCMCInterval.cxx:99
MCMCInterval.cxx:100
MCMCInterval.cxx:101
MCMCInterval.cxx:102
MCMCInterval.cxx:103
MCMCInterval.cxx:104
MCMCInterval.cxx:105
MCMCInterval.cxx:106
MCMCInterval.cxx:107
MCMCInterval.cxx:108
MCMCInterval.cxx:109
MCMCInterval.cxx:110
MCMCInterval.cxx:111
MCMCInterval.cxx:112
MCMCInterval.cxx:113
MCMCInterval.cxx:114
MCMCInterval.cxx:115
MCMCInterval.cxx:116
MCMCInterval.cxx:117
MCMCInterval.cxx:118
MCMCInterval.cxx:119
MCMCInterval.cxx:120
MCMCInterval.cxx:121
MCMCInterval.cxx:122
MCMCInterval.cxx:123
MCMCInterval.cxx:124
MCMCInterval.cxx:125
MCMCInterval.cxx:126
MCMCInterval.cxx:127
MCMCInterval.cxx:128
MCMCInterval.cxx:129
MCMCInterval.cxx:130
MCMCInterval.cxx:131
MCMCInterval.cxx:132
MCMCInterval.cxx:133
MCMCInterval.cxx:134
MCMCInterval.cxx:135
MCMCInterval.cxx:136
MCMCInterval.cxx:137
MCMCInterval.cxx:138
MCMCInterval.cxx:139
MCMCInterval.cxx:140
MCMCInterval.cxx:141
MCMCInterval.cxx:142
MCMCInterval.cxx:143
MCMCInterval.cxx:144
MCMCInterval.cxx:145
MCMCInterval.cxx:146
MCMCInterval.cxx:147
MCMCInterval.cxx:148
MCMCInterval.cxx:149
MCMCInterval.cxx:150
MCMCInterval.cxx:151
MCMCInterval.cxx:152
MCMCInterval.cxx:153
MCMCInterval.cxx:154
MCMCInterval.cxx:155
MCMCInterval.cxx:156
MCMCInterval.cxx:157
MCMCInterval.cxx:158
MCMCInterval.cxx:159
MCMCInterval.cxx:160
MCMCInterval.cxx:161
MCMCInterval.cxx:162
MCMCInterval.cxx:163
MCMCInterval.cxx:164
MCMCInterval.cxx:165
MCMCInterval.cxx:166
MCMCInterval.cxx:167
MCMCInterval.cxx:168
MCMCInterval.cxx:169
MCMCInterval.cxx:170
MCMCInterval.cxx:171
MCMCInterval.cxx:172
MCMCInterval.cxx:173
MCMCInterval.cxx:174
MCMCInterval.cxx:175
MCMCInterval.cxx:176
MCMCInterval.cxx:177
MCMCInterval.cxx:178
MCMCInterval.cxx:179
MCMCInterval.cxx:180
MCMCInterval.cxx:181
MCMCInterval.cxx:182
MCMCInterval.cxx:183
MCMCInterval.cxx:184
MCMCInterval.cxx:185
MCMCInterval.cxx:186
MCMCInterval.cxx:187
MCMCInterval.cxx:188
MCMCInterval.cxx:189
MCMCInterval.cxx:190
MCMCInterval.cxx:191
MCMCInterval.cxx:192
MCMCInterval.cxx:193
MCMCInterval.cxx:194
MCMCInterval.cxx:195
MCMCInterval.cxx:196
MCMCInterval.cxx:197
MCMCInterval.cxx:198
MCMCInterval.cxx:199
MCMCInterval.cxx:200
MCMCInterval.cxx:201
MCMCInterval.cxx:202
MCMCInterval.cxx:203
MCMCInterval.cxx:204
MCMCInterval.cxx:205
MCMCInterval.cxx:206
MCMCInterval.cxx:207
MCMCInterval.cxx:208
MCMCInterval.cxx:209
MCMCInterval.cxx:210
MCMCInterval.cxx:211
MCMCInterval.cxx:212
MCMCInterval.cxx:213
MCMCInterval.cxx:214
MCMCInterval.cxx:215
MCMCInterval.cxx:216
MCMCInterval.cxx:217
MCMCInterval.cxx:218
MCMCInterval.cxx:219
MCMCInterval.cxx:220
MCMCInterval.cxx:221
MCMCInterval.cxx:222
MCMCInterval.cxx:223
MCMCInterval.cxx:224
MCMCInterval.cxx:225
MCMCInterval.cxx:226
MCMCInterval.cxx:227
MCMCInterval.cxx:228
MCMCInterval.cxx:229
MCMCInterval.cxx:230
MCMCInterval.cxx:231
MCMCInterval.cxx:232
MCMCInterval.cxx:233
MCMCInterval.cxx:234
MCMCInterval.cxx:235
MCMCInterval.cxx:236
MCMCInterval.cxx:237
MCMCInterval.cxx:238
MCMCInterval.cxx:239
MCMCInterval.cxx:240
MCMCInterval.cxx:241
MCMCInterval.cxx:242
MCMCInterval.cxx:243
MCMCInterval.cxx:244
MCMCInterval.cxx:245
MCMCInterval.cxx:246
MCMCInterval.cxx:247
MCMCInterval.cxx:248
MCMCInterval.cxx:249
MCMCInterval.cxx:250
MCMCInterval.cxx:251
MCMCInterval.cxx:252
MCMCInterval.cxx:253
MCMCInterval.cxx:254
MCMCInterval.cxx:255
MCMCInterval.cxx:256
MCMCInterval.cxx:257
MCMCInterval.cxx:258
MCMCInterval.cxx:259
MCMCInterval.cxx:260
MCMCInterval.cxx:261
MCMCInterval.cxx:262
MCMCInterval.cxx:263
MCMCInterval.cxx:264
MCMCInterval.cxx:265
MCMCInterval.cxx:266
MCMCInterval.cxx:267
MCMCInterval.cxx:268
MCMCInterval.cxx:269
MCMCInterval.cxx:270
MCMCInterval.cxx:271
MCMCInterval.cxx:272
MCMCInterval.cxx:273
MCMCInterval.cxx:274
MCMCInterval.cxx:275
MCMCInterval.cxx:276
MCMCInterval.cxx:277
MCMCInterval.cxx:278
MCMCInterval.cxx:279
MCMCInterval.cxx:280
MCMCInterval.cxx:281
MCMCInterval.cxx:282
MCMCInterval.cxx:283
MCMCInterval.cxx:284
MCMCInterval.cxx:285
MCMCInterval.cxx:286
MCMCInterval.cxx:287
MCMCInterval.cxx:288
MCMCInterval.cxx:289
MCMCInterval.cxx:290
MCMCInterval.cxx:291
MCMCInterval.cxx:292
MCMCInterval.cxx:293
MCMCInterval.cxx:294
MCMCInterval.cxx:295
MCMCInterval.cxx:296
MCMCInterval.cxx:297
MCMCInterval.cxx:298
MCMCInterval.cxx:299
MCMCInterval.cxx:300
MCMCInterval.cxx:301
MCMCInterval.cxx:302
MCMCInterval.cxx:303
MCMCInterval.cxx:304
MCMCInterval.cxx:305
MCMCInterval.cxx:306
MCMCInterval.cxx:307
MCMCInterval.cxx:308
MCMCInterval.cxx:309
MCMCInterval.cxx:310
MCMCInterval.cxx:311
MCMCInterval.cxx:312
MCMCInterval.cxx:313
MCMCInterval.cxx:314
MCMCInterval.cxx:315
MCMCInterval.cxx:316
MCMCInterval.cxx:317
MCMCInterval.cxx:318
MCMCInterval.cxx:319
MCMCInterval.cxx:320
MCMCInterval.cxx:321
MCMCInterval.cxx:322
MCMCInterval.cxx:323
MCMCInterval.cxx:324
MCMCInterval.cxx:325
MCMCInterval.cxx:326
MCMCInterval.cxx:327
MCMCInterval.cxx:328
MCMCInterval.cxx:329
MCMCInterval.cxx:330
MCMCInterval.cxx:331
MCMCInterval.cxx:332
MCMCInterval.cxx:333
MCMCInterval.cxx:334
MCMCInterval.cxx:335
MCMCInterval.cxx:336
MCMCInterval.cxx:337
MCMCInterval.cxx:338
MCMCInterval.cxx:339
MCMCInterval.cxx:340
MCMCInterval.cxx:341
MCMCInterval.cxx:342
MCMCInterval.cxx:343
MCMCInterval.cxx:344
MCMCInterval.cxx:345
MCMCInterval.cxx:346
MCMCInterval.cxx:347
MCMCInterval.cxx:348
MCMCInterval.cxx:349
MCMCInterval.cxx:350
MCMCInterval.cxx:351
MCMCInterval.cxx:352
MCMCInterval.cxx:353
MCMCInterval.cxx:354
MCMCInterval.cxx:355
MCMCInterval.cxx:356
MCMCInterval.cxx:357
MCMCInterval.cxx:358
MCMCInterval.cxx:359
MCMCInterval.cxx:360
MCMCInterval.cxx:361
MCMCInterval.cxx:362
MCMCInterval.cxx:363
MCMCInterval.cxx:364
MCMCInterval.cxx:365
MCMCInterval.cxx:366
MCMCInterval.cxx:367
MCMCInterval.cxx:368
MCMCInterval.cxx:369
MCMCInterval.cxx:370
MCMCInterval.cxx:371
MCMCInterval.cxx:372
MCMCInterval.cxx:373
MCMCInterval.cxx:374
MCMCInterval.cxx:375
MCMCInterval.cxx:376
MCMCInterval.cxx:377
MCMCInterval.cxx:378
MCMCInterval.cxx:379
MCMCInterval.cxx:380
MCMCInterval.cxx:381
MCMCInterval.cxx:382
MCMCInterval.cxx:383
MCMCInterval.cxx:384
MCMCInterval.cxx:385
MCMCInterval.cxx:386
MCMCInterval.cxx:387
MCMCInterval.cxx:388
MCMCInterval.cxx:389
MCMCInterval.cxx:390
MCMCInterval.cxx:391
MCMCInterval.cxx:392
MCMCInterval.cxx:393
MCMCInterval.cxx:394
MCMCInterval.cxx:395
MCMCInterval.cxx:396
MCMCInterval.cxx:397
MCMCInterval.cxx:398
MCMCInterval.cxx:399
MCMCInterval.cxx:400
MCMCInterval.cxx:401
MCMCInterval.cxx:402
MCMCInterval.cxx:403
MCMCInterval.cxx:404
MCMCInterval.cxx:405
MCMCInterval.cxx:406
MCMCInterval.cxx:407
MCMCInterval.cxx:408
MCMCInterval.cxx:409
MCMCInterval.cxx:410
MCMCInterval.cxx:411
MCMCInterval.cxx:412
MCMCInterval.cxx:413
MCMCInterval.cxx:414
MCMCInterval.cxx:415
MCMCInterval.cxx:416
MCMCInterval.cxx:417
MCMCInterval.cxx:418
MCMCInterval.cxx:419
MCMCInterval.cxx:420
MCMCInterval.cxx:421
MCMCInterval.cxx:422
MCMCInterval.cxx:423
MCMCInterval.cxx:424
MCMCInterval.cxx:425
MCMCInterval.cxx:426
MCMCInterval.cxx:427
MCMCInterval.cxx:428
MCMCInterval.cxx:429
MCMCInterval.cxx:430
MCMCInterval.cxx:431
MCMCInterval.cxx:432
MCMCInterval.cxx:433
MCMCInterval.cxx:434
MCMCInterval.cxx:435
MCMCInterval.cxx:436
MCMCInterval.cxx:437
MCMCInterval.cxx:438
MCMCInterval.cxx:439
MCMCInterval.cxx:440
MCMCInterval.cxx:441
MCMCInterval.cxx:442
MCMCInterval.cxx:443
MCMCInterval.cxx:444
MCMCInterval.cxx:445
MCMCInterval.cxx:446
MCMCInterval.cxx:447
MCMCInterval.cxx:448
MCMCInterval.cxx:449
MCMCInterval.cxx:450
MCMCInterval.cxx:451
MCMCInterval.cxx:452
MCMCInterval.cxx:453
MCMCInterval.cxx:454
MCMCInterval.cxx:455
MCMCInterval.cxx:456
MCMCInterval.cxx:457
MCMCInterval.cxx:458
MCMCInterval.cxx:459
MCMCInterval.cxx:460
MCMCInterval.cxx:461
MCMCInterval.cxx:462
MCMCInterval.cxx:463
MCMCInterval.cxx:464
MCMCInterval.cxx:465
MCMCInterval.cxx:466
MCMCInterval.cxx:467
MCMCInterval.cxx:468
MCMCInterval.cxx:469
MCMCInterval.cxx:470
MCMCInterval.cxx:471
MCMCInterval.cxx:472
MCMCInterval.cxx:473
MCMCInterval.cxx:474
MCMCInterval.cxx:475
MCMCInterval.cxx:476
MCMCInterval.cxx:477
MCMCInterval.cxx:478
MCMCInterval.cxx:479
MCMCInterval.cxx:480
MCMCInterval.cxx:481
MCMCInterval.cxx:482
MCMCInterval.cxx:483
MCMCInterval.cxx:484
MCMCInterval.cxx:485
MCMCInterval.cxx:486
MCMCInterval.cxx:487
MCMCInterval.cxx:488
MCMCInterval.cxx:489
MCMCInterval.cxx:490
MCMCInterval.cxx:491
MCMCInterval.cxx:492
MCMCInterval.cxx:493
MCMCInterval.cxx:494
MCMCInterval.cxx:495
MCMCInterval.cxx:496
MCMCInterval.cxx:497
MCMCInterval.cxx:498
MCMCInterval.cxx:499
MCMCInterval.cxx:500
MCMCInterval.cxx:501
MCMCInterval.cxx:502
MCMCInterval.cxx:503
MCMCInterval.cxx:504
MCMCInterval.cxx:505
MCMCInterval.cxx:506
MCMCInterval.cxx:507
MCMCInterval.cxx:508
MCMCInterval.cxx:509
MCMCInterval.cxx:510
MCMCInterval.cxx:511
MCMCInterval.cxx:512
MCMCInterval.cxx:513
MCMCInterval.cxx:514
MCMCInterval.cxx:515
MCMCInterval.cxx:516
MCMCInterval.cxx:517
MCMCInterval.cxx:518
MCMCInterval.cxx:519
MCMCInterval.cxx:520
MCMCInterval.cxx:521
MCMCInterval.cxx:522
MCMCInterval.cxx:523
MCMCInterval.cxx:524
MCMCInterval.cxx:525
MCMCInterval.cxx:526
MCMCInterval.cxx:527
MCMCInterval.cxx:528
MCMCInterval.cxx:529
MCMCInterval.cxx:530
MCMCInterval.cxx:531
MCMCInterval.cxx:532
MCMCInterval.cxx:533
MCMCInterval.cxx:534
MCMCInterval.cxx:535
MCMCInterval.cxx:536
MCMCInterval.cxx:537
MCMCInterval.cxx:538
MCMCInterval.cxx:539
MCMCInterval.cxx:540
MCMCInterval.cxx:541
MCMCInterval.cxx:542
MCMCInterval.cxx:543
MCMCInterval.cxx:544
MCMCInterval.cxx:545
MCMCInterval.cxx:546
MCMCInterval.cxx:547
MCMCInterval.cxx:548
MCMCInterval.cxx:549
MCMCInterval.cxx:550
MCMCInterval.cxx:551
MCMCInterval.cxx:552
MCMCInterval.cxx:553
MCMCInterval.cxx:554
MCMCInterval.cxx:555
MCMCInterval.cxx:556
MCMCInterval.cxx:557
MCMCInterval.cxx:558
MCMCInterval.cxx:559
MCMCInterval.cxx:560
MCMCInterval.cxx:561
MCMCInterval.cxx:562
MCMCInterval.cxx:563
MCMCInterval.cxx:564
MCMCInterval.cxx:565
MCMCInterval.cxx:566
MCMCInterval.cxx:567
MCMCInterval.cxx:568
MCMCInterval.cxx:569
MCMCInterval.cxx:570
MCMCInterval.cxx:571
MCMCInterval.cxx:572
MCMCInterval.cxx:573
MCMCInterval.cxx:574
MCMCInterval.cxx:575
MCMCInterval.cxx:576
MCMCInterval.cxx:577
MCMCInterval.cxx:578
MCMCInterval.cxx:579
MCMCInterval.cxx:580
MCMCInterval.cxx:581
MCMCInterval.cxx:582
MCMCInterval.cxx:583
MCMCInterval.cxx:584
MCMCInterval.cxx:585
MCMCInterval.cxx:586
MCMCInterval.cxx:587
MCMCInterval.cxx:588
MCMCInterval.cxx:589
MCMCInterval.cxx:590
MCMCInterval.cxx:591
MCMCInterval.cxx:592
MCMCInterval.cxx:593
MCMCInterval.cxx:594
MCMCInterval.cxx:595
MCMCInterval.cxx:596
MCMCInterval.cxx:597
MCMCInterval.cxx:598
MCMCInterval.cxx:599
MCMCInterval.cxx:600
MCMCInterval.cxx:601
MCMCInterval.cxx:602
MCMCInterval.cxx:603
MCMCInterval.cxx:604
MCMCInterval.cxx:605
MCMCInterval.cxx:606
MCMCInterval.cxx:607
MCMCInterval.cxx:608
MCMCInterval.cxx:609
MCMCInterval.cxx:610
MCMCInterval.cxx:611
MCMCInterval.cxx:612
MCMCInterval.cxx:613
MCMCInterval.cxx:614
MCMCInterval.cxx:615
MCMCInterval.cxx:616
MCMCInterval.cxx:617
MCMCInterval.cxx:618
MCMCInterval.cxx:619
MCMCInterval.cxx:620
MCMCInterval.cxx:621
MCMCInterval.cxx:622
MCMCInterval.cxx:623
MCMCInterval.cxx:624
MCMCInterval.cxx:625
MCMCInterval.cxx:626
MCMCInterval.cxx:627
MCMCInterval.cxx:628
MCMCInterval.cxx:629
MCMCInterval.cxx:630
MCMCInterval.cxx:631
MCMCInterval.cxx:632
MCMCInterval.cxx:633
MCMCInterval.cxx:634
MCMCInterval.cxx:635
MCMCInterval.cxx:636
MCMCInterval.cxx:637
MCMCInterval.cxx:638
MCMCInterval.cxx:639
MCMCInterval.cxx:640
MCMCInterval.cxx:641
MCMCInterval.cxx:642
MCMCInterval.cxx:643
MCMCInterval.cxx:644
MCMCInterval.cxx:645
MCMCInterval.cxx:646
MCMCInterval.cxx:647
MCMCInterval.cxx:648
MCMCInterval.cxx:649
MCMCInterval.cxx:650
MCMCInterval.cxx:651
MCMCInterval.cxx:652
MCMCInterval.cxx:653
MCMCInterval.cxx:654
MCMCInterval.cxx:655
MCMCInterval.cxx:656
MCMCInterval.cxx:657
MCMCInterval.cxx:658
MCMCInterval.cxx:659
MCMCInterval.cxx:660
MCMCInterval.cxx:661
MCMCInterval.cxx:662
MCMCInterval.cxx:663
MCMCInterval.cxx:664
MCMCInterval.cxx:665
MCMCInterval.cxx:666
MCMCInterval.cxx:667
MCMCInterval.cxx:668
MCMCInterval.cxx:669
MCMCInterval.cxx:670
MCMCInterval.cxx:671
MCMCInterval.cxx:672
MCMCInterval.cxx:673
MCMCInterval.cxx:674
MCMCInterval.cxx:675
MCMCInterval.cxx:676
MCMCInterval.cxx:677
MCMCInterval.cxx:678
MCMCInterval.cxx:679
MCMCInterval.cxx:680
MCMCInterval.cxx:681
MCMCInterval.cxx:682
MCMCInterval.cxx:683
MCMCInterval.cxx:684
MCMCInterval.cxx:685
MCMCInterval.cxx:686
MCMCInterval.cxx:687
MCMCInterval.cxx:688
MCMCInterval.cxx:689
MCMCInterval.cxx:690
MCMCInterval.cxx:691
MCMCInterval.cxx:692
MCMCInterval.cxx:693
MCMCInterval.cxx:694
MCMCInterval.cxx:695
MCMCInterval.cxx:696
MCMCInterval.cxx:697
MCMCInterval.cxx:698
MCMCInterval.cxx:699
MCMCInterval.cxx:700
MCMCInterval.cxx:701
MCMCInterval.cxx:702
MCMCInterval.cxx:703
MCMCInterval.cxx:704
MCMCInterval.cxx:705
MCMCInterval.cxx:706
MCMCInterval.cxx:707
MCMCInterval.cxx:708
MCMCInterval.cxx:709
MCMCInterval.cxx:710
MCMCInterval.cxx:711
MCMCInterval.cxx:712
MCMCInterval.cxx:713
MCMCInterval.cxx:714
MCMCInterval.cxx:715
MCMCInterval.cxx:716
MCMCInterval.cxx:717
MCMCInterval.cxx:718
MCMCInterval.cxx:719
MCMCInterval.cxx:720
MCMCInterval.cxx:721
MCMCInterval.cxx:722
MCMCInterval.cxx:723
MCMCInterval.cxx:724
MCMCInterval.cxx:725
MCMCInterval.cxx:726
MCMCInterval.cxx:727
MCMCInterval.cxx:728
MCMCInterval.cxx:729
MCMCInterval.cxx:730
MCMCInterval.cxx:731
MCMCInterval.cxx:732
MCMCInterval.cxx:733
MCMCInterval.cxx:734
MCMCInterval.cxx:735
MCMCInterval.cxx:736
MCMCInterval.cxx:737
MCMCInterval.cxx:738
MCMCInterval.cxx:739
MCMCInterval.cxx:740
MCMCInterval.cxx:741
MCMCInterval.cxx:742
MCMCInterval.cxx:743
MCMCInterval.cxx:744
MCMCInterval.cxx:745
MCMCInterval.cxx:746
MCMCInterval.cxx:747
MCMCInterval.cxx:748
MCMCInterval.cxx:749
MCMCInterval.cxx:750
MCMCInterval.cxx:751
MCMCInterval.cxx:752
MCMCInterval.cxx:753
MCMCInterval.cxx:754
MCMCInterval.cxx:755
MCMCInterval.cxx:756
MCMCInterval.cxx:757
MCMCInterval.cxx:758
MCMCInterval.cxx:759
MCMCInterval.cxx:760
MCMCInterval.cxx:761
MCMCInterval.cxx:762
MCMCInterval.cxx:763
MCMCInterval.cxx:764
MCMCInterval.cxx:765
MCMCInterval.cxx:766
MCMCInterval.cxx:767
MCMCInterval.cxx:768
MCMCInterval.cxx:769
MCMCInterval.cxx:770
MCMCInterval.cxx:771
MCMCInterval.cxx:772
MCMCInterval.cxx:773
MCMCInterval.cxx:774
MCMCInterval.cxx:775
MCMCInterval.cxx:776
MCMCInterval.cxx:777
MCMCInterval.cxx:778
MCMCInterval.cxx:779
MCMCInterval.cxx:780
MCMCInterval.cxx:781
MCMCInterval.cxx:782
MCMCInterval.cxx:783
MCMCInterval.cxx:784
MCMCInterval.cxx:785
MCMCInterval.cxx:786
MCMCInterval.cxx:787
MCMCInterval.cxx:788
MCMCInterval.cxx:789
MCMCInterval.cxx:790
MCMCInterval.cxx:791
MCMCInterval.cxx:792
MCMCInterval.cxx:793
MCMCInterval.cxx:794
MCMCInterval.cxx:795
MCMCInterval.cxx:796
MCMCInterval.cxx:797
MCMCInterval.cxx:798
MCMCInterval.cxx:799
MCMCInterval.cxx:800
MCMCInterval.cxx:801
MCMCInterval.cxx:802
MCMCInterval.cxx:803
MCMCInterval.cxx:804
MCMCInterval.cxx:805
MCMCInterval.cxx:806
MCMCInterval.cxx:807
MCMCInterval.cxx:808
MCMCInterval.cxx:809
MCMCInterval.cxx:810
MCMCInterval.cxx:811
MCMCInterval.cxx:812
MCMCInterval.cxx:813
MCMCInterval.cxx:814
MCMCInterval.cxx:815
MCMCInterval.cxx:816
MCMCInterval.cxx:817
MCMCInterval.cxx:818
MCMCInterval.cxx:819
MCMCInterval.cxx:820
MCMCInterval.cxx:821
MCMCInterval.cxx:822
MCMCInterval.cxx:823
MCMCInterval.cxx:824
MCMCInterval.cxx:825
MCMCInterval.cxx:826
MCMCInterval.cxx:827
MCMCInterval.cxx:828
MCMCInterval.cxx:829
MCMCInterval.cxx:830
MCMCInterval.cxx:831
MCMCInterval.cxx:832
MCMCInterval.cxx:833
MCMCInterval.cxx:834
MCMCInterval.cxx:835
MCMCInterval.cxx:836
MCMCInterval.cxx:837
MCMCInterval.cxx:838
MCMCInterval.cxx:839
MCMCInterval.cxx:840
MCMCInterval.cxx:841
MCMCInterval.cxx:842
MCMCInterval.cxx:843
MCMCInterval.cxx:844
MCMCInterval.cxx:845
MCMCInterval.cxx:846
MCMCInterval.cxx:847
MCMCInterval.cxx:848
MCMCInterval.cxx:849
MCMCInterval.cxx:850
MCMCInterval.cxx:851
MCMCInterval.cxx:852
MCMCInterval.cxx:853
MCMCInterval.cxx:854
MCMCInterval.cxx:855
MCMCInterval.cxx:856
MCMCInterval.cxx:857
MCMCInterval.cxx:858
MCMCInterval.cxx:859
MCMCInterval.cxx:860
MCMCInterval.cxx:861
MCMCInterval.cxx:862
MCMCInterval.cxx:863
MCMCInterval.cxx:864
MCMCInterval.cxx:865
MCMCInterval.cxx:866
MCMCInterval.cxx:867
MCMCInterval.cxx:868
MCMCInterval.cxx:869
MCMCInterval.cxx:870
MCMCInterval.cxx:871
MCMCInterval.cxx:872
MCMCInterval.cxx:873
MCMCInterval.cxx:874
MCMCInterval.cxx:875
MCMCInterval.cxx:876
MCMCInterval.cxx:877
MCMCInterval.cxx:878
MCMCInterval.cxx:879
MCMCInterval.cxx:880
MCMCInterval.cxx:881
MCMCInterval.cxx:882
MCMCInterval.cxx:883
MCMCInterval.cxx:884
MCMCInterval.cxx:885
MCMCInterval.cxx:886
MCMCInterval.cxx:887
MCMCInterval.cxx:888
MCMCInterval.cxx:889
MCMCInterval.cxx:890
MCMCInterval.cxx:891
MCMCInterval.cxx:892
MCMCInterval.cxx:893
MCMCInterval.cxx:894
MCMCInterval.cxx:895
MCMCInterval.cxx:896
MCMCInterval.cxx:897
MCMCInterval.cxx:898
MCMCInterval.cxx:899
MCMCInterval.cxx:900
MCMCInterval.cxx:901
MCMCInterval.cxx:902
MCMCInterval.cxx:903
MCMCInterval.cxx:904
MCMCInterval.cxx:905
MCMCInterval.cxx:906
MCMCInterval.cxx:907
MCMCInterval.cxx:908
MCMCInterval.cxx:909
MCMCInterval.cxx:910
MCMCInterval.cxx:911
MCMCInterval.cxx:912
MCMCInterval.cxx:913
MCMCInterval.cxx:914
MCMCInterval.cxx:915
MCMCInterval.cxx:916
MCMCInterval.cxx:917
MCMCInterval.cxx:918
MCMCInterval.cxx:919
MCMCInterval.cxx:920
MCMCInterval.cxx:921
MCMCInterval.cxx:922
MCMCInterval.cxx:923
MCMCInterval.cxx:924
MCMCInterval.cxx:925
MCMCInterval.cxx:926
MCMCInterval.cxx:927
MCMCInterval.cxx:928
MCMCInterval.cxx:929
MCMCInterval.cxx:930
MCMCInterval.cxx:931
MCMCInterval.cxx:932
MCMCInterval.cxx:933
MCMCInterval.cxx:934
MCMCInterval.cxx:935
MCMCInterval.cxx:936
MCMCInterval.cxx:937
MCMCInterval.cxx:938
MCMCInterval.cxx:939
MCMCInterval.cxx:940
MCMCInterval.cxx:941
MCMCInterval.cxx:942
MCMCInterval.cxx:943
MCMCInterval.cxx:944
MCMCInterval.cxx:945
MCMCInterval.cxx:946
MCMCInterval.cxx:947
MCMCInterval.cxx:948
MCMCInterval.cxx:949
MCMCInterval.cxx:950
MCMCInterval.cxx:951
MCMCInterval.cxx:952
MCMCInterval.cxx:953
MCMCInterval.cxx:954
MCMCInterval.cxx:955
MCMCInterval.cxx:956
MCMCInterval.cxx:957
MCMCInterval.cxx:958
MCMCInterval.cxx:959
MCMCInterval.cxx:960
MCMCInterval.cxx:961
MCMCInterval.cxx:962
MCMCInterval.cxx:963
MCMCInterval.cxx:964
MCMCInterval.cxx:965
MCMCInterval.cxx:966
MCMCInterval.cxx:967
MCMCInterval.cxx:968
MCMCInterval.cxx:969
MCMCInterval.cxx:970
MCMCInterval.cxx:971
MCMCInterval.cxx:972
MCMCInterval.cxx:973
MCMCInterval.cxx:974
MCMCInterval.cxx:975
MCMCInterval.cxx:976
MCMCInterval.cxx:977
MCMCInterval.cxx:978
MCMCInterval.cxx:979
MCMCInterval.cxx:980
MCMCInterval.cxx:981
MCMCInterval.cxx:982
MCMCInterval.cxx:983
MCMCInterval.cxx:984
MCMCInterval.cxx:985
MCMCInterval.cxx:986
MCMCInterval.cxx:987
MCMCInterval.cxx:988
MCMCInterval.cxx:989
MCMCInterval.cxx:990
MCMCInterval.cxx:991
MCMCInterval.cxx:992
MCMCInterval.cxx:993
MCMCInterval.cxx:994
MCMCInterval.cxx:995
MCMCInterval.cxx:996
MCMCInterval.cxx:997
MCMCInterval.cxx:998
MCMCInterval.cxx:999
MCMCInterval.cxx:1000
MCMCInterval.cxx:1001
MCMCInterval.cxx:1002
MCMCInterval.cxx:1003
MCMCInterval.cxx:1004
MCMCInterval.cxx:1005
MCMCInterval.cxx:1006
MCMCInterval.cxx:1007
MCMCInterval.cxx:1008
MCMCInterval.cxx:1009
MCMCInterval.cxx:1010
MCMCInterval.cxx:1011
MCMCInterval.cxx:1012
MCMCInterval.cxx:1013
MCMCInterval.cxx:1014
MCMCInterval.cxx:1015
MCMCInterval.cxx:1016
MCMCInterval.cxx:1017
MCMCInterval.cxx:1018
MCMCInterval.cxx:1019
MCMCInterval.cxx:1020
MCMCInterval.cxx:1021
MCMCInterval.cxx:1022
MCMCInterval.cxx:1023
MCMCInterval.cxx:1024
MCMCInterval.cxx:1025
MCMCInterval.cxx:1026
MCMCInterval.cxx:1027
MCMCInterval.cxx:1028
MCMCInterval.cxx:1029
MCMCInterval.cxx:1030
MCMCInterval.cxx:1031
MCMCInterval.cxx:1032
MCMCInterval.cxx:1033
MCMCInterval.cxx:1034
MCMCInterval.cxx:1035
MCMCInterval.cxx:1036
MCMCInterval.cxx:1037
MCMCInterval.cxx:1038
MCMCInterval.cxx:1039
MCMCInterval.cxx:1040
MCMCInterval.cxx:1041
MCMCInterval.cxx:1042
MCMCInterval.cxx:1043
MCMCInterval.cxx:1044
MCMCInterval.cxx:1045
MCMCInterval.cxx:1046
MCMCInterval.cxx:1047
MCMCInterval.cxx:1048
MCMCInterval.cxx:1049
MCMCInterval.cxx:1050
MCMCInterval.cxx:1051
MCMCInterval.cxx:1052
MCMCInterval.cxx:1053
MCMCInterval.cxx:1054
MCMCInterval.cxx:1055
MCMCInterval.cxx:1056
MCMCInterval.cxx:1057
MCMCInterval.cxx:1058
MCMCInterval.cxx:1059
MCMCInterval.cxx:1060
MCMCInterval.cxx:1061
MCMCInterval.cxx:1062
MCMCInterval.cxx:1063
MCMCInterval.cxx:1064
MCMCInterval.cxx:1065
MCMCInterval.cxx:1066
MCMCInterval.cxx:1067
MCMCInterval.cxx:1068
MCMCInterval.cxx:1069
MCMCInterval.cxx:1070
MCMCInterval.cxx:1071
MCMCInterval.cxx:1072
MCMCInterval.cxx:1073
MCMCInterval.cxx:1074
MCMCInterval.cxx:1075
MCMCInterval.cxx:1076
MCMCInterval.cxx:1077
MCMCInterval.cxx:1078
MCMCInterval.cxx:1079
MCMCInterval.cxx:1080
MCMCInterval.cxx:1081
MCMCInterval.cxx:1082
MCMCInterval.cxx:1083
MCMCInterval.cxx:1084
MCMCInterval.cxx:1085
MCMCInterval.cxx:1086
MCMCInterval.cxx:1087
MCMCInterval.cxx:1088
MCMCInterval.cxx:1089
MCMCInterval.cxx:1090
MCMCInterval.cxx:1091
MCMCInterval.cxx:1092
MCMCInterval.cxx:1093
MCMCInterval.cxx:1094
MCMCInterval.cxx:1095
MCMCInterval.cxx:1096
MCMCInterval.cxx:1097
MCMCInterval.cxx:1098
MCMCInterval.cxx:1099
MCMCInterval.cxx:1100
MCMCInterval.cxx:1101
MCMCInterval.cxx:1102
MCMCInterval.cxx:1103
MCMCInterval.cxx:1104
MCMCInterval.cxx:1105
MCMCInterval.cxx:1106
MCMCInterval.cxx:1107
MCMCInterval.cxx:1108
MCMCInterval.cxx:1109
MCMCInterval.cxx:1110
MCMCInterval.cxx:1111
MCMCInterval.cxx:1112
MCMCInterval.cxx:1113
MCMCInterval.cxx:1114
MCMCInterval.cxx:1115
MCMCInterval.cxx:1116
MCMCInterval.cxx:1117
MCMCInterval.cxx:1118
MCMCInterval.cxx:1119
MCMCInterval.cxx:1120
MCMCInterval.cxx:1121
MCMCInterval.cxx:1122
MCMCInterval.cxx:1123
MCMCInterval.cxx:1124
MCMCInterval.cxx:1125
MCMCInterval.cxx:1126
MCMCInterval.cxx:1127
MCMCInterval.cxx:1128
MCMCInterval.cxx:1129
MCMCInterval.cxx:1130
MCMCInterval.cxx:1131
MCMCInterval.cxx:1132
MCMCInterval.cxx:1133
MCMCInterval.cxx:1134
MCMCInterval.cxx:1135
MCMCInterval.cxx:1136
MCMCInterval.cxx:1137
MCMCInterval.cxx:1138
MCMCInterval.cxx:1139
MCMCInterval.cxx:1140
MCMCInterval.cxx:1141
MCMCInterval.cxx:1142
MCMCInterval.cxx:1143
MCMCInterval.cxx:1144
MCMCInterval.cxx:1145
MCMCInterval.cxx:1146
MCMCInterval.cxx:1147
MCMCInterval.cxx:1148
MCMCInterval.cxx:1149
MCMCInterval.cxx:1150
MCMCInterval.cxx:1151
MCMCInterval.cxx:1152
MCMCInterval.cxx:1153
MCMCInterval.cxx:1154
MCMCInterval.cxx:1155
MCMCInterval.cxx:1156
MCMCInterval.cxx:1157
MCMCInterval.cxx:1158
MCMCInterval.cxx:1159
MCMCInterval.cxx:1160
MCMCInterval.cxx:1161
MCMCInterval.cxx:1162
MCMCInterval.cxx:1163
MCMCInterval.cxx:1164
MCMCInterval.cxx:1165
MCMCInterval.cxx:1166
MCMCInterval.cxx:1167
MCMCInterval.cxx:1168
MCMCInterval.cxx:1169
MCMCInterval.cxx:1170
MCMCInterval.cxx:1171
MCMCInterval.cxx:1172
MCMCInterval.cxx:1173
MCMCInterval.cxx:1174
MCMCInterval.cxx:1175
MCMCInterval.cxx:1176
MCMCInterval.cxx:1177
MCMCInterval.cxx:1178
MCMCInterval.cxx:1179
MCMCInterval.cxx:1180
MCMCInterval.cxx:1181
MCMCInterval.cxx:1182
MCMCInterval.cxx:1183
MCMCInterval.cxx:1184
MCMCInterval.cxx:1185
MCMCInterval.cxx:1186
MCMCInterval.cxx:1187
MCMCInterval.cxx:1188
MCMCInterval.cxx:1189
MCMCInterval.cxx:1190
MCMCInterval.cxx:1191
MCMCInterval.cxx:1192
MCMCInterval.cxx:1193
MCMCInterval.cxx:1194
MCMCInterval.cxx:1195
MCMCInterval.cxx:1196
MCMCInterval.cxx:1197
MCMCInterval.cxx:1198
MCMCInterval.cxx:1199
MCMCInterval.cxx:1200
MCMCInterval.cxx:1201
MCMCInterval.cxx:1202
MCMCInterval.cxx:1203
MCMCInterval.cxx:1204
MCMCInterval.cxx:1205
MCMCInterval.cxx:1206
MCMCInterval.cxx:1207
MCMCInterval.cxx:1208
MCMCInterval.cxx:1209
MCMCInterval.cxx:1210
MCMCInterval.cxx:1211
MCMCInterval.cxx:1212
MCMCInterval.cxx:1213
MCMCInterval.cxx:1214
MCMCInterval.cxx:1215
MCMCInterval.cxx:1216
MCMCInterval.cxx:1217
MCMCInterval.cxx:1218
MCMCInterval.cxx:1219
MCMCInterval.cxx:1220
MCMCInterval.cxx:1221
MCMCInterval.cxx:1222
MCMCInterval.cxx:1223
MCMCInterval.cxx:1224
MCMCInterval.cxx:1225
MCMCInterval.cxx:1226
MCMCInterval.cxx:1227
MCMCInterval.cxx:1228
MCMCInterval.cxx:1229
MCMCInterval.cxx:1230
MCMCInterval.cxx:1231
MCMCInterval.cxx:1232
MCMCInterval.cxx:1233
MCMCInterval.cxx:1234
MCMCInterval.cxx:1235
MCMCInterval.cxx:1236
MCMCInterval.cxx:1237
MCMCInterval.cxx:1238
MCMCInterval.cxx:1239
MCMCInterval.cxx:1240
MCMCInterval.cxx:1241
MCMCInterval.cxx:1242
MCMCInterval.cxx:1243
MCMCInterval.cxx:1244
MCMCInterval.cxx:1245
MCMCInterval.cxx:1246
MCMCInterval.cxx:1247
MCMCInterval.cxx:1248
MCMCInterval.cxx:1249
MCMCInterval.cxx:1250
MCMCInterval.cxx:1251
MCMCInterval.cxx:1252
MCMCInterval.cxx:1253
MCMCInterval.cxx:1254
MCMCInterval.cxx:1255
MCMCInterval.cxx:1256
MCMCInterval.cxx:1257
MCMCInterval.cxx:1258
MCMCInterval.cxx:1259
MCMCInterval.cxx:1260
MCMCInterval.cxx:1261
MCMCInterval.cxx:1262
MCMCInterval.cxx:1263
MCMCInterval.cxx:1264
MCMCInterval.cxx:1265
MCMCInterval.cxx:1266
MCMCInterval.cxx:1267
MCMCInterval.cxx:1268
MCMCInterval.cxx:1269
MCMCInterval.cxx:1270
MCMCInterval.cxx:1271
MCMCInterval.cxx:1272
MCMCInterval.cxx:1273
MCMCInterval.cxx:1274
MCMCInterval.cxx:1275
MCMCInterval.cxx:1276
MCMCInterval.cxx:1277
MCMCInterval.cxx:1278
MCMCInterval.cxx:1279
MCMCInterval.cxx:1280
MCMCInterval.cxx:1281
MCMCInterval.cxx:1282
MCMCInterval.cxx:1283
MCMCInterval.cxx:1284
MCMCInterval.cxx:1285
MCMCInterval.cxx:1286
MCMCInterval.cxx:1287
MCMCInterval.cxx:1288
MCMCInterval.cxx:1289
MCMCInterval.cxx:1290
MCMCInterval.cxx:1291
MCMCInterval.cxx:1292
MCMCInterval.cxx:1293
MCMCInterval.cxx:1294
MCMCInterval.cxx:1295
MCMCInterval.cxx:1296
MCMCInterval.cxx:1297
MCMCInterval.cxx:1298
MCMCInterval.cxx:1299
MCMCInterval.cxx:1300
MCMCInterval.cxx:1301
MCMCInterval.cxx:1302
MCMCInterval.cxx:1303
MCMCInterval.cxx:1304
MCMCInterval.cxx:1305
MCMCInterval.cxx:1306
MCMCInterval.cxx:1307
MCMCInterval.cxx:1308
MCMCInterval.cxx:1309
MCMCInterval.cxx:1310
MCMCInterval.cxx:1311
MCMCInterval.cxx:1312
MCMCInterval.cxx:1313
MCMCInterval.cxx:1314
MCMCInterval.cxx:1315
MCMCInterval.cxx:1316
MCMCInterval.cxx:1317
MCMCInterval.cxx:1318
MCMCInterval.cxx:1319
MCMCInterval.cxx:1320
MCMCInterval.cxx:1321
MCMCInterval.cxx:1322
MCMCInterval.cxx:1323
MCMCInterval.cxx:1324
MCMCInterval.cxx:1325
MCMCInterval.cxx:1326
MCMCInterval.cxx:1327
MCMCInterval.cxx:1328
MCMCInterval.cxx:1329
MCMCInterval.cxx:1330
MCMCInterval.cxx:1331
MCMCInterval.cxx:1332
MCMCInterval.cxx:1333
MCMCInterval.cxx:1334
MCMCInterval.cxx:1335
MCMCInterval.cxx:1336
MCMCInterval.cxx:1337
MCMCInterval.cxx:1338
MCMCInterval.cxx:1339
MCMCInterval.cxx:1340
MCMCInterval.cxx:1341
MCMCInterval.cxx:1342
MCMCInterval.cxx:1343
MCMCInterval.cxx:1344
MCMCInterval.cxx:1345
MCMCInterval.cxx:1346
MCMCInterval.cxx:1347
MCMCInterval.cxx:1348
MCMCInterval.cxx:1349
MCMCInterval.cxx:1350
MCMCInterval.cxx:1351
MCMCInterval.cxx:1352
MCMCInterval.cxx:1353
MCMCInterval.cxx:1354
MCMCInterval.cxx:1355
MCMCInterval.cxx:1356
MCMCInterval.cxx:1357
MCMCInterval.cxx:1358
MCMCInterval.cxx:1359
MCMCInterval.cxx:1360
MCMCInterval.cxx:1361
MCMCInterval.cxx:1362
MCMCInterval.cxx:1363
MCMCInterval.cxx:1364
MCMCInterval.cxx:1365
MCMCInterval.cxx:1366
MCMCInterval.cxx:1367
MCMCInterval.cxx:1368
MCMCInterval.cxx:1369
MCMCInterval.cxx:1370
MCMCInterval.cxx:1371
MCMCInterval.cxx:1372
MCMCInterval.cxx:1373
MCMCInterval.cxx:1374
MCMCInterval.cxx:1375
MCMCInterval.cxx:1376
MCMCInterval.cxx:1377
MCMCInterval.cxx:1378
MCMCInterval.cxx:1379
MCMCInterval.cxx:1380
MCMCInterval.cxx:1381
MCMCInterval.cxx:1382
MCMCInterval.cxx:1383
MCMCInterval.cxx:1384
MCMCInterval.cxx:1385
MCMCInterval.cxx:1386
MCMCInterval.cxx:1387
MCMCInterval.cxx:1388
MCMCInterval.cxx:1389
MCMCInterval.cxx:1390
MCMCInterval.cxx:1391
MCMCInterval.cxx:1392
MCMCInterval.cxx:1393
MCMCInterval.cxx:1394
MCMCInterval.cxx:1395
MCMCInterval.cxx:1396
MCMCInterval.cxx:1397
MCMCInterval.cxx:1398
MCMCInterval.cxx:1399
MCMCInterval.cxx:1400
MCMCInterval.cxx:1401
MCMCInterval.cxx:1402
MCMCInterval.cxx:1403
MCMCInterval.cxx:1404
MCMCInterval.cxx:1405
MCMCInterval.cxx:1406
MCMCInterval.cxx:1407
MCMCInterval.cxx:1408
MCMCInterval.cxx:1409
MCMCInterval.cxx:1410
MCMCInterval.cxx:1411
MCMCInterval.cxx:1412
MCMCInterval.cxx:1413
MCMCInterval.cxx:1414
MCMCInterval.cxx:1415
MCMCInterval.cxx:1416
MCMCInterval.cxx:1417
MCMCInterval.cxx:1418
MCMCInterval.cxx:1419
MCMCInterval.cxx:1420
MCMCInterval.cxx:1421
MCMCInterval.cxx:1422
MCMCInterval.cxx:1423
MCMCInterval.cxx:1424
MCMCInterval.cxx:1425
MCMCInterval.cxx:1426
MCMCInterval.cxx:1427
MCMCInterval.cxx:1428
MCMCInterval.cxx:1429
MCMCInterval.cxx:1430
MCMCInterval.cxx:1431
MCMCInterval.cxx:1432
MCMCInterval.cxx:1433
MCMCInterval.cxx:1434
MCMCInterval.cxx:1435
MCMCInterval.cxx:1436
MCMCInterval.cxx:1437
MCMCInterval.cxx:1438
MCMCInterval.cxx:1439
MCMCInterval.cxx:1440
MCMCInterval.cxx:1441
MCMCInterval.cxx:1442
MCMCInterval.cxx:1443
MCMCInterval.cxx:1444
MCMCInterval.cxx:1445
MCMCInterval.cxx:1446
MCMCInterval.cxx:1447
MCMCInterval.cxx:1448
MCMCInterval.cxx:1449
MCMCInterval.cxx:1450
MCMCInterval.cxx:1451
MCMCInterval.cxx:1452
MCMCInterval.cxx:1453
MCMCInterval.cxx:1454
MCMCInterval.cxx:1455
MCMCInterval.cxx:1456
MCMCInterval.cxx:1457
MCMCInterval.cxx:1458
MCMCInterval.cxx:1459
MCMCInterval.cxx:1460
MCMCInterval.cxx:1461
MCMCInterval.cxx:1462
MCMCInterval.cxx:1463
MCMCInterval.cxx:1464
MCMCInterval.cxx:1465
MCMCInterval.cxx:1466
MCMCInterval.cxx:1467
MCMCInterval.cxx:1468
MCMCInterval.cxx:1469
MCMCInterval.cxx:1470
MCMCInterval.cxx:1471
MCMCInterval.cxx:1472
MCMCInterval.cxx:1473
MCMCInterval.cxx:1474
MCMCInterval.cxx:1475
MCMCInterval.cxx:1476
MCMCInterval.cxx:1477
MCMCInterval.cxx:1478
MCMCInterval.cxx:1479
MCMCInterval.cxx:1480
MCMCInterval.cxx:1481
MCMCInterval.cxx:1482
MCMCInterval.cxx:1483
MCMCInterval.cxx:1484
MCMCInterval.cxx:1485
MCMCInterval.cxx:1486
MCMCInterval.cxx:1487
MCMCInterval.cxx:1488
MCMCInterval.cxx:1489
MCMCInterval.cxx:1490
MCMCInterval.cxx:1491
MCMCInterval.cxx:1492
MCMCInterval.cxx:1493
MCMCInterval.cxx:1494
MCMCInterval.cxx:1495
MCMCInterval.cxx:1496
MCMCInterval.cxx:1497
MCMCInterval.cxx:1498
MCMCInterval.cxx:1499
MCMCInterval.cxx:1500
MCMCInterval.cxx:1501
MCMCInterval.cxx:1502
MCMCInterval.cxx:1503
MCMCInterval.cxx:1504
MCMCInterval.cxx:1505
MCMCInterval.cxx:1506
MCMCInterval.cxx:1507
MCMCInterval.cxx:1508
MCMCInterval.cxx:1509
MCMCInterval.cxx:1510
MCMCInterval.cxx:1511
MCMCInterval.cxx:1512
MCMCInterval.cxx:1513
MCMCInterval.cxx:1514
MCMCInterval.cxx:1515
MCMCInterval.cxx:1516
MCMCInterval.cxx:1517
MCMCInterval.cxx:1518
MCMCInterval.cxx:1519
MCMCInterval.cxx:1520
MCMCInterval.cxx:1521
MCMCInterval.cxx:1522
MCMCInterval.cxx:1523
MCMCInterval.cxx:1524
MCMCInterval.cxx:1525
MCMCInterval.cxx:1526
MCMCInterval.cxx:1527
MCMCInterval.cxx:1528