Fit::ResidualFunctionAdapter Class Reference

Inheritance diagram for Fit::ResidualFunctionAdapter:

Collaboration diagram for Fit::ResidualFunctionAdapter:

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

Protected Attributes
int	m_number_of_calls
int	m_number_of_gradient_calls

Private Member Functions
void	calculate_gradients (const std::vector< double > &pars)
std::vector< double >	get_residuals (const std::vector< double > &pars)
double	element_residual (const std::vector< double > &pars, unsigned int index, std::vector< double > &gradients)
double	chi2 (const std::vector< double > &pars)

Private Attributes
size_t	m_datasize
fcn_residual_t	m_fcn
Parameters	m_parameters
std::vector< double >	m_residuals
std::vector< std::vector< double > >	m_gradients
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 33 of file ResidualFunctionAdapter.h.

Constructor & Destructor Documentation

ResidualFunctionAdapter()

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

Definition at line 28 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

rootResidualFunction()

const RootResidualFunction * ResidualFunctionAdapter::rootResidualFunction

(

)

Definition at line 37 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 Fit::Parameters::size().

Here is the call graph for this function:

calculate_gradients()

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

private

Definition at line 52 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(), anonymous_namespace{ResidualFunctionAdapter.cpp}::kEps, m_datasize, m_gradients, and Fit::IFunctionAdapter::m_number_of_gradient_calls.

Referenced by element_residual().

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 73 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, Fit::Parameters::setValues(), and Fit::Parameters::size().

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

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 100 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:

chi2()

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

private

Evaluate chi2.

Definition at line 121 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 Fit::Parameters::freeParameterCount(), get_residuals(), m_datasize, Fit::IFunctionAdapter::m_number_of_calls, and m_parameters.

Referenced by rootResidualFunction().

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 Fit::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 Fit::IFunctionAdapter::m_number_of_gradient_calls.

Member Data Documentation

m_datasize

size_t Fit::ResidualFunctionAdapter::m_datasize

private

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

Definition at line 51 of file ResidualFunctionAdapter.h.

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

m_fcn

fcn_residual_t Fit::ResidualFunctionAdapter::m_fcn

private

user function to minimize

Definition at line 52 of file ResidualFunctionAdapter.h.

Referenced by get_residuals(), and ResidualFunctionAdapter().

m_parameters

Parameters Fit::ResidualFunctionAdapter::m_parameters

private

Definition at line 53 of file ResidualFunctionAdapter.h.

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

m_residuals

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

private

Definition at line 54 of file ResidualFunctionAdapter.h.

Referenced by element_residual().

m_gradients

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

private

Definition at line 55 of file ResidualFunctionAdapter.h.

Referenced by calculate_gradients(), and element_residual().

m_root_objective

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

private

Definition at line 56 of file ResidualFunctionAdapter.h.

Referenced by rootResidualFunction().

m_number_of_calls

int Fit::IFunctionAdapter::m_number_of_calls

protectedinherited

Definition at line 34 of file IFunctionAdapter.h.

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

m_number_of_gradient_calls

int Fit::IFunctionAdapter::m_number_of_gradient_calls

protectedinherited

Definition at line 35 of file IFunctionAdapter.h.

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

---

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

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