RooEffResModel::CacheElem Class Reference

Inheritance diagram for RooEffResModel::CacheElem:

Public Member Functions
	CacheElem (const RooEffResModel &parent, const RooArgSet &iset, const TNamed *rangeName)
virtual	~CacheElem ()
virtual RooArgList	containedArgs (Action)
Double_t	getVal (const RooArgSet *nset=0) const

Private Attributes
std::vector< double >	_bounds
RooRealVar *	_x
RooAbsReal *	_eff
RooRealVar *	_xmin
RooRealVar *	_xmax
RooAbsReal *	_int
Double_t	_val

Detailed Description

Definition at line 79 of file RooEffResModel.h.

Constructor & Destructor Documentation

CacheElem()

RooEffResModel::CacheElem::CacheElem	(	const RooEffResModel &	parent,
		const RooArgSet &	iset,
		const TNamed *	rangeName
	)

Definition at line 78 of file RooEffResModel.cpp.

                                 :
    _x(0), _eff(0), _xmin(0), _xmax(0), _int(0),
    _val(std::numeric_limits<Double_t>::quiet_NaN())
{
    RooRealVar& x = parent.convVar(); // binboundaries not const...
    RooAbsReal& eff = *parent.efficiency();
    RooAbsReal& model = parent.model();
    // the subset of iset on which the efficiency depends
    myunique_ptr<const RooArgSet> effInt( eff.getObservables(iset) );

    if (effInt->getSize()>1) {
    std::cout << " got efficiency iset with more than 1 AbsArg -- not yet supported" << std::endl;
    effInt->Print("V");
    }
    assert(effInt->getSize() < 2); // for now, we only do 1D efficiency histograms...
    //TODO: instead of the above, verify whether things factorize, i.e.
    //      allow the case where the overlap of effInt and model is 1D, and
    //      all 'other' dependencies are from the efficiency only...
    //      That works because we can then ingrate the 'ceff' coefficient below
    //      over the remaining dependencies...
    if (0 == effInt->getSize()) {
        _int = parent.model().createIntegral(iset, RooNameReg::str(rangeName));
        return;
    }

    const char* rn = (rangeName ? RooNameReg::str(rangeName) : "");
    // get bin bounds
    const double rxmin = x.getMin(rn);
    const double rxmax = x.getMax(rn);

    myunique_ptr<std::list<Double_t> > bounds(
            eff.binBoundaries(x, x.getMin(), x.getMax()));
    assert(bounds->size() > 1);
    _bounds.reserve(bounds->size());
    for (std::list<Double_t>::const_iterator
            lo = bounds->begin(), hi = ++(bounds->begin());
            hi != bounds->end(); ++hi, ++lo) {
        if (*hi < rxmin) continue; // not there yet...
        if (*lo > rxmax) break;    // past the requested interval...
        const double xmin = std::max(*lo, rxmin);
        const double xmax = std::min(*hi, rxmax);
        if (_bounds.empty())
            _bounds.push_back(xmin);
        _bounds.push_back(xmax);
    }
    assert(_bounds.size() > 1);
    // build integral ingredients
    _x = dynamic_cast<RooRealVar*>(x.clone((std::string(x.GetName()) + "_" +
                    rn).c_str()));
    assert(_x);
    RooCustomizer customizer2(model, (std::string(rn) + "_customizer2").c_str());
    customizer2.replaceArg(x, *_x);
    RooAbsReal* m = dynamic_cast<RooAbsReal*>(customizer2.build(false));
    assert(m);
    // build "customised" version of iset
    RooArgSet custiset(iset);
    custiset.replace(x, *_x);
    // working range
    _xmin = dynamic_cast<RooRealVar*>(_x->clone(
                (std::string(_x->GetName()) + "_xmin").c_str()));
    assert(_xmin);
    _xmin->setVal(_bounds.front());
    _xmax = dynamic_cast<RooRealVar*>(_x->clone(
                (std::string(_x->GetName()) + "_xmax").c_str()));
    assert(_xmax);
    _xmax->setVal(_bounds.back());
    std::string wrn(parent.GetName());
    wrn += "_"; wrn += x.GetName(); wrn += "_"; wrn += model.GetName();
    wrn += "_"; wrn += eff.GetName(); wrn += "_"; wrn += rn;
    wrn += "_workRange";
    assert(!_x->hasRange(wrn.c_str()));
    _x->setRange(wrn.c_str(), *_xmin, *_xmax);
    // build integral
    _int = m->createIntegral(custiset, wrn.c_str());
    assert(_int);
    _int->addOwnedComponents(*m);
    _int->addOwnedComponents(*_x);
    _int->addOwnedComponents(*_xmin);
    _int->addOwnedComponents(*_xmax);
    // build efficiency in bin middle
    RooCustomizer customizer(eff, (std::string(rn) + "_customizer").c_str());
    customizer.replaceArg(x, *_x);
    _eff = static_cast<RooAbsReal*>(customizer.build(false));
    assert(_eff);
}

~CacheElem()

RooEffResModel::CacheElem::~CacheElem ( )

virtual

Definition at line 62 of file RooEffResModel.cpp.

{
    delete _eff;
    delete _int; // _int owns _x, _xmin, _xmax, so no need to free them
}

Member Function Documentation

containedArgs()

RooArgList RooEffResModel::CacheElem::containedArgs ( Action  )

virtual

Definition at line 69 of file RooEffResModel.cpp.

{
    // Return list of all RooAbsArgs in cache element
    if (_eff) return RooArgList(*_int, *_eff, *_x, *_xmin, *_xmax);
    else return RooArgList(*_int);
}

getVal()

Double_t RooEffResModel::CacheElem::getVal

(

const RooArgSet *

nset = 0

)

const

Definition at line 165 of file RooEffResModel.cpp.

{
    if (0 == _x) {
        // handle trivial case
        return _int->getVal(nset);
    }
    // see if our cached value needs recalculating
    if (_val != _val || _eff->isValueOrShapeDirtyAndClear() ||
            _int->isValueOrShapeDirtyAndClear()) {
        // yes, so iterate over subranges, and sum up integral contributions
        _val = 0.;
        for (unsigned i = 1; i < _bounds.size(); ++i) {
            _xmin->setVal(_bounds[i - 1]);
            _xmax->setVal(_bounds[i]);
            _x->setVal(0.5 * (_bounds[i - 1] + _bounds[i]));
            _val += _int->getVal() * _eff->getVal();
        }
    }

    return _val;
}

Member Data Documentation

_bounds

std::vector<double> RooEffResModel::CacheElem::_bounds

private

Definition at line 91 of file RooEffResModel.h.

_eff

RooAbsReal* RooEffResModel::CacheElem::_eff

private

Definition at line 93 of file RooEffResModel.h.

_int

RooAbsReal* RooEffResModel::CacheElem::_int

private

Definition at line 96 of file RooEffResModel.h.

_val

Double_t RooEffResModel::CacheElem::_val

mutableprivate

Definition at line 97 of file RooEffResModel.h.

_x

RooRealVar* RooEffResModel::CacheElem::_x

private

Definition at line 92 of file RooEffResModel.h.

_xmax

RooRealVar* RooEffResModel::CacheElem::_xmax

private

Definition at line 95 of file RooEffResModel.h.

_xmin

RooRealVar* RooEffResModel::CacheElem::_xmin

private

Definition at line 94 of file RooEffResModel.h.

---

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

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