#include <resol_fn.h>
Public Member Functions | |
ResolutionFn (const HKL_info &hkl_info, const BasisFn_base &basisfn, const TargetFn_base &targetfn, const std::vector< ftype > ¶ms, const ftype damp=0.0, const bool debug=false) | |
constructor: need reflections, basis fn and target fn. | |
ftype | f (const HKL_info::HKL_reference_index &ih) const |
return the value of the basis function with the current paramters | |
const std::vector< ftype > & | params () const |
return the values of the parameters | |
void | debug () const |
print the target, gradient, and curvatures with respect to the params | |
Protected Member Functions | |
void | calc_derivs (const std::vector< ftype > ¶ms, ftype &r, std::vector< ftype > &drdp, Matrix<> &drdp2) const |
calculate derivatives of target wrt params | |
ResolutionFn () | |
null constructor | |
Protected Attributes | |
const HKL_info * | hkl_info_ |
reflection list | |
const TargetFn_base * | targetfn_ |
target function | |
const BasisFn_base * | basisfn_ |
basis function | |
std::vector< ftype > | params_ |
basis function parameters | |
Cell | cell_ |
cell |
This is an automatic evaluator for arbitrary functions of HKL, most commonly used for evaluating a function of resolution (such a mean F^2 or sigmaa), although more general tasks including local scaling of reflections and anisotropic functions can also be handled. This form is for target functions which approach zero quadratically, e.g. least-squares targets.
This version implements a naive Newton-Raphson minimiser, which only uses the gradient and curvature of the target function, ignoring its value. It is ideal for quadratic targets with linear basis functions.
To evaluate a resolution function, this class must be provided with two objects:
For example, the following code may be used to calculate a smooth scaling function to scale one set of data to another using an anisotropic Gaussian scaling function:
make data object clipper::HKL_info hkls; clipper::HKL_data<clipper::data32::F_sigF> fsig1( hkls ); clipper::HKL_data<clipper::data32::F_sigF> fsig2( hkls ); INITIALISE THEM HERE! calculate the scaling function std::vector<clipper::ftype> params( 7, 0.0 ); // initial parameters clipper::BasisFn_aniso_gaussian basisfn; // aniso gaussian clipper::TargetFn_scaleF1F2<clipper::data32::F_sigF,clipper::data32::F_sigF>targetfn( fsig1, fsig2 ); clipper::ResolutionFn_nonlinear rfn( hkls, basisfn, targetfn, params ); now scale the data clipper::HKL_info::HKL_reference_index ih; for ( ih = hkls.first(); !ih.last(); ih.next() ) fsig1[ih].scale( sqrt( rfn.f(ih) ) );
The most useful isotropic resolution function is the BasisFn_spline, since it is linear and provides a good fit to most data.
clipper::ResolutionFn::ResolutionFn | ( | const HKL_info & | hkl_info, | |
const BasisFn_base & | basisfn, | |||
const TargetFn_base & | targetfn, | |||
const std::vector< ftype > & | params, | |||
const ftype | damp = 0.0 , |
|||
const bool | debug = false | |||
) |
constructor: need reflections, basis fn and target fn.
The constructor performs the full minimisation calculation.
hkl_info | HKL_info object which provides the reflection list. | |
basisfn | The basis function used to describe the desired property. | |
targetfn | The target function to be minimised. | |
damp_ | If > 0.0, shifts are fdamped during early cycles to help convergence with difficult bases/target conbinations. |
const std::vector< ftype > & clipper::ResolutionFn::params | ( | ) | const |
return the values of the parameters
void clipper::ResolutionFn::calc_derivs | ( | const std::vector< ftype > & | params, | |
ftype & | r, | |||
std::vector< ftype > & | drdp, | |||
Matrix<> & | drdp2 | |||
) | const [protected] |
calculate derivatives of target wrt params
The target and its derivatives are calculated by the chain rule and accumulated over all HKLs.
params | Current value of parameters. | |
r | The value of the target function. | |
drdp | The derivative of the target function. | |
drdp2 | The curvature of the target function. |