RooCubicSplineFun Class Reference

#include <RooCubicSplineFun.h>

Inheritance diagram for RooCubicSplineFun:

Public Member Functions
	RooCubicSplineFun ()
	RooCubicSplineFun (const char *name, const char *title, RooRealVar &x, const std::vector< double > &knots, const std::vector< double > &values, const std::vector< double > &errors=std::vector< double >(), double smooth=0, bool constCoeffs=true)
	RooCubicSplineFun (const char *name, const char *title, RooRealVar &x, const TGraph *graph, bool constCoeffs=true)
	RooCubicSplineFun (const char *name, const char *title, RooRealVar &x, const TH1 *hist, double smooth=0, bool constCoeffs=true)
	RooCubicSplineFun (const char *name, const char *title, RooRealVar &x, const TGraphErrors *graph, double smooth=0, bool constCoeffs=true)
	RooCubicSplineFun (const char *name, const char *title, RooRealVar &x, const char *knotBinningName, const RooArgList &coefList)
	RooCubicSplineFun (const char *name, const char *title, RooRealVar &x, const std::vector< double > &knots, const RooArgList &coefList)
	~RooCubicSplineFun ()
	RooCubicSplineFun (const RooCubicSplineFun &other, const char *name=0)
TObject *	clone (const char *newname) const
Int_t	getAnalyticalIntegral (RooArgSet &allVars, RooArgSet &analVars, const char *rangeName) const
Double_t	analyticalIntegral (Int_t code, const char *rangeName) const
Int_t	getMaxVal (const RooArgSet &vars) const
Double_t	maxVal (Int_t code) const
std::complex< double >	productAnalyticalIntegral (Double_t umin, Double_t umax, Double_t scale, Double_t offset, const std::complex< double > &z) const
unsigned	knotSize () const
double	u (int i) const
const std::vector< double > &	knots () const
const RooArgList &	coefficients () const
Public Member Functions inherited from RooAbsGaussModelEfficiency
	RooAbsGaussModelEfficiency ()
	RooAbsGaussModelEfficiency (const char *name, const char *title, const char *unit="")
	RooAbsGaussModelEfficiency (const RooAbsGaussModelEfficiency &other, const char *name=0)
	~RooAbsGaussModelEfficiency ()

Private Member Functions
void	init (const char *name, const std::vector< double > &heights, const std::vector< double > &errors, double smooth, bool constCoeffs)
Double_t	evaluate () const
std::complex< double >	gaussIntegralE (bool left, const RooGaussModelAcceptance::M_n< 4U > &dM, const RooGaussModelAcceptance::K_n &K, double offset, double *sc) const

Private Attributes
RooRealProxy	_x
RooListProxy	_coefList
RooCubicSplineKnot	_aux

Friends
class	RooSplineProduct

Detailed Description

Definition at line 27 of file RooCubicSplineFun.h.

Constructor & Destructor Documentation

RooCubicSplineFun() [1/8]

RooCubicSplineFun::RooCubicSplineFun

(

)

Definition at line 79 of file RooCubicSplineFun.cpp.

    : _aux(0,0)
{
}

RooCubicSplineFun() [2/8]

RooCubicSplineFun::RooCubicSplineFun	(	const char *	name,
		const char *	title,
		RooRealVar &	x,
		const std::vector< double > &	knots,
		const std::vector< double > &	values,
		const std::vector< double > &	errors = std::vector< double >(),
		double	smooth = 0,
		bool	constCoeffs = true
	)

RooCubicSplineFun() [3/8]

RooCubicSplineFun::RooCubicSplineFun	(	const char *	name,
		const char *	title,
		RooRealVar &	x,
		const TGraph *	graph,
		bool	constCoeffs = true
	)

Definition at line 99 of file RooCubicSplineFun.cpp.

                                                                                           :
  RooAbsGaussModelEfficiency(name, title),
  _x("x", "Dependent", this, x),
  _coefList("coefficients","List of coefficients",this),
  _aux(0,0)
{
    int nPoints = graph->GetN();
    vector<double> centres, values;
    for (int i=0;i<nPoints ;++i) {
        double x,y;
        graph->GetPoint(i,x,y);
        centres.push_back(x);
        values.push_back(y);
    }
   _aux = RooCubicSplineKnot( centres.begin(), centres.end() );
    vector<double> errs;
    init(name, values, errs, 0, constCoeffs);
}

RooCubicSplineFun() [4/8]

RooCubicSplineFun::RooCubicSplineFun	(	const char *	name,
		const char *	title,
		RooRealVar &	x,
		const TH1 *	hist,
		double	smooth = 0,
		bool	constCoeffs = true
	)

Definition at line 120 of file RooCubicSplineFun.cpp.

                                                       :
  RooAbsGaussModelEfficiency(name, title),
  _x("x", "Dependent", this, x),
  _coefList("coefficients","List of coefficients",this),
  _aux(0,0)
{
    // bin 0 is underflow, and bin nBins + 1 is overflow...
    int nBins = hist->GetNbinsX();
    vector<double> centres, values;
    for (int i=0;i<nBins ;++i) {
        centres.push_back(hist->GetBinCenter(1+i));
        values.push_back(hist->GetBinContent(1+i));
    }
   _aux = RooCubicSplineKnot( centres.begin(), centres.end() );

    vector<double> errs;
    if (smooth>0) for (int i=0;i<nBins ;++i) errs.push_back(hist->GetBinError(1+i));

    init(name, values, errs, smooth, constCoeffs);
}

RooCubicSplineFun() [5/8]

RooCubicSplineFun::RooCubicSplineFun	(	const char *	name,
		const char *	title,
		RooRealVar &	x,
		const TGraphErrors *	graph,
		double	smooth = 0,
		bool	constCoeffs = true
	)

Definition at line 143 of file RooCubicSplineFun.cpp.

                                                       :
  RooAbsGaussModelEfficiency(name, title),
  _x("x", "Dependent", this, x),
  _coefList("coefficients","List of coefficients",this),
  _aux(0,0)
{
    int nPoints = graph->GetN();
    vector<double> centres, values;
    for (int i=0;i<nPoints ;++i) {
        double x,y;
        graph->GetPoint(i,x,y);
        centres.push_back(x);
        values.push_back(y);
    }
   _aux = RooCubicSplineKnot( centres.begin(), centres.end() );

    vector<double> errs;
    if (smooth>0) for (int i=0;i<nPoints ;++i) errs.push_back(graph->GetErrorY(i));

    init(name, values, errs, smooth, constCoeffs);
}

RooCubicSplineFun() [6/8]

RooCubicSplineFun::RooCubicSplineFun	(	const char *	name,
		const char *	title,
		RooRealVar &	x,
		const char *	knotBinningName,
		const RooArgList &	coefList
	)

Definition at line 168 of file RooCubicSplineFun.cpp.

                                                                :
  RooAbsGaussModelEfficiency(name, title),
  _x("x", "Dependent", this, x),
  _coefList("coefficients", "List of coefficients", this),
  _aux(0,0)
{
  // TODO: verify coefList is consistent with knots as specified by the knotBinningName binning
  //    should be N+2 coefficients for N bins...
  const RooAbsBinning* binning = x.getBinningPtr(knotBinningName);
  assert( binning!=0);
  if ( coefList.getSize()!=2+binning->numBoundaries())  {
        cout << TString::Format( "you have specified %d coefficients for %d knots. The differentce should 2!",coefList.getSize(),binning->numBoundaries()) << endl;
        throw TString::Format( "you have specified %d coefficients for %d knots. The differentce should 2!",coefList.getSize(),binning->numBoundaries());
  }
  _coefList.add(coefList);

  Double_t* boundaries = binning->array();
  _aux = RooCubicSplineKnot( boundaries, boundaries + binning->numBoundaries() );
}

RooCubicSplineFun() [7/8]

RooCubicSplineFun::RooCubicSplineFun	(	const char *	name,
		const char *	title,
		RooRealVar &	x,
		const std::vector< double > &	knots,
		const RooArgList &	coefList
	)

~RooCubicSplineFun()

RooCubicSplineFun::~RooCubicSplineFun

(

)

Definition at line 213 of file RooCubicSplineFun.cpp.

{
}

RooCubicSplineFun() [8/8]

RooCubicSplineFun::RooCubicSplineFun	(	const RooCubicSplineFun &	other,
		const char *	name = 0
	)

Definition at line 204 of file RooCubicSplineFun.cpp.

                                                                                     :
  RooAbsGaussModelEfficiency(other, name),
  _x("x", this, other._x),
  _coefList("coefList", this, other._coefList),
  _aux(other._aux)
{
}

Member Function Documentation

analyticalIntegral()

Double_t RooCubicSplineFun::analyticalIntegral	(	Int_t	code,
		const char *	rangeName
	)		const

Definition at line 232 of file RooCubicSplineFun.cpp.

{
  if (code != 1) {
    coutE(InputArguments) << "RooCubicSplineFun::analyticalIntegral(" << GetName()
        << "): argument \"code\" can only have value 1" << std::endl;
    assert(code==1) ;
  }
  return _aux.analyticalIntegral(_coefList);
}

clone()

TObject* RooCubicSplineFun::clone ( const char *  newname ) const

inline

Definition at line 53 of file RooCubicSplineFun.h.

{ return new RooCubicSplineFun(*this, newname); }

coefficients()

const RooArgList& RooCubicSplineFun::coefficients ( ) const

inline

Definition at line 69 of file RooCubicSplineFun.h.

{ return _coefList; }

evaluate()

Double_t RooCubicSplineFun::evaluate ( ) const

private

Definition at line 218 of file RooCubicSplineFun.cpp.

{
  return _aux.evaluate(_x,_coefList);
}

gaussIntegralE()

complex< double > RooCubicSplineFun::gaussIntegralE ( bool  left, const RooGaussModelAcceptance::M_n< 4U > &  dM, const RooGaussModelAcceptance::K_n &  K, double  offset, double *  sc  ) const

private

Definition at line 243 of file RooCubicSplineFun.cpp.

{
        RooCubicSplineKnot::S_edge s_jk( _aux.S_jk_edge( left, _coefList ), offset );
        return dM(0)*( s_jk(0,0) * K(0) * sc[0] + s_jk(0,1) * K(1) * sc[1] )
             + dM(1)*( s_jk(1,0) * K(0) * sc[1]                            );
}

getAnalyticalIntegral()

Int_t RooCubicSplineFun::getAnalyticalIntegral	(	RooArgSet &	allVars,
		RooArgSet &	analVars,
		const char *	rangeName
	)		const

Definition at line 224 of file RooCubicSplineFun.cpp.

{
  // No analytical calculation available (yet) of integrals over subranges
  if (_x.min(rangeName)!=_aux.knots().front() || _x.max(rangeName)!=_aux.knots().back() ) return 0;
  if (matchArgs(allVars, analVars, _x)) return 1;
  return 0;
}

getMaxVal()

Int_t RooCubicSplineFun::getMaxVal

(

const RooArgSet &

vars

)

const

Definition at line 284 of file RooCubicSplineFun.cpp.

{
    // check that vars only contains _x...
    return ( vars.getSize() == 1 && vars.contains( _x.arg() ) ) ? 1 : 0;
}

init()

void RooCubicSplineFun::init ( const char *  name, const std::vector< double > &  heights, const std::vector< double > &  errors, double  smooth, bool  constCoeffs  )

private

Definition at line 49 of file RooCubicSplineFun.cpp.

                                                              {
   vector<double> values(heights);
   if ( smooth > 0 ) {
      assert(int(errors.size()) == _aux.size());
      _aux.smooth( values, errors, smooth );
   }
   _aux.computeCoefficients( values );
   for (unsigned int i=0;i<values.size();++i) {
      if (constCoeffs) {
         _coefList.add( RooFit::RooConst( values[i] ) );
      } else {
         stringstream name_str;
         name_str << name << "_bin_" << i;
         string n(name_str.str());
         RooRealVar* coeff = new RooRealVar(n.c_str(), n.c_str(), values[i], 0.0, 10.0);
//          if (i == 0 || i == values.size() - 1) coeff->setConstant(true);
         if (i == values.size() - 2){
             coeff->setVal(1.0);
         coeff->setConstant(true);
    }
    _coefList.add(*coeff);
         addOwnedComponents( *coeff );
      }
   }
}

knots()

const std::vector<double>& RooCubicSplineFun::knots ( ) const

inline

Definition at line 68 of file RooCubicSplineFun.h.

{ return _aux.knots(); }

knotSize()

unsigned RooCubicSplineFun::knotSize ( ) const

inline

Definition at line 66 of file RooCubicSplineFun.h.

{ return _aux.size(); }

maxVal()

Double_t RooCubicSplineFun::maxVal

(

Int_t

code

)

const

Definition at line 290 of file RooCubicSplineFun.cpp.

{
    if (code != 1) {
      coutE(InputArguments) << "RooCubicSplineFun::maxVal(" << GetName()
          << "): argument \"code\" can only have value 1" << std::endl;
      assert(code==1) ;
    }
    RooFIter iter = _coefList.fwdIterator();
    RooAbsReal *c(0);
    double res = 0;
    while((c=(RooAbsReal*)iter.next())) {
          double x = fabs(c->getVal());
          if (x>res)  { res = x; }
    }
    return res;
}

productAnalyticalIntegral()

std::complex< double > RooCubicSplineFun::productAnalyticalIntegral ( Double_t  umin, Double_t  umax, Double_t  scale, Double_t  offset, const std::complex< double > &  z  ) const

virtual

Implements RooAbsGaussModelEfficiency.

Definition at line 254 of file RooCubicSplineFun.cpp.

{
    RooGaussModelAcceptance::K_n K(z);
    assert(knotSize()>1);
    double lo = scale*umin+offset;
    double hi = scale*umax+offset+1.e-7;
    typedef RooGaussModelAcceptance::M_n<4U> M_n;
    std::vector<M_n> M; M.reserve( knotSize() );
    for (unsigned int i=0;i<knotSize();++i) {
        double x = (u(i)-offset)/scale ;
        // TODO: remove unnecessary calculation of integral (that gives 0) if lo>u(i) and/or u(i+1)<hi
        if (lo>=u(i)) x = umin ; // take M[i] if lo<=u(i) else M_n(lo)
        if (u(i)>=hi) x = umax ; // take M[i+1] if u(i+1)<=hi else M_n(hi)
        M.push_back( M_n( x, z ) );
    }
    double sc[4]; for (int i=0;i<4;++i) sc[i] = pow(scale,i);
    std::complex<double> sum(0,0);
    if (lo<u(0)) sum += gaussIntegralE(true,  M.front()-M_n( umin,z), K, offset, sc);
    for (unsigned i=0;i<knotSize()-1 && u(i)<hi ;++i) {
        M_n dM = M[i+1]-M[i];
        RooCubicSplineKnot::S_jk s_jk( _aux.S_jk_sum( i, _coefList ), offset );  // pass sc into S_jk, remove from loop
        for (int j=0;j<4;++j) for (int k=0;k<4-j;++k) sum += dM(j)*s_jk(j,k)*K(k)*sc[j+k];
    }
    if (hi>u(knotSize()-1)) sum += gaussIntegralE(false, M_n(umax,z)-M.back(),   K, offset, sc);
    return sum;
}

u()

double RooCubicSplineFun::u ( int  i ) const

inline

Definition at line 67 of file RooCubicSplineFun.h.

{ return _aux.u(i); }

Friends And Related Function Documentation

RooSplineProduct

friend class RooSplineProduct

friend

Definition at line 28 of file RooCubicSplineFun.h.

Member Data Documentation

_aux

RooCubicSplineKnot RooCubicSplineFun::_aux

private

Definition at line 75 of file RooCubicSplineFun.h.

_coefList

RooListProxy RooCubicSplineFun::_coefList

private

Definition at line 74 of file RooCubicSplineFun.h.

_x

RooRealProxy RooCubicSplineFun::_x

private

Definition at line 73 of file RooCubicSplineFun.h.

---

The documentation for this class was generated from the following files:

• Mint/RooCubicSplineFun.h
• src/Mojito/TimeDependent/RooCubicSplineFun.cpp