ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id: RooIntegrator1D.cxx 28259 2009-04-16 16:21:16Z wouter $
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
//
// BEGIN_HTML
// RooIntegrator1D implements an adaptive one-dimensional 
// numerical integration algorithm. 
// END_HTML
//


#include "RooFit.h"
#include "Riostream.h"

#include "TClass.h"
#include "RooIntegrator1D.h"
#include "RooArgSet.h"
#include "RooRealVar.h"
#include "RooNumber.h"
#include "RooIntegratorBinding.h"
#include "RooNumIntConfig.h"
#include "RooNumIntFactory.h"
#include "RooMsgService.h"

#include <assert.h>



ClassImp(RooIntegrator1D)
;

// Register this class with RooNumIntConfig

//_____________________________________________________________________________
void RooIntegrator1D::registerIntegrator(RooNumIntFactory& fact)
{
  // Register RooIntegrator1D, is parameters and capabilities with RooNumIntFactory

  RooCategory sumRule("sumRule","Summation Rule") ;
  sumRule.defineType("Trapezoid",RooIntegrator1D::Trapezoid) ;
  sumRule.defineType("Midpoint",RooIntegrator1D::Midpoint) ;
  sumRule.setLabel("Trapezoid") ;
  RooCategory extrap("extrapolation","Extrapolation procedure") ;
  extrap.defineType("None",0) ;
  extrap.defineType("Wynn-Epsilon",1) ;
  extrap.setLabel("Wynn-Epsilon") ;
  RooRealVar maxSteps("maxSteps","Maximum number of steps",20) ;
  RooRealVar minSteps("minSteps","Minimum number of steps",999) ;
  RooRealVar fixSteps("fixSteps","Fixed number of steps",0) ;

  RooIntegrator1D* proto = new RooIntegrator1D() ;
  fact.storeProtoIntegrator(proto,RooArgSet(sumRule,extrap,maxSteps,minSteps,fixSteps)) ;
  RooNumIntConfig::defaultConfig().method1D().setLabel(proto->IsA()->GetName()) ;
}



//_____________________________________________________________________________
RooIntegrator1D::RooIntegrator1D() :
  _h(0), _s(0), _c(0), _d(0), _x(0)
{
  // Default constructor
}


//_____________________________________________________________________________
RooIntegrator1D::RooIntegrator1D(const RooAbsFunc& function, SummationRule rule,
				 Int_t maxSteps, Double_t eps) : 
  RooAbsIntegrator(function), _rule(rule), _maxSteps(maxSteps),  _minStepsZero(999), _fixSteps(0), _epsAbs(eps), _epsRel(eps), _doExtrap(kTRUE)
{
  // Construct integrator on given function binding, using specified summation
  // rule, maximum number of steps and conversion tolerance. The integration
  // limits are taken from the function binding

  _useIntegrandLimits= kTRUE;
  _valid= initialize();
} 


//_____________________________________________________________________________
RooIntegrator1D::RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax,
				 SummationRule rule, Int_t maxSteps, Double_t eps) : 
  RooAbsIntegrator(function), 
  _rule(rule), 
  _maxSteps(maxSteps), 
  _minStepsZero(999), 
  _fixSteps(0),
  _epsAbs(eps), 
  _epsRel(eps),
  _doExtrap(kTRUE)
{
  // Construct integrator on given function binding for given range,
  // using specified summation rule, maximum number of steps and
  // conversion tolerance. The integration limits are taken from the
  // function binding

  _useIntegrandLimits= kFALSE;
  _xmin= xmin;
  _xmax= xmax;
  _valid= initialize();
} 


//_____________________________________________________________________________
RooIntegrator1D::RooIntegrator1D(const RooAbsFunc& function, const RooNumIntConfig& config) :
  RooAbsIntegrator(function,config.printEvalCounter()), 
  _epsAbs(config.epsAbs()),
  _epsRel(config.epsRel())
{
  // Construct integrator on given function binding, using specified
  // configuration object. The integration limits are taken from the
  // function binding

  // Extract parameters from config object
  const RooArgSet& configSet = config.getConfigSection(IsA()->GetName()) ;  
  _rule = (SummationRule) configSet.getCatIndex("sumRule",Trapezoid) ;
  _maxSteps = (Int_t) configSet.getRealValue("maxSteps",20) ;
  _minStepsZero = (Int_t) configSet.getRealValue("minSteps",999) ;
  _fixSteps = (Int_t) configSet.getRealValue("fixSteps",0) ;
  _doExtrap = (Bool_t) configSet.getCatIndex("extrapolation",1) ;

  if (_fixSteps>_maxSteps) {
    oocoutE((TObject*)0,Integration) << "RooIntegrator1D::ctor() ERROR: fixSteps>maxSteps, fixSteps set to maxSteps" << endl ;
    _fixSteps = _maxSteps ;
  }

  _useIntegrandLimits= kTRUE;
  _valid= initialize();
} 



//_____________________________________________________________________________
RooIntegrator1D::RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax,
				const RooNumIntConfig& config) :
  RooAbsIntegrator(function,config.printEvalCounter()), 
  _epsAbs(config.epsAbs()),
  _epsRel(config.epsRel())
{
  // Construct integrator on given function binding, using specified
  // configuration object and integration range

  // Extract parameters from config object
  const RooArgSet& configSet = config.getConfigSection(IsA()->GetName()) ;  
  _rule = (SummationRule) configSet.getCatIndex("sumRule",Trapezoid) ;
  _maxSteps = (Int_t) configSet.getRealValue("maxSteps",20) ;
  _minStepsZero = (Int_t) configSet.getRealValue("minSteps",999) ;
  _fixSteps = (Int_t) configSet.getRealValue("fixSteps",0) ;  
  _doExtrap = (Bool_t) configSet.getCatIndex("extrapolation",1) ;

  _useIntegrandLimits= kFALSE;
  _xmin= xmin;
  _xmax= xmax;
  _valid= initialize();
} 



//_____________________________________________________________________________
RooAbsIntegrator* RooIntegrator1D::clone(const RooAbsFunc& function, const RooNumIntConfig& config) const
{
  // Clone integrator with new function binding and configuration. Needed by RooNumIntFactory
  return new RooIntegrator1D(function,config) ;
}



//_____________________________________________________________________________
Bool_t RooIntegrator1D::initialize()
{
  // Initialize the integrator

  // apply defaults if necessary
  if(_maxSteps <= 0) {
    _maxSteps= (_rule == Trapezoid) ? 20 : 14;
  }

  if(_epsRel <= 0) _epsRel= 1e-6;
  if(_epsAbs <= 0) _epsAbs= 1e-6;

  // check that the integrand is a valid function
  if(!isValid()) {
    oocoutE((TObject*)0,Integration) << "RooIntegrator1D::initialize: cannot integrate invalid function" << endl;
    return kFALSE;
  }

  // Allocate coordinate buffer size after number of function dimensions
  _x = new Double_t[_function->getDimension()] ;


  // Allocate workspace for numerical integration engine
  _h= new Double_t[_maxSteps + 2];
  _s= new Double_t[_maxSteps + 2];
  _c= new Double_t[_nPoints + 1];
  _d= new Double_t[_nPoints + 1];

  return checkLimits();
}


//_____________________________________________________________________________
RooIntegrator1D::~RooIntegrator1D()
{
  // Destructor

  // Release integrator workspace
  if(_h) delete[] _h;
  if(_s) delete[] _s;
  if(_c) delete[] _c;
  if(_d) delete[] _d;
  if(_x) delete[] _x;
}


//_____________________________________________________________________________
Bool_t RooIntegrator1D::setLimits(Double_t *xmin, Double_t *xmax) 
{
  // Change our integration limits. Return kTRUE if the new limits are
  // ok, or otherwise kFALSE. Always returns kFALSE and does nothing
  // if this object was constructed to always use our integrand's limits.

  if(_useIntegrandLimits) {
    oocoutE((TObject*)0,Integration) << "RooIntegrator1D::setLimits: cannot override integrand's limits" << endl;
    return kFALSE;
  }
  _xmin= *xmin;
  _xmax= *xmax;
  return checkLimits();
}


//_____________________________________________________________________________
Bool_t RooIntegrator1D::checkLimits() const 
{
  // Check that our integration range is finite and otherwise return kFALSE.
  // Update the limits from the integrand if requested.

  if(_useIntegrandLimits) {
    assert(0 != integrand() && integrand()->isValid());
    _xmin= integrand()->getMinLimit(0);
    _xmax= integrand()->getMaxLimit(0);
  }
  _range= _xmax - _xmin;
  if(_range < 0) {
    oocoutE((TObject*)0,Integration) << "RooIntegrator1D::checkLimits: bad range with min >= max (_xmin = " << _xmin << " _xmax = " << _xmax << ")" << endl;
    return kFALSE;
  }
  return (RooNumber::isInfinite(_xmin) || RooNumber::isInfinite(_xmax)) ? kFALSE : kTRUE;
}


//_____________________________________________________________________________
Double_t RooIntegrator1D::integral(const Double_t *yvec) 
{
  // Calculate numeric integral at given set of function binding parameters
  
  assert(isValid());

  // Copy yvec to xvec if provided
  if (yvec) {
    UInt_t i ; for (i=0 ; i<_function->getDimension()-1 ; i++) {
      _x[i+1] = yvec[i] ;
    }
  }

  Int_t j;
  _h[1]=1.0;
  Double_t zeroThresh = _epsAbs/_range ;
  for(j= 1; j<=_maxSteps; j++) {
    // refine our estimate using the appropriate summation rule
    _s[j]= (_rule == Trapezoid) ? addTrapezoids(j) : addMidpoints(j);

    if (j >= _minStepsZero) {
      Bool_t allZero(kTRUE) ;
      Int_t jj ; for (jj=0 ; jj<=j ; jj++) {	
	if (_s[j]>=zeroThresh) {
	  allZero=kFALSE ;
	}
      }
      if (allZero) {
	//cout << "Roo1DIntegrator(" << this << "): zero convergence at step " << j << ", value = " << 0 << endl ;
	return 0;
      }
    }
    
    if (_fixSteps>0) {
      
      // Fixed step mode, return result after fixed number of steps
      if (j==_fixSteps) {
	//cout << "returning result at fixed step " << j << endl ;
	return _s[j];
      }

    } else  if(j >= _nPoints) {

      // extrapolate the results of recent refinements and check for a stable result
      if (_doExtrap) {
	extrapolate(j);
      } else {
	_extrapValue = _s[j] ;
	_extrapError = _s[j]-(j>0?_s[j-1]:0) ;
      }

      if(fabs(_extrapError) <= _epsRel*fabs(_extrapValue)) {
	return _extrapValue;
      }
      if(fabs(_extrapError) <= _epsAbs) {
	return _extrapValue ;
      }

    }
    // update the step size for the next refinement of the summation
    _h[j+1]= (_rule == Trapezoid) ? _h[j]/4. : _h[j]/9.;
  }

  oocoutW((TObject*)0,Integration) << "RooIntegrator1D::integral: integral of " << _function->getName() << " over range (" << _xmin << "," << _xmax << ") did not converge after " 
				   << _maxSteps << " steps" << endl;
  for(j= 1; j <= _maxSteps; j++) {
    ooccoutW((TObject*)0,Integration) << "   [" << j << "] h = " << _h[j] << " , s = " << _s[j] << endl;
  }
  return _s[_maxSteps] ;
}


//_____________________________________________________________________________
Double_t RooIntegrator1D::addMidpoints(Int_t n)
{
  // Calculate the n-th stage of refinement of the Second Euler-Maclaurin
  // summation rule which has the useful property of not evaluating the
  // integrand at either of its endpoints but requires more function
  // evaluations than the trapezoidal rule. This rule can be used with
  // a suitable change of variables to estimate improper integrals.

  Double_t x,tnm,sum,del,ddel;
  Int_t it,j;

  if(n == 1) {
    Double_t xmid= 0.5*(_xmin + _xmax);
    return (_savedResult= _range*integrand(xvec(xmid)));
  }
  else {
    for(it=1, j=1; j < n-1; j++) it*= 3;
    tnm= it;
    del= _range/(3.*tnm);
    ddel= del+del;
    x= _xmin + 0.5*del;
    for(sum= 0, j= 1; j <= it; j++) {
      sum+= integrand(xvec(x));
      x+= ddel;
      sum+= integrand(xvec(x));
      x+= del;
    }      
    return (_savedResult= (_savedResult + _range*sum/tnm)/3.);
  }
}


//_____________________________________________________________________________
Double_t RooIntegrator1D::addTrapezoids(Int_t n)
{
  // Calculate the n-th stage of refinement of the extended trapezoidal
  // summation rule. This is the most efficient rule for a well behaved
  // integrand that can be evaluated over its entire range, including the
  // endpoints.

  Double_t x,tnm,sum,del;
  Int_t it,j;

  if (n == 1) {
    // use a single trapezoid to cover the full range
    return (_savedResult= 0.5*_range*(integrand(xvec(_xmin)) + integrand(xvec(_xmax))));
  }
  else {
    // break the range down into several trapezoids using 2**(n-2)
    // equally-spaced interior points
    for(it=1, j=1; j < n-1; j++) it <<= 1;
    tnm= it;
    del= _range/tnm;
    x= _xmin + 0.5*del;
    for(sum=0.0, j=1; j<=it; j++, x+=del) sum += integrand(xvec(x));
    return (_savedResult= 0.5*(_savedResult + _range*sum/tnm));
  }
}



//_____________________________________________________________________________
void RooIntegrator1D::extrapolate(Int_t n)
{
  // Extrapolate result to final value

  Double_t *xa= &_h[n-_nPoints];
  Double_t *ya= &_s[n-_nPoints];
  Int_t i,m,ns=1;
  Double_t den,dif,dift,ho,hp,w;

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