mumufit::ResidualFunctionAdapter Class Reference

Provides RootResidualFunction which will be minimizer by ROOT. More...

Inheritance diagram for mumufit::ResidualFunctionAdapter:

Collaboration diagram for mumufit::ResidualFunctionAdapter:

Public Member Functions
	ResidualFunctionAdapter (fcn_residual_t func, const Parameters &parameters)
int	numberOfCalls () const
int	numberOfGradientCalls () const
const RootResidualFunction *	rootResidualFunction ()

Protected Attributes
int	m_number_of_calls
int	m_number_of_gradient_calls

Private Member Functions
void	calculate_gradients (const std::vector< double > &pars)
double	chi2 (const std::vector< double > &pars)
	Evaluate chi2. More...
double	element_residual (const std::vector< double > &pars, unsigned int index, std::vector< double > &gradients)
	evaluate method for gradients and residuals called directly from the minimizer More...
std::vector< double >	get_residuals (const std::vector< double > &pars)

Private Attributes
size_t	m_datasize
	Length of vector with residuals, should stay the same during minimization. More...
fcn_residual_t	m_fcn
	user function to minimize More...
std::vector< std::vector< double > >	m_gradients
Parameters	m_parameters
std::vector< double >	m_residuals
std::unique_ptr< RootResidualFunction >	m_root_objective

Detailed Description

Provides RootResidualFunction which will be minimizer by ROOT.

Converts ROOT calls to the call of fcn_residual_t.

Definition at line 37 of file ResidualFunctionAdapter.h.

Constructor & Destructor Documentation

ResidualFunctionAdapter()

ResidualFunctionAdapter::ResidualFunctionAdapter	(	fcn_residual_t	func,
		const Parameters &	parameters
	)

Definition at line 27 of file ResidualFunctionAdapter.cpp.

    : m_datasize(0), m_fcn(func), m_parameters(parameters)
{
    // single call of user function to get dataset size
    auto residuals = m_fcn(parameters);
    m_datasize = residuals.size();
}

References m_datasize, and m_fcn.

Member Function Documentation

calculate_gradients()

void ResidualFunctionAdapter::calculate_gradients ( const std::vector< double > &  pars )

private

Definition at line 51 of file ResidualFunctionAdapter.cpp.

{
    m_gradients.clear();
    m_gradients.resize(pars.size());
    for (size_t i_par = 0; i_par < pars.size(); ++i_par)
        m_gradients[i_par].resize(m_datasize, 0.0);
 
    auto residuals = get_residuals(pars);
    m_number_of_gradient_calls++;
 
    for (size_t i_par = 0; i_par < pars.size(); ++i_par) {
        std::vector<double> pars_deriv = pars; // values of parameters for derivative calculation
        pars_deriv[i_par] += kEps;
 
        auto residuals2 = get_residuals(pars_deriv);
 
        for (size_t i_data = 0; i_data < m_datasize; ++i_data)
            m_gradients[i_par][i_data] = (residuals2[i_data] - residuals[i_data]) / kEps;
    }
}

References get_residuals(), m_datasize, m_gradients, and mumufit::IFunctionAdapter::m_number_of_gradient_calls.

Referenced by element_residual().

Here is the call graph for this function:

chi2()

double ResidualFunctionAdapter::chi2 ( const std::vector< double > &  pars )

private

Evaluate chi2.

Definition at line 120 of file ResidualFunctionAdapter.cpp.

{
    ++m_number_of_calls;
 
    double result(0.0);
    for (auto x : get_residuals(pars))
        result += x * x;
 
    int fnorm = static_cast<int>(m_datasize) - static_cast<int>(m_parameters.freeParameterCount());
    if (fnorm <= 0)
        throw std::runtime_error("ResidualFunctionAdapter::chi2() -> Error. Normalization is 0");
 
    return result / fnorm;
}

References mumufit::Parameters::freeParameterCount(), get_residuals(), m_datasize, mumufit::IFunctionAdapter::m_number_of_calls, and m_parameters.

Referenced by rootResidualFunction().

Here is the call graph for this function:

element_residual()

double ResidualFunctionAdapter::element_residual ( const std::vector< double > &  pars, unsigned int  index, std::vector< double > &  gradients  )

private

evaluate method for gradients and residuals called directly from the minimizer

Returns residual for given data element index.

If gradients vector size is not empty, also calculates gradients. Actuall calculation is done for all data elements when index==0. If index!=0 - cached value of residuals/gradients will be used.

Definition at line 99 of file ResidualFunctionAdapter.cpp.

{
    if (index == 0) {
        m_residuals = get_residuals(pars);
    }
 
    if (!gradients.empty()) {
        // Non zero size means that minimizer wants to know gradients.
        if (pars.size() != gradients.size())
            throw std::runtime_error("ResidualFunctionAdapter::element_residual() -> Error. "
                                     "Number of gradients doesn't match number of fit parameters.");
        if (index == 0)
            calculate_gradients(pars);
        for (size_t i_par = 0; i_par < pars.size(); ++i_par)
            gradients[i_par] = m_gradients[i_par][index];
    }
 
    return m_residuals[index];
}

References calculate_gradients(), get_residuals(), m_gradients, and m_residuals.

Referenced by rootResidualFunction().

Here is the call graph for this function:

get_residuals()

std::vector< double > ResidualFunctionAdapter::get_residuals ( const std::vector< double > &  pars )

private

Definition at line 72 of file ResidualFunctionAdapter.cpp.

{
    if (pars.size() != m_parameters.size()) {
        std::ostringstream ostr;
        ostr << "ResidualFunctionAdapter::residuals() -> Error. Number of fit parameters "
             << "has changed in the course of minimization. Initially was " << m_parameters.size()
             << " become " << pars.size() << "\n";
        throw std::runtime_error(ostr.str());
    }
 
    m_parameters.setValues(pars);
    auto result = m_fcn(m_parameters);
 
    if (result.size() != m_datasize) {
        std::ostringstream ostr;
        ostr << "ResidualFunctionAdapter::residuals() -> Error. Size of data "
             << "has changed in the course of minimization. Initial length " << m_datasize
             << " new length " << result.size() << "\n";
        throw std::runtime_error(ostr.str());
    }
    return result;
}

References m_datasize, m_fcn, m_parameters, mumufit::Parameters::setValues(), and mumufit::Parameters::size().

Referenced by calculate_gradients(), chi2(), and element_residual().

Here is the call graph for this function:

numberOfCalls()

int IFunctionAdapter::numberOfCalls ( ) const

inherited

Definition at line 23 of file IFunctionAdapter.cpp.

{
    return m_number_of_calls;
}

References mumufit::IFunctionAdapter::m_number_of_calls.

numberOfGradientCalls()

int IFunctionAdapter::numberOfGradientCalls ( ) const

inherited

Definition at line 28 of file IFunctionAdapter.cpp.

{
    return m_number_of_gradient_calls;
}

References mumufit::IFunctionAdapter::m_number_of_gradient_calls.

rootResidualFunction()

const RootResidualFunction * ResidualFunctionAdapter::rootResidualFunction

(

)

Definition at line 36 of file ResidualFunctionAdapter.cpp.

{
    gradient_function_t gradient_fun = [&](const std::vector<double>& pars, unsigned int index,
                                           std::vector<double>& gradients) {
        return element_residual(pars, index, gradients);
    };
 
    scalar_function_t objective_fun = [&](const std::vector<double>& pars) { return chi2(pars); };
 
    m_root_objective.reset(
        new RootResidualFunction(objective_fun, gradient_fun, m_parameters.size(), m_datasize));
 
    return m_root_objective.get();
}

References chi2(), element_residual(), m_datasize, m_parameters, m_root_objective, and mumufit::Parameters::size().

Here is the call graph for this function:

Member Data Documentation

m_datasize

size_t mumufit::ResidualFunctionAdapter::m_datasize

private

Length of vector with residuals, should stay the same during minimization.

Definition at line 54 of file ResidualFunctionAdapter.h.

Referenced by ResidualFunctionAdapter(), calculate_gradients(), chi2(), get_residuals(), and rootResidualFunction().

m_fcn

fcn_residual_t mumufit::ResidualFunctionAdapter::m_fcn

private

user function to minimize

Definition at line 55 of file ResidualFunctionAdapter.h.

Referenced by ResidualFunctionAdapter(), and get_residuals().

m_gradients

std::vector<std::vector<double> > mumufit::ResidualFunctionAdapter::m_gradients

private

Definition at line 58 of file ResidualFunctionAdapter.h.

Referenced by calculate_gradients(), and element_residual().

m_number_of_calls

int mumufit::IFunctionAdapter::m_number_of_calls

protectedinherited

Definition at line 37 of file IFunctionAdapter.h.

Referenced by chi2(), mumufit::IFunctionAdapter::numberOfCalls(), and mumufit::ScalarFunctionAdapter::rootObjectiveFunction().

m_number_of_gradient_calls

int mumufit::IFunctionAdapter::m_number_of_gradient_calls

protectedinherited

Definition at line 38 of file IFunctionAdapter.h.

Referenced by calculate_gradients(), and mumufit::IFunctionAdapter::numberOfGradientCalls().

m_parameters

Parameters mumufit::ResidualFunctionAdapter::m_parameters

private

Definition at line 56 of file ResidualFunctionAdapter.h.

Referenced by chi2(), get_residuals(), and rootResidualFunction().

m_residuals

std::vector<double> mumufit::ResidualFunctionAdapter::m_residuals

private

Definition at line 57 of file ResidualFunctionAdapter.h.

Referenced by element_residual().

m_root_objective

std::unique_ptr<RootResidualFunction> mumufit::ResidualFunctionAdapter::m_root_objective

private

Definition at line 59 of file ResidualFunctionAdapter.h.

Referenced by rootResidualFunction().

---

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

• /home/www/ba/Fit/Adapter/ResidualFunctionAdapter.h
• /home/www/ba/Fit/Adapter/ResidualFunctionAdapter.cpp