def r1_setup():
"""Modify the current spin parameter list to either include or exclude the R1 parameter."""
# Loop over the spins.
for spin, spin_id in spin_loop(return_id=True, skip_desel=True):
# No model set up.
if not hasattr(spin, 'params') or not hasattr(spin, 'model'):
continue
# Should R1 data be optimised?
r1_fit = is_r1_optimised(spin.model)
# Prepend R1 and add it to the spin container.
if r1_fit and 'r1' not in spin.params:
spin.params.insert(0, 'r1')
if r1_fit and not hasattr(spin, 'r1'):
spin.r1 = {}
# Remove the R1 parameter.
if not r1_fit and 'r1' in spin.params:
spin.params.remove('r1')
def r1_setup():
"""Modify the current spin parameter list to either include or exclude the R1 parameter."""
# Loop over the spins.
for spin, spin_id in spin_loop(return_id=True, skip_desel=True):
# No model set up.
if not hasattr(spin, 'params') or not hasattr(spin, 'model'):
continue
# Should R1 data be optimised?
r1_fit = is_r1_optimised(spin.model)
# Prepend R1 and add it to the spin container.
if r1_fit and 'r1' not in spin.params:
spin.params.insert(0, 'r1')
if r1_fit and not hasattr(spin, 'r1'):
spin.r1 = {}
# Remove the R1 parameter.
if not r1_fit and 'r1' in spin.params:
spin.params.remove('r1')
def optimise(self, model=None, model_path=None):
"""Optimise the model, taking model nesting into account.
@keyword model: The model to be optimised.
@type model: str
@keyword model_path: The folder name for the model, where possible spaces has been replaced with underscore.
@type model_path: str
"""
# Printout.
section(file=sys.stdout, text="Optimisation", prespace=2)
# Deselect insignificant spins.
if model not in [MODEL_R2EFF, MODEL_NOREX]:
self.interpreter.relax_disp.insignificance(
level=self.insignificance)
# Speed-up grid-search by using minium R2eff value.
if self.set_grid_r20 and model != MODEL_R2EFF:
self.interpreter.relax_disp.r20_from_min_r2eff(force=True)
# Use pre-run results as the optimisation starting point.
# Test if file exists.
if self.pre_run_dir:
path = self.pre_run_dir + sep + model_path
# File path.
file_path = get_file_path('results', path)
# Test if the file exists and determine the compression type.
try:
compress_type, file_path = determine_compression(file_path)
res_file_exists = True
except RelaxFileError:
res_file_exists = False
if self.pre_run_dir and res_file_exists:
self.pre_run_parameters(model=model, model_path=model_path)
# Otherwise use the normal nesting check and grid search if not nested.
else:
# Nested model simplification.
nested = self.nesting(model=model)
# Otherwise use a grid search of default values to start optimisation with.
if not nested:
# Grid search.
if self.grid_inc:
self.interpreter.minimise.grid_search(inc=self.grid_inc)
# Default values.
else:
# The standard parameters.
for param in MODEL_PARAMS[model]:
self.interpreter.value.set(param=param, index=None)
# The optional R1 parameter.
if is_r1_optimised(model=model):
self.interpreter.value.set(param='r1', index=None)
# 'R2eff' model minimisation flags.
do_minimise = False
if model == MODEL_R2EFF:
# The constraints flag.
constraints = False
# The minimisation algorithm to use.
# Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used.
min_algor = 'Newton'
# Check if all spins contains 'r2eff and it associated error.
has_r2eff = False
# Loop over all spins.
for cur_spin, spin_id in spin_loop(return_id=True,
skip_desel=True):
# Check 'r2eff'
if hasattr(cur_spin, 'r2eff') and hasattr(
cur_spin, 'r2eff_err'):
has_r2eff = True
else:
has_r2eff = False
break
# Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised.
if has_r2eff and not self.optimise_r2eff:
pass
# Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised.
elif has_r2eff and self.optimise_r2eff:
do_minimise = True
# Optimise, if no R2eff and error is present.
elif not has_r2eff:
do_minimise = True
# Dispersion model minimisation flags.
else:
do_minimise = True
constraints = True
# The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used.
min_algor = 'simplex'
# Do the minimisation.
if do_minimise:
self.interpreter.minimise.execute(min_algor=min_algor,
func_tol=self.opt_func_tol,
max_iter=self.opt_max_iterations,
constraints=constraints)
# Model elimination.
if self.eliminate:
self.interpreter.eliminate()
# Monte Carlo simulations.
do_monte_carlo = False
if model == MODEL_R2EFF:
# The constraints flag.
constraints = False
# Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used.
min_algor = 'Newton'
# Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised.
if has_r2eff and not self.optimise_r2eff:
pass
# Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised.
elif has_r2eff and self.optimise_r2eff:
do_monte_carlo = True
# Optimise, if no R2eff and error is present.
elif not has_r2eff:
do_monte_carlo = True
elif self.mc_sim_all_models or len(self.models) < 2:
do_monte_carlo = True
# The constraints flag.
constraints = True
# The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used.
min_algor = 'simplex'
# Error estimation by Monte Carlo simulations.
if do_monte_carlo:
# Set the number of Monte-Carlo simulations.
monte_carlo_sim = self.mc_sim_num
# If the number for exponential curve fitting has been set.
if model == MODEL_R2EFF and self.exp_mc_sim_num != None:
monte_carlo_sim = self.exp_mc_sim_num
# When set to minus 1, estimation of the errors will be extracted from the covariance matrix.
# This is HIGHLY likely to be wrong, but can be used in an initial test fase.
if model == MODEL_R2EFF and self.exp_mc_sim_num == -1:
# Print
subsection(file=sys.stdout,
text="Estimating errors from Covariance matrix",
prespace=1)
# Raise warning.
text = 'Estimating errors from the Covariance matrix is highly likely to be "quite" wrong. Use only with extreme care, and for initial rapid testing of your data.'
warn(RelaxWarning(text))
# Estimate errors
self.interpreter.relax_disp.r2eff_err_estimate()
else:
self.interpreter.monte_carlo.setup(number=monte_carlo_sim)
self.interpreter.monte_carlo.create_data()
self.interpreter.monte_carlo.initial_values()
self.interpreter.minimise.execute(
min_algor=min_algor,
func_tol=self.opt_func_tol,
max_iter=self.opt_max_iterations,
constraints=constraints)
if self.eliminate:
self.interpreter.eliminate()
self.interpreter.monte_carlo.error_analysis()
def __init__(self, model=None):
"""Class for storing model information.
@keyword model: Current model
@type model: str
"""
# Save the info to variables.
self.model = model
# model description.
self.desc = deepcopy(MODEL_DESC[self.model])
# model equation type: analytic, silico or numeric.
self.eq = deepcopy(MODEL_EQ[self.model])
# The model experiment type.
self.exp_type = deepcopy(MODEL_EXP_TYPE[self.model])
# model parameters.
self.params = deepcopy(MODEL_PARAMS[self.model])
if is_r1_optimised(model=model) and 'r1' not in self.params:
self.params.insert(0, 'r1')
# model number of parameters.
self.params_nr = len(self.params)
# The number of chemical sites.
self.sites = deepcopy(MODEL_SITES[self.model])
# year where model was developed or published.
self.year = deepcopy(MODEL_YEAR[self.model])
# Ordered lists of models to nest from.
nest_list = deepcopy(MODEL_NEST[self.model])
# Remove the model itself from the list.
if nest_list == None:
self.nest_list = nest_list
else:
nest_list = list(filter(partial(ne, self.model), nest_list))
self.nest_list = nest_list
# Define the order of how exp type ranks.
order_exp_type = [
EXP_TYPE_R2EFF, EXP_TYPE_NOREX, EXP_TYPE_CPMG_SQ,
EXP_TYPE_CPMG_MMQ, EXP_TYPE_R1RHO
]
# Save the index of current model to order of equation type.
self.exp_type_i = order_exp_type.index(self.exp_type)
# Define the order of how equation type ranks.
order_eq = [EQ_NUMERIC, EQ_SILICO, EQ_ANALYTIC]
# Save the index of current model to order of equation type.
self.eq_i = order_eq.index(self.eq)
# Define the order of how equation type ranks, when sorting before auto analyses.
order_s = [EQ_SILICO, EQ_ANALYTIC, EQ_NUMERIC]
# Save the index of current model to order of equation type.
self.eq_s = order_s.index(self.eq)
# Save the difference in year from now, to implemented model.
self.year_diff = date.today().year - self.year
def __init__(self, spins=None, spin_ids=None, sim_index=None, scaling_matrix=None, min_algor=None, min_options=None, func_tol=None, grad_tol=None, max_iterations=None, constraints=False, verbosity=0, lower=None, upper=None, inc=None, fields=None, param_names=None):
"""Initialise the base class, storing all the master data to be sent to the slave processor.
This method is run on the master processor whereas the run() method is run on the slave processor.
@keyword spins: The list of spin data container for the cluster. If this argument is supplied, then the spin_id argument will be ignored.
@type spins: list of SpinContainer instances
@keyword spin_ids: The list of spin ID strings corresponding to the spins argument.
@type spin_ids: list of str
@keyword sim_index: The index of the simulation to optimise. This should be None if normal optimisation is desired.
@type sim_index: None or int
@keyword scaling_matrix: The diagonal, square scaling matrix.
@type scaling_matrix: numpy diagonal matrix
@keyword min_algor: The minimisation algorithm to use.
@type min_algor: str
@keyword min_options: An array of options to be used by the minimisation algorithm.
@type min_options: array of str
@keyword func_tol: The function tolerance which, when reached, terminates optimisation. Setting this to None turns of the check.
@type func_tol: None or float
@keyword grad_tol: The gradient tolerance which, when reached, terminates optimisation. Setting this to None turns of the check.
@type grad_tol: None or float
@keyword max_iterations: The maximum number of iterations for the algorithm.
@type max_iterations: int
@keyword constraints: If True, constraints are used during optimisation.
@type constraints: bool
@keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
@keyword lower: The lower bounds of the grid search which must be equal to the number of parameters in the model. This optional argument is only used when doing a grid search.
@type lower: array of numbers
@keyword upper: The upper bounds of the grid search which must be equal to the number of parameters in the model. This optional argument is only used when doing a grid search.
@type upper: array of numbers
@keyword inc: The increments for each dimension of the space for the grid search. The number of elements in the array must equal to the number of parameters in the model. This argument is only used when doing a grid search.
@type inc: array of int
@keyword fields: The list of unique of spectrometer field strengths.
@type fields: int
@keyword param_names: The list of parameter names to use in printouts.
@type param_names: str
"""
# Execute the base class __init__() method.
super(Disp_minimise_command, self).__init__()
# Store the arguments needed by the run() method.
self.spins = spins
self.spin_ids = spin_ids
self.sim_index = sim_index
self.scaling_matrix = scaling_matrix
self.verbosity = verbosity
self.min_algor = min_algor
self.min_options = min_options
self.func_tol = func_tol
self.grad_tol = grad_tol
self.max_iterations = max_iterations
self.lower = lower
self.upper = upper
self.inc = inc
self.fields = fields
self.param_names = param_names
# Create the initial parameter vector.
self.param_vector = assemble_param_vector(spins=self.spins)
if len(scaling_matrix):
self.param_vector = dot(inv(scaling_matrix), self.param_vector)
# Linear constraints.
self.A, self.b = None, None
if constraints:
self.A, self.b = linear_constraints(spins=spins, scaling_matrix=scaling_matrix)
# Test if the spectrometer frequencies have been set.
if spins[0].model in [MODEL_LM63, MODEL_CR72, MODEL_CR72_FULL, MODEL_M61, MODEL_TP02, MODEL_TAP03, MODEL_MP05] and not hasattr(cdp, 'spectrometer_frq'):
raise RelaxError("The spectrometer frequency information has not been specified.")
# The R2eff/R1rho data.
self.values, self.errors, self.missing, self.frqs, self.frqs_H, self.exp_types, self.relax_times = return_r2eff_arrays(spins=spins, spin_ids=spin_ids, fields=fields, field_count=len(fields), sim_index=sim_index)
# The offset and R1 data.
r1_setup()
self.offsets, spin_lock_fields_inter, self.chemical_shifts, self.tilt_angles, self.Delta_omega, self.w_eff = return_offset_data(spins=spins, spin_ids=spin_ids, field_count=len(fields))
self.r1 = return_r1_data(spins=spins, spin_ids=spin_ids, field_count=len(fields), sim_index=sim_index)
self.r1_fit = is_r1_optimised(spins[0].model)
# Parameter number.
self.param_num = param_num(spins=spins)
# The dispersion data.
self.dispersion_points = cdp.dispersion_points
self.cpmg_frqs = return_cpmg_frqs(ref_flag=False)
self.spin_lock_nu1 = return_spin_lock_nu1(ref_flag=False)
def back_calc_r2eff(spins=None, spin_ids=None, cpmg_frqs=None, spin_lock_offset=None, spin_lock_nu1=None, relax_times_new=None, store_chi2=False):
"""Back-calculation of R2eff/R1rho values for the given spin.
@keyword spins: The list of specific spin data container for cluster.
@type spins: List of SpinContainer instances
@keyword spin_ids: The list of spin ID strings for the spin containers in cluster.
@type spin_ids: list of str
@keyword cpmg_frqs: The CPMG frequencies to use instead of the user loaded values - to enable interpolation.
@type cpmg_frqs: list of lists of numpy rank-1 float arrays
@keyword spin_lock_offset: The spin-lock offsets to use instead of the user loaded values - to enable interpolation.
@type spin_lock_offset: list of lists of numpy rank-1 float arrays
@keyword spin_lock_nu1: The spin-lock field strengths to use instead of the user loaded values - to enable interpolation.
@type spin_lock_nu1: list of lists of numpy rank-1 float arrays
@keyword relax_times_new: The interpolated experiment specific fixed time period for relaxation (in seconds). The dimensions are {Ei, Mi, Oi, Di, Ti}.
@type relax_times_new: rank-4 list of floats
@keyword store_chi2: A flag which if True will cause the spin specific chi-squared value to be stored in the spin container.
@type store_chi2: bool
@return: The back-calculated R2eff/R1rho value for the given spin.
@rtype: numpy rank-1 float array
"""
# Create the initial parameter vector.
param_vector = assemble_param_vector(spins=spins)
# Number of spectrometer fields.
fields = [None]
field_count = 1
if hasattr(cdp, 'spectrometer_frq_count'):
fields = cdp.spectrometer_frq_list
field_count = cdp.spectrometer_frq_count
# Initialise the data structures for the target function.
values, errors, missing, frqs, frqs_H, exp_types, relax_times = return_r2eff_arrays(spins=spins, spin_ids=spin_ids, fields=fields, field_count=field_count)
# The offset and R1 data.
r1_setup()
offsets, spin_lock_fields_inter, chemical_shifts, tilt_angles, Delta_omega, w_eff = return_offset_data(spins=spins, spin_ids=spin_ids, field_count=field_count, spin_lock_offset=spin_lock_offset, fields=spin_lock_nu1)
r1 = return_r1_data(spins=spins, spin_ids=spin_ids, field_count=field_count)
r1_fit = is_r1_optimised(spins[0].model)
# The relaxation times.
if relax_times_new != None:
relax_times = relax_times_new
# The dispersion data.
recalc_tau = True
if cpmg_frqs == None and spin_lock_nu1 == None and spin_lock_offset == None:
cpmg_frqs = return_cpmg_frqs(ref_flag=False)
spin_lock_nu1 = return_spin_lock_nu1(ref_flag=False)
# Reset the cpmg_frqs if interpolating R1rho models.
elif cpmg_frqs == None and spin_lock_offset != None:
cpmg_frqs = None
spin_lock_nu1 = spin_lock_fields_inter
recalc_tau = False
values = []
errors = []
missing = []
for exp_type, ei in loop_exp(return_indices=True):
values.append([])
errors.append([])
missing.append([])
for si in range(len(spins)):
values[ei].append([])
errors[ei].append([])
missing[ei].append([])
for frq, mi in loop_frq(return_indices=True):
values[ei][si].append([])
errors[ei][si].append([])
missing[ei][si].append([])
for oi, offset in enumerate(offsets[ei][si][mi]):
num = len(spin_lock_nu1[ei][mi][oi])
values[ei][si][mi].append(zeros(num, float64))
errors[ei][si][mi].append(ones(num, float64))
missing[ei][si][mi].append(zeros(num, int32))
# Reconstruct the structures for interpolation.
else:
recalc_tau = False
values = []
errors = []
missing = []
for exp_type, ei in loop_exp(return_indices=True):
values.append([])
errors.append([])
missing.append([])
for si in range(len(spins)):
values[ei].append([])
errors[ei].append([])
missing[ei].append([])
for frq, mi in loop_frq(return_indices=True):
values[ei][si].append([])
errors[ei][si].append([])
missing[ei][si].append([])
for offset, oi in loop_offset(exp_type=exp_type, frq=frq, return_indices=True):
if exp_type in EXP_TYPE_LIST_CPMG:
num = len(cpmg_frqs[ei][mi][oi])
else:
num = len(spin_lock_nu1[ei][mi][oi])
values[ei][si][mi].append(zeros(num, float64))
errors[ei][si][mi].append(ones(num, float64))
missing[ei][si][mi].append(zeros(num, int32))
# Initialise the relaxation dispersion fit functions.
model = Dispersion(model=spins[0].model, num_params=param_num(spins=spins), num_spins=len(spins), num_frq=field_count, exp_types=exp_types, values=values, errors=errors, missing=missing, frqs=frqs, frqs_H=frqs_H, cpmg_frqs=cpmg_frqs, spin_lock_nu1=spin_lock_nu1, chemical_shifts=chemical_shifts, offset=offsets, tilt_angles=tilt_angles, r1=r1, relax_times=relax_times, recalc_tau=recalc_tau, r1_fit=r1_fit)
# Make a single function call. This will cause back calculation and the data will be stored in the class instance.
chi2 = model.func(param_vector)
# Store the chi-squared value.
if store_chi2:
for spin in spins:
spin.chi2 = chi2
# Return the structure.
return model.get_back_calc()
def __init__(self, spins=None, spin_ids=None, sim_index=None, scaling_matrix=None, min_algor=None, min_options=None, func_tol=None, grad_tol=None, max_iterations=None, constraints=False, verbosity=0, lower=None, upper=None, inc=None, fields=None, param_names=None):
"""Initialise the base class, storing all the master data to be sent to the slave processor.
This method is run on the master processor whereas the run() method is run on the slave processor.
@keyword spins: The list of spin data container for the cluster. If this argument is supplied, then the spin_id argument will be ignored.
@type spins: list of SpinContainer instances
@keyword spin_ids: The list of spin ID strings corresponding to the spins argument.
@type spin_ids: list of str
@keyword sim_index: The index of the simulation to optimise. This should be None if normal optimisation is desired.
@type sim_index: None or int
@keyword scaling_matrix: The diagonal, square scaling matrix.
@type scaling_matrix: numpy diagonal matrix
@keyword min_algor: The minimisation algorithm to use.
@type min_algor: str
@keyword min_options: An array of options to be used by the minimisation algorithm.
@type min_options: array of str
@keyword func_tol: The function tolerance which, when reached, terminates optimisation. Setting this to None turns of the check.
@type func_tol: None or float
@keyword grad_tol: The gradient tolerance which, when reached, terminates optimisation. Setting this to None turns of the check.
@type grad_tol: None or float
@keyword max_iterations: The maximum number of iterations for the algorithm.
@type max_iterations: int
@keyword constraints: If True, constraints are used during optimisation.
@type constraints: bool
@keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
@keyword lower: The lower bounds of the grid search which must be equal to the number of parameters in the model. This optional argument is only used when doing a grid search.
@type lower: array of numbers
@keyword upper: The upper bounds of the grid search which must be equal to the number of parameters in the model. This optional argument is only used when doing a grid search.
@type upper: array of numbers
@keyword inc: The increments for each dimension of the space for the grid search. The number of elements in the array must equal to the number of parameters in the model. This argument is only used when doing a grid search.
@type inc: array of int
@keyword fields: The list of unique of spectrometer field strengths.
@type fields: int
@keyword param_names: The list of parameter names to use in printouts.
@type param_names: str
"""
# Execute the base class __init__() method.
super(Disp_minimise_command, self).__init__()
# Store the arguments needed by the run() method.
self.spins = spins
self.spin_ids = spin_ids
self.sim_index = sim_index
self.scaling_matrix = scaling_matrix
self.verbosity = verbosity
self.min_algor = min_algor
self.min_options = min_options
self.func_tol = func_tol
self.grad_tol = grad_tol
self.max_iterations = max_iterations
self.lower = lower
self.upper = upper
self.inc = inc
self.fields = fields
self.param_names = param_names
# Create the initial parameter vector.
self.param_vector = assemble_param_vector(spins=self.spins)
if len(scaling_matrix):
self.param_vector = dot(inv(scaling_matrix), self.param_vector)
# Linear constraints.
self.A, self.b = None, None
if constraints:
self.A, self.b = linear_constraints(spins=spins, scaling_matrix=scaling_matrix)
# Test if the spectrometer frequencies have been set.
if spins[0].model in [MODEL_LM63, MODEL_CR72, MODEL_CR72_FULL, MODEL_M61, MODEL_TP02, MODEL_TAP03, MODEL_MP05] and not hasattr(cdp, 'spectrometer_frq'):
raise RelaxError("The spectrometer frequency information has not been specified.")
# The R2eff/R1rho data.
self.values, self.errors, self.missing, self.frqs, self.frqs_H, self.exp_types, self.relax_times = return_r2eff_arrays(spins=spins, spin_ids=spin_ids, fields=fields, field_count=len(fields), sim_index=sim_index)
# The offset and R1 data.
r1_setup()
self.offsets, spin_lock_fields_inter, self.chemical_shifts, self.tilt_angles, self.Delta_omega, self.w_eff = return_offset_data(spins=spins, spin_ids=spin_ids, field_count=len(fields))
self.r1 = return_r1_data(spins=spins, spin_ids=spin_ids, field_count=len(fields), sim_index=sim_index)
self.r1_fit = is_r1_optimised(spins[0].model)
# Parameter number.
self.param_num = param_num(spins=spins)
# The dispersion data.
self.dispersion_points = cdp.dispersion_points
self.cpmg_frqs = return_cpmg_frqs(ref_flag=False)
self.spin_lock_nu1 = return_spin_lock_nu1(ref_flag=False)
def back_calc_r2eff(spins=None, spin_ids=None, cpmg_frqs=None, spin_lock_offset=None, spin_lock_nu1=None, relax_times_new=None, store_chi2=False):
"""Back-calculation of R2eff/R1rho values for the given spin.
@keyword spins: The list of specific spin data container for cluster.
@type spins: List of SpinContainer instances
@keyword spin_ids: The list of spin ID strings for the spin containers in cluster.
@type spin_ids: list of str
@keyword cpmg_frqs: The CPMG frequencies to use instead of the user loaded values - to enable interpolation.
@type cpmg_frqs: list of lists of numpy rank-1 float arrays
@keyword spin_lock_offset: The spin-lock offsets to use instead of the user loaded values - to enable interpolation.
@type spin_lock_offset: list of lists of numpy rank-1 float arrays
@keyword spin_lock_nu1: The spin-lock field strengths to use instead of the user loaded values - to enable interpolation.
@type spin_lock_nu1: list of lists of numpy rank-1 float arrays
@keyword relax_times_new: The interpolated experiment specific fixed time period for relaxation (in seconds). The dimensions are {Ei, Mi, Oi, Di, Ti}.
@type relax_times_new: rank-4 list of floats
@keyword store_chi2: A flag which if True will cause the spin specific chi-squared value to be stored in the spin container.
@type store_chi2: bool
@return: The back-calculated R2eff/R1rho value for the given spin.
@rtype: numpy rank-1 float array
"""
# Create the initial parameter vector.
param_vector = assemble_param_vector(spins=spins)
# Number of spectrometer fields.
fields = [None]
field_count = 1
if hasattr(cdp, 'spectrometer_frq_count'):
fields = cdp.spectrometer_frq_list
field_count = cdp.spectrometer_frq_count
# Initialise the data structures for the target function.
values, errors, missing, frqs, frqs_H, exp_types, relax_times = return_r2eff_arrays(spins=spins, spin_ids=spin_ids, fields=fields, field_count=field_count)
# The offset and R1 data.
r1_setup()
offsets, spin_lock_fields_inter, chemical_shifts, tilt_angles, Delta_omega, w_eff = return_offset_data(spins=spins, spin_ids=spin_ids, field_count=field_count, spin_lock_offset=spin_lock_offset, fields=spin_lock_nu1)
r1 = return_r1_data(spins=spins, spin_ids=spin_ids, field_count=field_count)
r1_fit = is_r1_optimised(spins[0].model)
# The relaxation times.
if relax_times_new != None:
relax_times = relax_times_new
# The dispersion data.
recalc_tau = True
if cpmg_frqs == None and spin_lock_nu1 == None and spin_lock_offset == None:
cpmg_frqs = return_cpmg_frqs(ref_flag=False)
spin_lock_nu1 = return_spin_lock_nu1(ref_flag=False)
# Reset the cpmg_frqs if interpolating R1rho models.
elif cpmg_frqs == None and spin_lock_offset != None:
cpmg_frqs = None
spin_lock_nu1 = spin_lock_fields_inter
recalc_tau = False
values = []
errors = []
missing = []
for exp_type, ei in loop_exp(return_indices=True):
values.append([])
errors.append([])
missing.append([])
for si in range(len(spins)):
values[ei].append([])
errors[ei].append([])
missing[ei].append([])
for frq, mi in loop_frq(return_indices=True):
values[ei][si].append([])
errors[ei][si].append([])
missing[ei][si].append([])
for oi, offset in enumerate(offsets[ei][si][mi]):
num = len(spin_lock_nu1[ei][mi][oi])
values[ei][si][mi].append(zeros(num, float64))
errors[ei][si][mi].append(ones(num, float64))
missing[ei][si][mi].append(zeros(num, int32))
# Reconstruct the structures for interpolation.
else:
recalc_tau = False
values = []
errors = []
missing = []
for exp_type, ei in loop_exp(return_indices=True):
values.append([])
errors.append([])
missing.append([])
for si in range(len(spins)):
values[ei].append([])
errors[ei].append([])
missing[ei].append([])
for frq, mi in loop_frq(return_indices=True):
values[ei][si].append([])
errors[ei][si].append([])
missing[ei][si].append([])
for offset, oi in loop_offset(exp_type=exp_type, frq=frq, return_indices=True):
if exp_type in EXP_TYPE_LIST_CPMG:
num = len(cpmg_frqs[ei][mi][oi])
else:
num = len(spin_lock_nu1[ei][mi][oi])
values[ei][si][mi].append(zeros(num, float64))
errors[ei][si][mi].append(ones(num, float64))
missing[ei][si][mi].append(zeros(num, int32))
# Initialise the relaxation dispersion fit functions.
model = Dispersion(model=spins[0].model, num_params=param_num(spins=spins), num_spins=len(spins), num_frq=field_count, exp_types=exp_types, values=values, errors=errors, missing=missing, frqs=frqs, frqs_H=frqs_H, cpmg_frqs=cpmg_frqs, spin_lock_nu1=spin_lock_nu1, chemical_shifts=chemical_shifts, offset=offsets, tilt_angles=tilt_angles, r1=r1, relax_times=relax_times, recalc_tau=recalc_tau, r1_fit=r1_fit)
# Make a single function call. This will cause back calculation and the data will be stored in the class instance.
chi2 = model.func(param_vector)
# Store the chi-squared value.
if store_chi2:
for spin in spins:
spin.chi2 = chi2
# Return the structure.
return model.get_back_calc()
def __init__(self, model=None):
"""Class for storing model information.
@keyword model: Current model
@type model: str
"""
# Save the info to variables.
self.model = model
# model description.
self.desc = MODEL_DESC[self.model]
# model equation type: analytic, silico or numeric.
self.eq = MODEL_EQ[self.model]
# The model experiment type.
self.exp_type = MODEL_EXP_TYPE[self.model]
# model parameters.
self.params = MODEL_PARAMS[self.model]
if is_r1_optimised(model=model) and 'r1' not in self.params:
self.params.insert(0, 'r1')
# model number of parameters.
self.params_nr = len(self.params)
# The number of chemical sites.
self.sites = MODEL_SITES[self.model]
# year where model was developed or published.
self.year = MODEL_YEAR[self.model]
# Ordered lists of models to nest from.
nest_list = MODEL_NEST[self.model]
# Remove the model itself from the list.
if nest_list == None:
self.nest_list = nest_list
else:
nest_list = list(filter(partial(ne, self.model), nest_list))
self.nest_list = nest_list
# Define the order of how exp type ranks.
order_exp_type = [EXP_TYPE_R2EFF, EXP_TYPE_NOREX, EXP_TYPE_CPMG_SQ, EXP_TYPE_CPMG_MMQ, EXP_TYPE_R1RHO]
# Save the index of current model to order of equation type.
self.exp_type_i = order_exp_type.index(self.exp_type)
# Define the order of how equation type ranks.
order_eq = [EQ_NUMERIC, EQ_SILICO, EQ_ANALYTIC]
# Save the index of current model to order of equation type.
self.eq_i = order_eq.index(self.eq)
# Define the order of how equation type ranks, when sorting before auto analyses.
order_s = [EQ_SILICO, EQ_ANALYTIC, EQ_NUMERIC]
# Save the index of current model to order of equation type.
self.eq_s = order_s.index(self.eq)
# Save the difference in year from now, to implemented model.
self.year_diff = date.today().year - self.year
def optimise(self, model=None, model_path=None):
"""Optimise the model, taking model nesting into account.
@keyword model: The model to be optimised.
@type model: str
@keyword model_path: The folder name for the model, where possible spaces has been replaced with underscore.
@type model_path: str
"""
# Printout.
section(file=sys.stdout, text="Optimisation", prespace=2)
# Deselect insignificant spins.
if model not in [MODEL_R2EFF, MODEL_NOREX]:
self.interpreter.relax_disp.insignificance(level=self.insignificance)
# Speed-up grid-search by using minium R2eff value.
if self.set_grid_r20 and model != MODEL_R2EFF:
self.interpreter.relax_disp.r20_from_min_r2eff(force=True)
# Use pre-run results as the optimisation starting point.
# Test if file exists.
if self.pre_run_dir:
path = self.pre_run_dir + sep + model_path
# File path.
file_path = get_file_path('results', path)
# Test if the file exists and determine the compression type.
try:
compress_type, file_path = determine_compression(file_path)
res_file_exists = True
except RelaxFileError:
res_file_exists = False
if self.pre_run_dir and res_file_exists:
self.pre_run_parameters(model=model, model_path=model_path)
# Otherwise use the normal nesting check and grid search if not nested.
else:
# Nested model simplification.
nested = self.nesting(model=model)
# Otherwise use a grid search of default values to start optimisation with.
if not nested:
# Grid search.
if self.grid_inc:
self.interpreter.minimise.grid_search(inc=self.grid_inc)
# Default values.
else:
# The standard parameters.
for param in MODEL_PARAMS[model]:
self.interpreter.value.set(param=param, index=None)
# The optional R1 parameter.
if is_r1_optimised(model=model):
self.interpreter.value.set(param='r1', index=None)
# 'R2eff' model minimisation flags.
do_minimise = False
if model == MODEL_R2EFF:
# The constraints flag.
constraints = False
# The minimisation algorithm to use.
# Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used.
min_algor = 'Newton'
# Check if all spins contains 'r2eff and it associated error.
has_r2eff = False
# Loop over all spins.
for cur_spin, spin_id in spin_loop(return_id=True, skip_desel=True):
# Check 'r2eff'
if hasattr(cur_spin, 'r2eff') and hasattr(cur_spin, 'r2eff_err'):
has_r2eff = True
else:
has_r2eff = False
break
# Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised.
if has_r2eff and not self.optimise_r2eff:
pass
# Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised.
elif has_r2eff and self.optimise_r2eff:
do_minimise = True
# Optimise, if no R2eff and error is present.
elif not has_r2eff:
do_minimise = True
# Dispersion model minimisation flags.
else:
do_minimise = True
constraints = True
# The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used.
min_algor = 'simplex'
# Do the minimisation.
if do_minimise:
self.interpreter.minimise.execute(min_algor=min_algor, func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=constraints)
# Model elimination.
if self.eliminate:
self.interpreter.eliminate()
# Monte Carlo simulations.
do_monte_carlo = False
if model == MODEL_R2EFF:
# The constraints flag.
constraints = False
# Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used.
min_algor = 'Newton'
# Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised.
if has_r2eff and not self.optimise_r2eff:
pass
# Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised.
elif has_r2eff and self.optimise_r2eff:
do_monte_carlo = True
# Optimise, if no R2eff and error is present.
elif not has_r2eff:
do_monte_carlo = True
elif self.mc_sim_all_models or len(self.models) < 2:
do_monte_carlo = True
# The constraints flag.
constraints = True
# The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used.
min_algor = 'simplex'
# Error estimation by Monte Carlo simulations.
if do_monte_carlo:
# Set the number of Monte-Carlo simulations.
monte_carlo_sim = self.mc_sim_num
# If the number for exponential curve fitting has been set.
if model == MODEL_R2EFF and self.exp_mc_sim_num != None:
monte_carlo_sim = self.exp_mc_sim_num
# When set to minus 1, estimation of the errors will be extracted from the covariance matrix.
# This is HIGHLY likely to be wrong, but can be used in an initial test fase.
if model == MODEL_R2EFF and self.exp_mc_sim_num == -1:
# Print
subsection(file=sys.stdout, text="Estimating errors from Covariance matrix", prespace=1)
# Raise warning.
text = 'Estimating errors from the Covariance matrix is highly likely to be "quite" wrong. Use only with extreme care, and for initial rapid testing of your data.'
warn(RelaxWarning(text))
# Estimate errors
self.interpreter.relax_disp.r2eff_err_estimate()
else:
self.interpreter.monte_carlo.setup(number=monte_carlo_sim)
self.interpreter.monte_carlo.create_data()
self.interpreter.monte_carlo.initial_values()
self.interpreter.minimise.execute(min_algor=min_algor, func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=constraints)
if self.eliminate:
self.interpreter.eliminate()
self.interpreter.monte_carlo.error_analysis()
