def catia_input(file='Fit.catia', dir=None, output_dir='output', force=False):
"""Create the CATIA input files.
@keyword file: The main CATIA execution file.
@type file: str
@keyword dir: The optional directory to place the files into. If None, then the files will be placed into the current directory.
@type dir: str or None
@keyword output_dir: The CATIA output directory, located within the directory specified by the dir argument. This directory will be created.
@type output_dir: str
@keyword force: A flag which if True will cause all pre-existing files to be overwritten.
@type force: Bool
"""
# Data checks.
check_pipe()
check_mol_res_spin_data()
check_spectra_id_setup()
check_model_type()
# Check that this is CPMG data.
for id in cdp.spectrum_ids:
if cdp.exp_type[id] != 'SQ CPMG':
raise RelaxError("Only CPMG type data is supported.")
# Directory creation.
if dir != None:
mkdir_nofail(dir, verbosity=0)
# Create the R2eff files.
write_r2eff_files(input_dir='input_r2eff', base_dir=dir, force=force)
# Create the parameter files.
write_param_files(global_file="ParamGlobal.inp",
set_file="ParamSet1.inp",
dir=dir,
force=force)
# Create the main execution file.
write_main_file(file=file, dir=dir, output_dir=output_dir, force=force)
# Create the output directory as needed by CATIA (it does not create it itself).
mkdir_nofail(dir + sep + output_dir, verbosity=0)
def catia_input(file='Fit.catia', dir=None, output_dir='output', force=False):
"""Create the CATIA input files.
@keyword file: The main CATIA execution file.
@type file: str
@keyword dir: The optional directory to place the files into. If None, then the files will be placed into the current directory.
@type dir: str or None
@keyword output_dir: The CATIA output directory, located within the directory specified by the dir argument. This directory will be created.
@type output_dir: str
@keyword force: A flag which if True will cause all pre-existing files to be overwritten.
@type force: Bool
"""
# Data checks.
pipes.test()
check_mol_res_spin_data()
check_spectra_id_setup()
check_model_type()
# Check that this is CPMG data.
for id in cdp.spectrum_ids:
if cdp.exp_type[id] != 'SQ CPMG':
raise RelaxError("Only CPMG type data is supported.")
# Directory creation.
if dir != None:
mkdir_nofail(dir, verbosity=0)
# Create the R2eff files.
write_r2eff_files(input_dir='input_r2eff', base_dir=dir, force=force)
# Create the parameter files.
write_param_files(global_file="ParamGlobal.inp", set_file="ParamSet1.inp", dir=dir, force=force)
# Create the main execution file.
write_main_file(file=file, dir=dir, output_dir=output_dir, force=force)
# Create the output directory as needed by CATIA (it does not create it itself).
mkdir_nofail(dir + sep + output_dir, verbosity=0)
def estimate_r2eff(method='minfx',
min_algor='simplex',
c_code=True,
constraints=False,
chi2_jacobian=False,
spin_id=None,
ftol=1e-15,
xtol=1e-15,
maxfev=10000000,
factor=100.0,
verbosity=1):
"""Estimate r2eff and errors by exponential curve fitting with scipy.optimize.leastsq or minfx.
THIS IS ONLY FOR TESTING.
scipy.optimize.leastsq is a wrapper around MINPACK's lmdif and lmder algorithms.
MINPACK is a FORTRAN90 library which solves systems of nonlinear equations, or carries out the least squares minimization of the residual of a set of linear or nonlinear equations.
Errors are calculated by taking the square root of the reported co-variance.
This can be an huge time saving step, when performing model fitting in R1rho.
Errors of R2eff values, are normally estimated by time-consuming Monte-Carlo simulations.
Initial guess for the starting parameter x0 = [r2eff_est, i0_est], is by converting the exponential curve to a linear problem.
Then solving initial guess by linear least squares of: ln(Intensity[j]) = ln(i0) - time[j]* r2eff.
@keyword method: The method to minimise and estimate errors. Options are: 'minfx' or 'scipy.optimize.leastsq'.
@type method: string
@keyword min_algor: The minimisation algorithm
@type min_algor: string
@keyword c_code: If optimise with C code.
@type c_code: bool
@keyword constraints: If constraints should be used.
@type constraints: bool
@keyword chi2_jacobian: If the chi2 Jacobian should be used.
@type chi2_jacobian: bool
@keyword spin_id: The spin identification string.
@type spin_id: str
@keyword ftol: The function tolerance for the relative error desired in the sum of squares, parsed to leastsq.
@type ftol: float
@keyword xtol: The error tolerance for the relative error desired in the approximate solution, parsed to leastsq.
@type xtol: float
@keyword maxfev: The maximum number of function evaluations, parsed to leastsq. If zero, then 100*(N+1) is the maximum function calls. N is the number of elements in x0=[r2eff, i0].
@type maxfev: int
@keyword factor: The initial step bound, parsed to leastsq. It determines the initial step bound (''factor * || diag * x||''). Should be in the interval (0.1, 100).
@type factor: float
@keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
"""
# Perform checks.
check_model_type(model=MODEL_R2EFF)
# Check that the C modules have been compiled.
if not C_module_exp_fn and method == 'minfx':
raise RelaxError(
"Relaxation curve fitting is not available. Try compiling the C modules on your platform."
)
# Set class scipy setting.
E = Exp(verbosity=verbosity)
E.set_settings_leastsq(ftol=ftol, xtol=xtol, maxfev=maxfev, factor=factor)
# Check if intensity errors have already been calculated by the user.
precalc = True
for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(
selection=spin_id, full_info=True, return_id=True,
skip_desel=True):
# No structure.
if not hasattr(cur_spin, 'peak_intensity_err'):
precalc = False
break
# Determine if a spectrum ID is missing from the list.
for id in cdp.spectrum_ids:
if id not in cur_spin.peak_intensity_err:
precalc = False
break
# Loop over the spins.
for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(
selection=spin_id, full_info=True, return_id=True,
skip_desel=True):
# Generate spin string.
spin_string = generate_spin_string(spin=cur_spin,
mol_name=mol_name,
res_num=resi,
res_name=resn)
# Print information.
if E.verbosity >= 1:
# Individual spin block section.
top = 2
if E.verbosity >= 2:
top += 2
subsection(file=sys.stdout,
text="Fitting with %s to: %s" % (method, spin_string),
prespace=top)
if method == 'minfx':
subsection(
file=sys.stdout,
text=
"min_algor='%s', c_code=%s, constraints=%s, chi2_jacobian?=%s"
% (min_algor, c_code, constraints, chi2_jacobian),
prespace=0)
# Loop over each spectrometer frequency and dispersion point.
for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point(
return_indices=True):
# The parameter key.
param_key = return_param_key_from_data(exp_type=exp_type,
frq=frq,
offset=offset,
point=point)
# The peak intensities, errors and times.
values = []
errors = []
times = []
for time in loop_time(exp_type=exp_type,
frq=frq,
offset=offset,
point=point):
values.append(
average_intensity(spin=cur_spin,
exp_type=exp_type,
frq=frq,
offset=offset,
point=point,
time=time))
errors.append(
average_intensity(spin=cur_spin,
exp_type=exp_type,
frq=frq,
offset=offset,
point=point,
time=time,
error=True))
times.append(time)
# Convert to numpy array.
values = asarray(values)
errors = asarray(errors)
times = asarray(times)
# Initialise data.
E.setup_data(values=values, errors=errors, times=times)
# Get the result based on method.
if method == 'scipy.optimize.leastsq':
# Acquire results.
results = minimise_leastsq(E=E)
elif method == 'minfx':
# Set settings.
E.set_settings_minfx(min_algor=min_algor,
c_code=c_code,
chi2_jacobian=chi2_jacobian,
constraints=constraints)
# Acquire results.
results = minimise_minfx(E=E)
else:
raise RelaxError(
"Method for minimisation not known. Try setting: method='scipy.optimize.leastsq'."
)
# Unpack results
param_vector, param_vector_error, chi2, iter_count, f_count, g_count, h_count, warning = results
# Extract values.
r2eff = param_vector[0]
i0 = param_vector[1]
r2eff_err = param_vector_error[0]
i0_err = param_vector_error[1]
# Disassemble the parameter vector.
disassemble_param_vector(param_vector=param_vector,
spins=[cur_spin],
key=param_key)
# Errors.
if not hasattr(cur_spin, 'r2eff_err'):
setattr(cur_spin, 'r2eff_err',
deepcopy(getattr(cur_spin, 'r2eff')))
if not hasattr(cur_spin, 'i0_err'):
setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0')))
# Set error.
cur_spin.r2eff_err[param_key] = r2eff_err
cur_spin.i0_err[param_key] = i0_err
# Chi-squared statistic.
cur_spin.chi2 = chi2
# Iterations.
cur_spin.f_count = f_count
# Warning.
cur_spin.warning = warning
# Print information.
print_strings = []
if E.verbosity >= 1:
# Add print strings.
point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % (
exp_type, frq / 1E6, offset, point, len(times))
print_strings.append(point_info)
par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % (
r2eff, r2eff_err, i0, i0_err, chi2)
print_strings.append(par_info)
if E.verbosity >= 2:
time_info = ', '.join(map(str, times))
print_strings.append('For time array: ' + time_info +
'.\n\n')
# Print info
if len(print_strings) > 0:
for print_string in print_strings:
print(print_string),
def estimate_r2eff_err(spin_id=None, epsrel=0.0, verbosity=1):
"""This will estimate the R2eff and i0 errors from the covariance matrix Qxx. Qxx is calculated from the Jacobian matrix and the optimised parameters.
@keyword spin_id: The spin identification string.
@type spin_id: str
@param epsrel: Any columns of R which satisfy |R_{kk}| <= epsrel |R_{11}| are considered linearly-dependent and are excluded from the covariance matrix, where the corresponding rows and columns of the covariance matrix are set to zero.
@type epsrel: float
@keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
"""
# Check that the C modules have been compiled.
if not C_module_exp_fn:
raise RelaxError(
"Relaxation curve fitting is not available. Try compiling the C modules on your platform."
)
# Perform checks.
check_model_type(model=MODEL_R2EFF)
# Loop over the spins.
for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(
selection=spin_id, full_info=True, return_id=True,
skip_desel=True):
# Generate spin string.
spin_string = generate_spin_string(spin=cur_spin,
mol_name=mol_name,
res_num=resi,
res_name=resn)
# Raise Error, if not optimised.
if not (hasattr(cur_spin, 'r2eff') and hasattr(cur_spin, 'i0')):
raise RelaxError(
"Spin %s does not contain optimised 'r2eff' and 'i0' values. Try execute: minimise.execute(min_algor='Newton', constraints=False)"
% (spin_string))
# Raise warning, if gradient count is 0. This could point to a lack of minimisation first.
if hasattr(cur_spin, 'g_count'):
if getattr(cur_spin, 'g_count') == 0.0:
text = "Spin %s contains a gradient count of 0.0. Is the R2eff parameter optimised? Try execute: minimise.execute(min_algor='Newton', constraints=False)" % (
spin_string)
warn(RelaxWarning("%s." % text))
# Print information.
if verbosity >= 1:
# Individual spin block section.
top = 2
if verbosity >= 2:
top += 2
subsection(file=sys.stdout,
text="Estimating R2eff error for spin: %s" %
spin_string,
prespace=top)
# Loop over each spectrometer frequency and dispersion point.
for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point(
return_indices=True):
# The parameter key.
param_key = return_param_key_from_data(exp_type=exp_type,
frq=frq,
offset=offset,
point=point)
# Extract values.
r2eff = getattr(cur_spin, 'r2eff')[param_key]
i0 = getattr(cur_spin, 'i0')[param_key]
# Pack data
param_vector = [r2eff, i0]
# The peak intensities, errors and times.
values = []
errors = []
times = []
for time in loop_time(exp_type=exp_type,
frq=frq,
offset=offset,
point=point):
values.append(
average_intensity(spin=cur_spin,
exp_type=exp_type,
frq=frq,
offset=offset,
point=point,
time=time))
errors.append(
average_intensity(spin=cur_spin,
exp_type=exp_type,
frq=frq,
offset=offset,
point=point,
time=time,
error=True))
times.append(time)
# Convert to numpy array.
values = asarray(values)
errors = asarray(errors)
times = asarray(times)
# Initialise data in C code.
scaling_list = [1.0, 1.0]
model = Relax_fit_opt(model='exp',
num_params=len(param_vector),
values=values,
errors=errors,
relax_times=times,
scaling_matrix=scaling_list)
# Use the direct Jacobian from function.
jacobian_matrix_exp = transpose(
asarray(model.jacobian(param_vector)))
weights = 1. / errors**2
# Get the co-variance
pcov = multifit_covar(J=jacobian_matrix_exp, weights=weights)
# To compute one standard deviation errors on the parameters, take the square root of the diagonal covariance.
param_vector_error = sqrt(diag(pcov))
# Extract values.
r2eff_err, i0_err = param_vector_error
# Copy r2eff dictionary, to r2eff_err dictionary. They have same keys to the dictionary,
if not hasattr(cur_spin, 'r2eff_err'):
setattr(cur_spin, 'r2eff_err',
deepcopy(getattr(cur_spin, 'r2eff')))
if not hasattr(cur_spin, 'i0_err'):
setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0')))
# Set error.
cur_spin.r2eff_err[param_key] = r2eff_err
cur_spin.i0_err[param_key] = i0_err
# Get other relevant information.
chi2 = getattr(cur_spin, 'chi2')
# Print information.
print_strings = []
if verbosity >= 1:
# Add print strings.
point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % (
exp_type, frq / 1E6, offset, point, len(times))
print_strings.append(point_info)
par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % (
r2eff, r2eff_err, i0, i0_err, chi2)
print_strings.append(par_info)
if verbosity >= 2:
time_info = ', '.join(map(str, times))
print_strings.append('For time array: ' + time_info +
'.\n\n')
# Print info
if len(print_strings) > 0:
for print_string in print_strings:
print(print_string),
def estimate_r2eff_err(spin_id=None, epsrel=0.0, verbosity=1):
"""This will estimate the R2eff and i0 errors from the covariance matrix Qxx. Qxx is calculated from the Jacobian matrix and the optimised parameters.
@keyword spin_id: The spin identification string.
@type spin_id: str
@param epsrel: Any columns of R which satisfy |R_{kk}| <= epsrel |R_{11}| are considered linearly-dependent and are excluded from the covariance matrix, where the corresponding rows and columns of the covariance matrix are set to zero.
@type epsrel: float
@keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
"""
# Check that the C modules have been compiled.
if not C_module_exp_fn:
raise RelaxError("Relaxation curve fitting is not available. Try compiling the C modules on your platform.")
# Perform checks.
check_model_type(model=MODEL_R2EFF)
# Loop over the spins.
for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(selection=spin_id, full_info=True, return_id=True, skip_desel=True):
# Generate spin string.
spin_string = generate_spin_string(spin=cur_spin, mol_name=mol_name, res_num=resi, res_name=resn)
# Raise Error, if not optimised.
if not (hasattr(cur_spin, 'r2eff') and hasattr(cur_spin, 'i0')):
raise RelaxError("Spin %s does not contain optimised 'r2eff' and 'i0' values. Try execute: minimise.execute(min_algor='Newton', constraints=False)"%(spin_string))
# Raise warning, if gradient count is 0. This could point to a lack of minimisation first.
if hasattr(cur_spin, 'g_count'):
if getattr(cur_spin, 'g_count') == 0.0:
text = "Spin %s contains a gradient count of 0.0. Is the R2eff parameter optimised? Try execute: minimise.execute(min_algor='Newton', constraints=False)" %(spin_string)
warn(RelaxWarning("%s." % text))
# Print information.
if verbosity >= 1:
# Individual spin block section.
top = 2
if verbosity >= 2:
top += 2
subsection(file=sys.stdout, text="Estimating R2eff error for spin: %s"%spin_string, prespace=top)
# Loop over each spectrometer frequency and dispersion point.
for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point(return_indices=True):
# The parameter key.
param_key = return_param_key_from_data(exp_type=exp_type, frq=frq, offset=offset, point=point)
# Extract values.
r2eff = getattr(cur_spin, 'r2eff')[param_key]
i0 = getattr(cur_spin, 'i0')[param_key]
# Pack data
param_vector = [r2eff, i0]
# The peak intensities, errors and times.
values = []
errors = []
times = []
for time in loop_time(exp_type=exp_type, frq=frq, offset=offset, point=point):
values.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time))
errors.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time, error=True))
times.append(time)
# Convert to numpy array.
values = asarray(values)
errors = asarray(errors)
times = asarray(times)
# Initialise data in C code.
scaling_list = [1.0, 1.0]
model = Relax_fit_opt(model='exp', num_params=len(param_vector), values=values, errors=errors, relax_times=times, scaling_matrix=scaling_list)
# Use the direct Jacobian from function.
jacobian_matrix_exp = transpose(asarray( model.jacobian(param_vector) ) )
weights = 1. / errors**2
# Get the co-variance
pcov = multifit_covar(J=jacobian_matrix_exp, weights=weights)
# To compute one standard deviation errors on the parameters, take the square root of the diagonal covariance.
param_vector_error = sqrt(diag(pcov))
# Extract values.
r2eff_err, i0_err = param_vector_error
# Copy r2eff dictionary, to r2eff_err dictionary. They have same keys to the dictionary,
if not hasattr(cur_spin, 'r2eff_err'):
setattr(cur_spin, 'r2eff_err', deepcopy(getattr(cur_spin, 'r2eff')))
if not hasattr(cur_spin, 'i0_err'):
setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0')))
# Set error.
cur_spin.r2eff_err[param_key] = r2eff_err
cur_spin.i0_err[param_key] = i0_err
# Get other relevant information.
chi2 = getattr(cur_spin, 'chi2')
# Print information.
print_strings = []
if verbosity >= 1:
# Add print strings.
point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % (exp_type, frq/1E6, offset, point, len(times))
print_strings.append(point_info)
par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % ( r2eff, r2eff_err, i0, i0_err, chi2)
print_strings.append(par_info)
if verbosity >= 2:
time_info = ', '.join(map(str, times))
print_strings.append('For time array: '+time_info+'.\n\n')
# Print info
if len(print_strings) > 0:
for print_string in print_strings:
print(print_string),
def estimate_r2eff(method='minfx', min_algor='simplex', c_code=True, constraints=False, chi2_jacobian=False, spin_id=None, ftol=1e-15, xtol=1e-15, maxfev=10000000, factor=100.0, verbosity=1):
"""Estimate r2eff and errors by exponential curve fitting with scipy.optimize.leastsq or minfx.
THIS IS ONLY FOR TESTING.
scipy.optimize.leastsq is a wrapper around MINPACK's lmdif and lmder algorithms.
MINPACK is a FORTRAN90 library which solves systems of nonlinear equations, or carries out the least squares minimization of the residual of a set of linear or nonlinear equations.
Errors are calculated by taking the square root of the reported co-variance.
This can be an huge time saving step, when performing model fitting in R1rho.
Errors of R2eff values, are normally estimated by time-consuming Monte-Carlo simulations.
Initial guess for the starting parameter x0 = [r2eff_est, i0_est], is by converting the exponential curve to a linear problem.
Then solving initial guess by linear least squares of: ln(Intensity[j]) = ln(i0) - time[j]* r2eff.
@keyword method: The method to minimise and estimate errors. Options are: 'minfx' or 'scipy.optimize.leastsq'.
@type method: string
@keyword min_algor: The minimisation algorithm
@type min_algor: string
@keyword c_code: If optimise with C code.
@type c_code: bool
@keyword constraints: If constraints should be used.
@type constraints: bool
@keyword chi2_jacobian: If the chi2 Jacobian should be used.
@type chi2_jacobian: bool
@keyword spin_id: The spin identification string.
@type spin_id: str
@keyword ftol: The function tolerance for the relative error desired in the sum of squares, parsed to leastsq.
@type ftol: float
@keyword xtol: The error tolerance for the relative error desired in the approximate solution, parsed to leastsq.
@type xtol: float
@keyword maxfev: The maximum number of function evaluations, parsed to leastsq. If zero, then 100*(N+1) is the maximum function calls. N is the number of elements in x0=[r2eff, i0].
@type maxfev: int
@keyword factor: The initial step bound, parsed to leastsq. It determines the initial step bound (''factor * || diag * x||''). Should be in the interval (0.1, 100).
@type factor: float
@keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
"""
# Perform checks.
check_model_type(model=MODEL_R2EFF)
# Check that the C modules have been compiled.
if not C_module_exp_fn and method == 'minfx':
raise RelaxError("Relaxation curve fitting is not available. Try compiling the C modules on your platform.")
# Set class scipy setting.
E = Exp(verbosity=verbosity)
E.set_settings_leastsq(ftol=ftol, xtol=xtol, maxfev=maxfev, factor=factor)
# Check if intensity errors have already been calculated by the user.
precalc = True
for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(selection=spin_id, full_info=True, return_id=True, skip_desel=True):
# No structure.
if not hasattr(cur_spin, 'peak_intensity_err'):
precalc = False
break
# Determine if a spectrum ID is missing from the list.
for id in cdp.spectrum_ids:
if id not in cur_spin.peak_intensity_err:
precalc = False
break
# Loop over the spins.
for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(selection=spin_id, full_info=True, return_id=True, skip_desel=True):
# Generate spin string.
spin_string = generate_spin_string(spin=cur_spin, mol_name=mol_name, res_num=resi, res_name=resn)
# Print information.
if E.verbosity >= 1:
# Individual spin block section.
top = 2
if E.verbosity >= 2:
top += 2
subsection(file=sys.stdout, text="Fitting with %s to: %s"%(method, spin_string), prespace=top)
if method == 'minfx':
subsection(file=sys.stdout, text="min_algor='%s', c_code=%s, constraints=%s, chi2_jacobian?=%s"%(min_algor, c_code, constraints, chi2_jacobian), prespace=0)
# Loop over each spectrometer frequency and dispersion point.
for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point(return_indices=True):
# The parameter key.
param_key = return_param_key_from_data(exp_type=exp_type, frq=frq, offset=offset, point=point)
# The peak intensities, errors and times.
values = []
errors = []
times = []
for time in loop_time(exp_type=exp_type, frq=frq, offset=offset, point=point):
values.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time))
errors.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time, error=True))
times.append(time)
# Convert to numpy array.
values = asarray(values)
errors = asarray(errors)
times = asarray(times)
# Initialise data.
E.setup_data(values=values, errors=errors, times=times)
# Get the result based on method.
if method == 'scipy.optimize.leastsq':
# Acquire results.
results = minimise_leastsq(E=E)
elif method == 'minfx':
# Set settings.
E.set_settings_minfx(min_algor=min_algor, c_code=c_code, chi2_jacobian=chi2_jacobian, constraints=constraints)
# Acquire results.
results = minimise_minfx(E=E)
else:
raise RelaxError("Method for minimisation not known. Try setting: method='scipy.optimize.leastsq'.")
# Unpack results
param_vector, param_vector_error, chi2, iter_count, f_count, g_count, h_count, warning = results
# Extract values.
r2eff = param_vector[0]
i0 = param_vector[1]
r2eff_err = param_vector_error[0]
i0_err = param_vector_error[1]
# Disassemble the parameter vector.
disassemble_param_vector(param_vector=param_vector, spins=[cur_spin], key=param_key)
# Errors.
if not hasattr(cur_spin, 'r2eff_err'):
setattr(cur_spin, 'r2eff_err', deepcopy(getattr(cur_spin, 'r2eff')))
if not hasattr(cur_spin, 'i0_err'):
setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0')))
# Set error.
cur_spin.r2eff_err[param_key] = r2eff_err
cur_spin.i0_err[param_key] = i0_err
# Chi-squared statistic.
cur_spin.chi2 = chi2
# Iterations.
cur_spin.f_count = f_count
# Warning.
cur_spin.warning = warning
# Print information.
print_strings = []
if E.verbosity >= 1:
# Add print strings.
point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % (exp_type, frq/1E6, offset, point, len(times))
print_strings.append(point_info)
par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % ( r2eff, r2eff_err, i0, i0_err, chi2)
print_strings.append(par_info)
if E.verbosity >= 2:
time_info = ', '.join(map(str, times))
print_strings.append('For time array: '+time_info+'.\n\n')
# Print info
if len(print_strings) > 0:
for print_string in print_strings:
print(print_string),
