def get_param_names(self, model_info=None):
"""Return a vector of parameter names.
@keyword model_info: The model information from model_loop(). This is unused.
@type model_info: None
@return: The vector of parameter names.
@rtype: list of str
"""
# Init.
param_names = []
# A RDC or PCS data type requires the alignment tensors to be at the start of the parameter vector (unless the tensors are fixed).
if opt_uses_align_data():
for i in range(len(cdp.align_tensors)):
# Skip non-optimised tensors.
if not opt_uses_tensor(cdp.align_tensors[i]):
continue
# Add the parameters.
param_names += ['Axx', 'Ayy', 'Axy', 'Axz', 'Ayz']
# Populations.
if cdp.model in ['2-domain', 'population']:
for i in range(cdp.N - 1):
param_names.append('probs')
# The Euler angles.
if cdp.model == '2-domain':
for i in range(cdp.N):
param_names.append('alpha')
param_names.append('beta')
param_names.append('gamma')
# The paramagnetic centre.
if hasattr(cdp,
'paramag_centre_fixed') and not cdp.paramag_centre_fixed:
for i in range(3):
param_names.append('paramagnetic_centre')
# Return the list.
return param_names
def get_param_names(self, model_info=None):
"""Return a vector of parameter names.
@keyword model_info: The model information from model_loop(). This is unused.
@type model_info: None
@return: The vector of parameter names.
@rtype: list of str
"""
# Init.
param_names = []
# A RDC or PCS data type requires the alignment tensors to be at the start of the parameter vector (unless the tensors are fixed).
if opt_uses_align_data():
for i in range(len(cdp.align_tensors)):
# Skip non-optimised tensors.
if not opt_uses_tensor(cdp.align_tensors[i]):
continue
# Add the parameters.
param_names += ['Axx', 'Ayy', 'Axy', 'Axz', 'Ayz']
# Populations.
if cdp.model in ['2-domain', 'population']:
for i in range(cdp.N - 1):
param_names.append('probs')
# The Euler angles.
if cdp.model == '2-domain':
for i in range(cdp.N):
param_names.append('alpha')
param_names.append('beta')
param_names.append('gamma')
# The paramagnetic centre.
if hasattr(cdp, 'paramag_centre_fixed') and not cdp.paramag_centre_fixed:
for i in range(3):
param_names.append('paramagnetic_centre')
# Return the list.
return param_names
def minimise_setup_fixed_tensors():
"""Set up the data structures for the fixed alignment tensors.
@return: The assembled data structures for the fixed alignment tensors.
@rtype: numpy rank-1 array.
"""
# Initialise.
n = align_tensor.num_tensors(skip_fixed=False) - align_tensor.num_tensors(
skip_fixed=True)
tensors = zeros(n * 5, float64)
# Nothing to do.
if n == 0:
return None
# Loop over the tensors.
index = 0
for i in range(len(cdp.align_tensors)):
# Skip non-optimised data.
if not opt_uses_align_data(cdp.align_tensors[i].name):
continue
# No parameters have been set.
if not hasattr(cdp.align_tensors[i], 'Axx'):
continue
# The real tensors.
tensors[5 * index + 0] = cdp.align_tensors[i].Axx
tensors[5 * index + 1] = cdp.align_tensors[i].Ayy
tensors[5 * index + 2] = cdp.align_tensors[i].Axy
tensors[5 * index + 3] = cdp.align_tensors[i].Axz
tensors[5 * index + 4] = cdp.align_tensors[i].Ayz
# Increment the index.
index += 1
# Return the data structure.
return tensors
def minimise_setup_fixed_tensors():
"""Set up the data structures for the fixed alignment tensors.
@return: The assembled data structures for the fixed alignment tensors.
@rtype: numpy rank-1 array.
"""
# Initialise.
n = align_tensor.num_tensors(skip_fixed=False) - align_tensor.num_tensors(skip_fixed=True)
tensors = zeros(n*5, float64)
# Nothing to do.
if n == 0:
return None
# Loop over the tensors.
index = 0
for i in range(len(cdp.align_tensors)):
# Skip non-optimised data.
if not opt_uses_align_data(cdp.align_tensors[i].name):
continue
# No parameters have been set.
if not hasattr(cdp.align_tensors[i], 'Axx'):
continue
# The real tensors.
tensors[5*index + 0] = cdp.align_tensors[i].Axx
tensors[5*index + 1] = cdp.align_tensors[i].Ayy
tensors[5*index + 2] = cdp.align_tensors[i].Axy
tensors[5*index + 3] = cdp.align_tensors[i].Axz
tensors[5*index + 4] = cdp.align_tensors[i].Ayz
# Increment the index.
index += 1
# Return the data structure.
return tensors
def target_fn_setup(sim_index=None, scaling_matrix=None, verbosity=0):
"""Initialise the target function for optimisation or direct calculation.
@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 and square scaling matrix.
@type scaling_matrix: numpy rank-2, float64 array or None
@keyword verbosity: A flag specifying the amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
"""
# Test if the N-state model has been set up.
if not hasattr(cdp, 'model'):
raise RelaxNoModelError('N-state')
# '2-domain' model setup tests.
if cdp.model == '2-domain':
# The number of states.
if not hasattr(cdp, 'N'):
raise RelaxError("The number of states has not been set.")
# The reference domain.
if not hasattr(cdp, 'ref_domain'):
raise RelaxError("The reference domain has not been set.")
# Update the model parameters if necessary.
update_model()
# Create the initial parameter vector.
param_vector = assemble_param_vector(sim_index=sim_index)
# Replace all NaNs with 0.0.
fix_invalid(param_vector, copy=False, fill_value=0.0)
# Determine if alignment tensors or RDCs are to be used.
data_types = base_data_types()
# The probabilities.
probs = None
if hasattr(cdp, 'probs') and len(cdp.probs) and cdp.probs[0] != None:
probs = cdp.probs
# Diagonal scaling.
if len(param_vector) and scaling_matrix is not None:
param_vector = dot(inv(scaling_matrix), param_vector)
# Get the data structures for optimisation using the tensors as base data sets.
full_tensors, red_tensor_elem, red_tensor_err, full_in_ref_frame = None, None, None, None
if 'tensor' in data_types:
full_tensors, red_tensor_elem, red_tensor_err, full_in_ref_frame = minimise_setup_tensors(sim_index=sim_index)
# Get the data structures for optimisation using PCSs as base data sets.
pcs, pcs_err, pcs_weight, temp, frq, pcs_pseudo_flags = None, None, None, None, None, None
if 'pcs' in data_types:
pcs, pcs_err, pcs_weight, temp, frq, pcs_pseudo_flags = return_pcs_data(sim_index=sim_index, verbosity=verbosity)
# Get the data structures for optimisation using RDCs as base data sets.
rdcs, rdc_err, rdc_weight, rdc_vector, rdc_dj, absolute_rdc, T_flags, j_couplings, rdc_pseudo_flags = None, None, None, None, None, None, None, None, None
if 'rdc' in data_types:
# The data.
rdcs, rdc_err, rdc_weight, rdc_vector, rdc_dj, absolute_rdc, T_flags, j_couplings, rdc_pseudo_flags = return_rdc_data(sim_index=sim_index, verbosity=verbosity)
# Get the fixed tensors.
fixed_tensors = None
if 'rdc' in data_types or 'pcs' in data_types:
full_tensors = minimise_setup_fixed_tensors()
# The flag list.
fixed_tensors = []
for i in range(len(cdp.align_tensors)):
# Skip non-optimised data.
if not opt_uses_align_data(cdp.align_tensors[i].name):
continue
if cdp.align_tensors[i].fixed:
fixed_tensors.append(True)
else:
fixed_tensors.append(False)
# Get the atomic_positions.
atomic_pos, paramag_centre, centre_fixed = None, None, True
if 'pcs' in data_types or 'pre' in data_types:
atomic_pos, paramag_centre = minimise_setup_atomic_pos(sim_index=sim_index)
# Optimisation of the centre.
if hasattr(cdp, 'paramag_centre_fixed'):
centre_fixed = cdp.paramag_centre_fixed
# Set up the class instance containing the target function.
model = N_state_opt(model=cdp.model, N=cdp.N, init_params=param_vector, probs=probs, full_tensors=full_tensors, red_data=red_tensor_elem, red_errors=red_tensor_err, full_in_ref_frame=full_in_ref_frame, fixed_tensors=fixed_tensors, pcs=pcs, rdcs=rdcs, pcs_errors=pcs_err, rdc_errors=rdc_err, T_flags=T_flags, j_couplings=j_couplings, rdc_pseudo_flags=rdc_pseudo_flags, pcs_pseudo_flags=pcs_pseudo_flags, pcs_weights=pcs_weight, rdc_weights=rdc_weight, rdc_vect=rdc_vector, temp=temp, frq=frq, dip_const=rdc_dj, absolute_rdc=absolute_rdc, atomic_pos=atomic_pos, paramag_centre=paramag_centre, scaling_matrix=scaling_matrix, centre_fixed=centre_fixed)
# Return the data.
return model, param_vector, data_types
def target_fn_setup(sim_index=None, scaling_matrix=None, verbosity=0):
"""Initialise the target function for optimisation or direct calculation.
@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 and square scaling matrix.
@type scaling_matrix: numpy rank-2, float64 array or None
@keyword verbosity: A flag specifying the amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
"""
# Test if the N-state model has been set up.
if not hasattr(cdp, 'model'):
raise RelaxNoModelError('N-state')
# '2-domain' model setup tests.
if cdp.model == '2-domain':
# The number of states.
if not hasattr(cdp, 'N'):
raise RelaxError("The number of states has not been set.")
# The reference domain.
if not hasattr(cdp, 'ref_domain'):
raise RelaxError("The reference domain has not been set.")
# Update the model parameters if necessary.
update_model()
# Create the initial parameter vector.
param_vector = assemble_param_vector(sim_index=sim_index)
# Replace all NaNs with 0.0.
fix_invalid(param_vector, copy=False, fill_value=0.0)
# Determine if alignment tensors or RDCs are to be used.
data_types = base_data_types()
# The probabilities.
probs = None
if hasattr(cdp, 'probs') and len(cdp.probs) and cdp.probs[0] != None:
probs = cdp.probs
# Diagonal scaling.
if len(param_vector) and scaling_matrix is not None:
param_vector = dot(inv(scaling_matrix), param_vector)
# Get the data structures for optimisation using the tensors as base data sets.
full_tensors, red_tensor_elem, red_tensor_err, full_in_ref_frame = None, None, None, None
if 'tensor' in data_types:
full_tensors, red_tensor_elem, red_tensor_err, full_in_ref_frame = minimise_setup_tensors(
sim_index=sim_index)
# Get the data structures for optimisation using PCSs as base data sets.
pcs, pcs_err, pcs_weight, temp, frq, pcs_pseudo_flags = None, None, None, None, None, None
if 'pcs' in data_types:
pcs, pcs_err, pcs_weight, temp, frq, pcs_pseudo_flags = return_pcs_data(
sim_index=sim_index, verbosity=verbosity)
# Get the data structures for optimisation using RDCs as base data sets.
rdcs, rdc_err, rdc_weight, rdc_vector, rdc_dj, absolute_rdc, T_flags, j_couplings, rdc_pseudo_flags = None, None, None, None, None, None, None, None, None
if 'rdc' in data_types:
# The data.
rdcs, rdc_err, rdc_weight, rdc_vector, rdc_dj, absolute_rdc, T_flags, j_couplings, rdc_pseudo_flags = return_rdc_data(
sim_index=sim_index, verbosity=verbosity)
# Get the fixed tensors.
fixed_tensors = None
if 'rdc' in data_types or 'pcs' in data_types:
full_tensors = minimise_setup_fixed_tensors()
# The flag list.
fixed_tensors = []
for i in range(len(cdp.align_tensors)):
# Skip non-optimised data.
if not opt_uses_align_data(cdp.align_tensors[i].name):
continue
if cdp.align_tensors[i].fixed:
fixed_tensors.append(True)
else:
fixed_tensors.append(False)
# Get the atomic_positions.
atomic_pos, paramag_centre, centre_fixed = None, None, True
if 'pcs' in data_types or 'pre' in data_types:
atomic_pos, paramag_centre = minimise_setup_atomic_pos(
sim_index=sim_index)
# Optimisation of the centre.
if hasattr(cdp, 'paramag_centre_fixed'):
centre_fixed = cdp.paramag_centre_fixed
# Set up the class instance containing the target function.
model = N_state_opt(model=cdp.model,
N=cdp.N,
init_params=param_vector,
probs=probs,
full_tensors=full_tensors,
red_data=red_tensor_elem,
red_errors=red_tensor_err,
full_in_ref_frame=full_in_ref_frame,
fixed_tensors=fixed_tensors,
pcs=pcs,
rdcs=rdcs,
pcs_errors=pcs_err,
rdc_errors=rdc_err,
T_flags=T_flags,
j_couplings=j_couplings,
rdc_pseudo_flags=rdc_pseudo_flags,
pcs_pseudo_flags=pcs_pseudo_flags,
pcs_weights=pcs_weight,
rdc_weights=rdc_weight,
rdc_vect=rdc_vector,
temp=temp,
frq=frq,
dip_const=rdc_dj,
absolute_rdc=absolute_rdc,
atomic_pos=atomic_pos,
paramag_centre=paramag_centre,
scaling_matrix=scaling_matrix,
centre_fixed=centre_fixed)
# Return the data.
return model, param_vector, data_types
def return_rdc_data(sim_index=None):
"""Set up the data structures for optimisation using RDCs as base data sets.
@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
@return: The assembled data structures for using RDCs as the base data for optimisation. These include:
- rdc, the RDC values.
- rdc_err, the RDC errors.
- rdc_weight, the RDC weights.
- vectors, the interatomic vectors (pseudo-atom dependent).
- rdc_const, the dipolar constants (pseudo-atom dependent).
- absolute, the absolute value flags (as 1's and 0's).
- T_flags, the flags for T = J+D type data (as 1's and 0's).
- j_couplings, the J coupling values if the RDC data type is set to T = J+D.
- pseudo_flags, the list of flags indicating if the interatomic data contains a pseudo-atom (as 1's and 0's).
@rtype: tuple of (numpy rank-2 float64 array, numpy rank-2 float64 array, numpy rank-2 float64 array, list of numpy rank-3 float64 arrays, list of lists of floats, numpy rank-2 int32 array, numpy rank-2 int32 array, numpy rank-2 float64 array, numpy rank-1 int32 array)
"""
# Sort out pseudo-atoms first. This only needs to be called once.
setup_pseudoatom_rdc()
# Initialise.
rdc = []
rdc_err = []
rdc_weight = []
unit_vect = []
rdc_const = []
absolute = []
T_flags = []
j_couplings = []
pseudo_flags = []
# The unit vectors, RDC constants, and J couplings.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(interatom.spin_id1)
spin2 = return_spin(interatom.spin_id2)
# RDC checks.
if not check_rdcs(interatom):
continue
# Gyromagnetic ratios.
g1 = return_gyromagnetic_ratio(spin1.isotope)
g2 = return_gyromagnetic_ratio(spin2.isotope)
# Pseudo atoms.
if is_pseudoatom(spin1) and is_pseudoatom(spin2):
raise RelaxError("Support for both spins being in a dipole pair being pseudo-atoms is not implemented yet.")
if is_pseudoatom(spin1) or is_pseudoatom(spin2):
# Set the flag.
pseudo_flags.append(1)
# Alias the pseudo and normal atoms.
if is_pseudoatom(spin1):
pseudospin = spin1
base_spin = spin2
pseudospin_id = interatom.spin_id1
base_spin_id = interatom.spin_id2
else:
pseudospin = spin2
base_spin = spin1
pseudospin_id = interatom.spin_id2
base_spin_id = interatom.spin_id1
# Loop over the atoms of the pseudo-atom, storing the data.
pseudo_unit_vect = []
pseudo_rdc_const = []
for spin, spin_id in pseudoatom_loop(pseudospin, return_id=True):
# Get the corresponding interatomic data container.
pseudo_interatom = return_interatom(spin_id1=spin_id, spin_id2=base_spin_id)
# Check.
if pseudo_interatom == None:
raise RelaxError("The interatomic data container between the spins '%s' and '%s' for the pseudo-atom '%s' is not defined." % (base_spin_id, spin_id, pseudospin_id))
# Add the vectors.
if is_float(interatom.vector[0]):
pseudo_unit_vect.append([pseudo_interatom.vector])
else:
pseudo_unit_vect.append(pseudo_interatom.vector)
# Calculate the RDC dipolar constant (in Hertz, and the 3 comes from the alignment tensor), and append it to the list.
pseudo_rdc_const.append(3.0/(2.0*pi) * dipolar_constant(g1, g2, pseudo_interatom.r))
# Reorder the unit vectors so that the structure and pseudo-atom dimensions are swapped.
pseudo_unit_vect = transpose(array(pseudo_unit_vect, float64), (1, 0, 2))
# Block append the pseudo-data.
unit_vect.append(pseudo_unit_vect)
rdc_const.append(pseudo_rdc_const)
# Normal atom.
else:
# Set the flag.
pseudo_flags.append(0)
# Add the vectors.
if is_float(interatom.vector[0]):
unit_vect.append([interatom.vector])
else:
unit_vect.append(interatom.vector)
# Calculate the RDC dipolar constant (in Hertz, and the 3 comes from the alignment tensor), and append it to the list.
rdc_const.append(3.0/(2.0*pi) * dipolar_constant(g1, g2, interatom.r))
# Store the measured J coupling.
if opt_uses_j_couplings():
j_couplings.append(interatom.j_coupling)
# Fix the unit vector data structure.
num = None
for rdc_index in range(len(unit_vect)):
# Convert to numpy structures.
unit_vect[rdc_index] = array(unit_vect[rdc_index], float64)
# Number of vectors.
if num == None:
if unit_vect[rdc_index] != None:
num = len(unit_vect[rdc_index])
continue
# Check.
if unit_vect[rdc_index] != None and len(unit_vect[rdc_index]) != num:
raise RelaxError("The number of interatomic vectors for all no match:\n%s" % unit_vect[rdc_index])
# Missing unit vectors.
if num == None:
raise RelaxError("No interatomic vectors could be found.")
# Update None entries.
for i in range(len(unit_vect)):
if unit_vect[i] == None:
unit_vect[i] = [[None, None, None]]*num
# The RDC data.
for i in range(len(cdp.align_ids)):
# Alias the ID.
align_id = cdp.align_ids[i]
# Skip non-optimised data.
if not opt_uses_align_data(align_id):
continue
# Append empty arrays to the RDC structures.
rdc.append([])
rdc_err.append([])
rdc_weight.append([])
absolute.append([])
T_flags.append([])
# Interatom loop.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(interatom.spin_id1)
spin2 = return_spin(interatom.spin_id2)
# RDC checks.
if not check_rdcs(interatom):
continue
# T-type data.
if align_id in interatom.rdc_data_types and interatom.rdc_data_types[align_id] == 'T':
T_flags[-1].append(True)
else:
T_flags[-1].append(False)
# Check for J couplings if the RDC data type is T = J+D.
if T_flags[-1][-1] and not hasattr(interatom, 'j_coupling'):
continue
# Defaults of None.
value = None
error = None
# Normal set up.
if align_id in interatom.rdc.keys():
# The RDC.
if sim_index != None:
value = interatom.rdc_sim[align_id][sim_index]
else:
value = interatom.rdc[align_id]
# The error.
if hasattr(interatom, 'rdc_err') and align_id in interatom.rdc_err.keys():
# T values.
if T_flags[-1][-1]:
error = sqrt(interatom.rdc_err[align_id]**2 + interatom.j_coupling_err**2)
# D values.
else:
error = interatom.rdc_err[align_id]
# Append the RDCs to the list.
rdc[-1].append(value)
# Append the RDC errors.
rdc_err[-1].append(error)
# Append the weight.
if hasattr(interatom, 'rdc_weight') and align_id in interatom.rdc_weight.keys():
rdc_weight[-1].append(interatom.rdc_weight[align_id])
else:
rdc_weight[-1].append(1.0)
# Append the absolute value flag.
if hasattr(interatom, 'absolute_rdc') and align_id in interatom.absolute_rdc.keys():
absolute[-1].append(interatom.absolute_rdc[align_id])
else:
absolute[-1].append(False)
# Convert to numpy objects.
rdc = array(rdc, float64)
rdc_err = array(rdc_err, float64)
rdc_weight = array(rdc_weight, float64)
absolute = array(absolute, int32)
T_flags = array(T_flags, int32)
if not opt_uses_j_couplings():
j_couplings = None
pseudo_flags = array(pseudo_flags, int32)
# Return the data structures.
return rdc, rdc_err, rdc_weight, unit_vect, rdc_const, absolute, T_flags, j_couplings, pseudo_flags
def assemble_param_vector(sim_index=None):
"""Assemble all the parameters of the model into a single array.
@param sim_index: The index of the simulation to optimise. This should be None if normal optimisation is desired.
@type sim_index: None or int
@return: The parameter vector used for optimisation.
@rtype: numpy array
"""
# Test if the model is selected.
if not hasattr(cdp, 'model') or not isinstance(cdp.model, str):
raise RelaxNoModelError
# Determine the data type.
data_types = base_data_types()
# Initialise the parameter vector.
param_vector = []
# A RDC or PCS data type requires the alignment tensors to be at the start of the parameter vector (unless the tensors are fixed).
if opt_uses_align_data():
for i in range(len(cdp.align_tensors)):
# Skip non-optimised tensors.
if not opt_uses_tensor(cdp.align_tensors[i]):
continue
# No values set.
if not hasattr(cdp.align_tensors[i], 'A_5D'):
param_vector += [None, None, None, None, None]
# Otherwise add the parameters.
else:
param_vector += list(cdp.align_tensors[i].A_5D)
# Monte Carlo simulation data structures.
if sim_index != None:
# Populations.
if cdp.model in ['2-domain', 'population']:
probs = cdp.probs_sim[sim_index]
# Euler angles.
if cdp.model == '2-domain':
alpha = cdp.alpha_sim[sim_index]
beta = cdp.beta_sim[sim_index]
gamma = cdp.gamma_sim[sim_index]
# Normal data structures.
else:
# Populations.
if cdp.model in ['2-domain', 'population']:
probs = cdp.probs
# Euler angles.
if cdp.model == '2-domain':
alpha = cdp.alpha
beta = cdp.beta
gamma = cdp.gamma
# The probabilities (exclude that of state N).
if cdp.model in ['2-domain', 'population']:
param_vector = param_vector + probs[0:-1]
# The Euler angles.
if cdp.model == '2-domain':
for i in range(cdp.N):
param_vector.append(alpha[i])
param_vector.append(beta[i])
param_vector.append(gamma[i])
# The paramagnetic centre.
if hasattr(cdp, 'paramag_centre_fixed') and not cdp.paramag_centre_fixed:
if not hasattr(cdp, 'paramagnetic_centre'):
for i in range(3):
param_vector.append(None)
elif sim_index != None:
if cdp.paramagnetic_centre_sim[sim_index] is None:
for i in range(3):
param_vector.append(None)
else:
for i in range(3):
param_vector.append(
cdp.paramagnetic_centre_sim[sim_index][i])
else:
for i in range(3):
param_vector.append(cdp.paramagnetic_centre[i])
# Return a numpy arrary.
return array(param_vector, float64)
def return_pcs_data(sim_index=None, verbosity=0):
"""Set up the data structures for optimisation using PCSs as base data sets.
@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 verbosity: A flag specifying the amount of information to print. The higher the value, the greater the verbosity.
@type verbosity: int
@return: The assembled data structures for using PCSs as the base data for optimisation. These include:
- the PCS values.
- the unit vectors connecting the paramagnetic centre (the electron spin) to the spin.
- the PCS weight.
- the experimental temperatures.
- the spectrometer frequencies.
- pseudo_flags, the list of flags indicating if the interatomic data contains a pseudo-atom (as 1's and 0's).
@rtype: tuple of (numpy rank-2 float64 array, numpy rank-2 float64 array, numpy rank-2 float64 array, list of float, list of float, numpy rank-1 int32 array)
"""
# Initial printout.
if verbosity:
print("\nPCS data counts:")
# Data setup tests.
if not hasattr(cdp, 'paramagnetic_centre') and (hasattr(cdp, 'paramag_centre_fixed') and cdp.paramag_centre_fixed):
raise RelaxError("The paramagnetic centre has not yet been specified.")
if not hasattr(cdp, 'temperature'):
raise RelaxError("The experimental temperatures have not been set.")
if not hasattr(cdp, 'spectrometer_frq'):
raise RelaxError("The spectrometer frequencies of the experiments have not been set.")
# Sort out pseudo-atoms first. This only needs to be called once.
setup_pseudoatom_pcs()
# Initialise.
pcs = []
pcs_err = []
pcs_weight = []
temp = []
frq = []
pseudo_flags = []
# The PCS data.
for i in range(len(cdp.align_ids)):
# Alias the ID.
align_id = cdp.align_ids[i]
# Skip non-optimised data.
if not opt_uses_align_data(align_id):
continue
# Append empty arrays to the PCS structures.
pcs.append([])
pcs_err.append([])
pcs_weight.append([])
# Get the temperature for the PCS constant.
if align_id in cdp.temperature:
temp.append(cdp.temperature[align_id])
# The temperature must be given!
else:
raise RelaxError("The experimental temperature for the alignment ID '%s' has not been set." % align_id)
# Get the spectrometer frequency in Tesla units for the PCS constant.
if align_id in cdp.spectrometer_frq:
frq.append(cdp.spectrometer_frq[align_id] * 2.0 * pi / periodic_table.gyromagnetic_ratio('1H'))
# The frequency must be given!
else:
raise RelaxError("The spectrometer frequency for the alignment ID '%s' has not been set." % align_id)
# Spin loop.
j = 0
for spin in spin_loop():
# Skip deselected spins.
if not spin.select:
continue
# Skip spins without PCS data.
if not hasattr(spin, 'pcs'):
continue
# Append the PCSs to the list.
if align_id in spin.pcs:
if sim_index != None:
pcs[-1].append(spin.pcs_sim[align_id][sim_index])
else:
pcs[-1].append(spin.pcs[align_id])
# Increment the PCS count.
if pcs[-1][-1] != None:
j += 1
# No data.
else:
pcs[-1].append(None)
# Append the PCS errors.
if hasattr(spin, 'pcs_err') and align_id in spin.pcs_err:
pcs_err[-1].append(spin.pcs_err[align_id])
else:
pcs_err[-1].append(None)
# Append the weight.
if hasattr(spin, 'pcs_weight') and align_id in spin.pcs_weight:
pcs_weight[-1].append(spin.pcs_weight[align_id])
else:
pcs_weight[-1].append(1.0)
# ID and PCS count printout.
if verbosity:
print(" Alignment ID '%s': %i" % (align_id, j))
# Pseudo-atom.
for spin in spin_loop():
if is_pseudoatom(spin):
pseudo_flags.append(1)
else:
pseudo_flags.append(0)
# Convert to numpy objects.
pcs = array(pcs, float64)
pcs_err = array(pcs_err, float64)
pcs_weight = array(pcs_weight, float64)
pseudo_flags = array(pseudo_flags, int32)
# Convert the PCS from ppm to no units.
pcs = pcs * 1e-6
pcs_err = pcs_err * 1e-6
# Return the data structures.
return pcs, pcs_err, pcs_weight, temp, frq, pseudo_flags
def assemble_param_vector(sim_index=None):
"""Assemble all the parameters of the model into a single array.
@param sim_index: The index of the simulation to optimise. This should be None if normal optimisation is desired.
@type sim_index: None or int
@return: The parameter vector used for optimisation.
@rtype: numpy array
"""
# Test if the model is selected.
if not hasattr(cdp, 'model') or not isinstance(cdp.model, str):
raise RelaxNoModelError
# Determine the data type.
data_types = base_data_types()
# Initialise the parameter vector.
param_vector = []
# A RDC or PCS data type requires the alignment tensors to be at the start of the parameter vector (unless the tensors are fixed).
if opt_uses_align_data():
for i in range(len(cdp.align_tensors)):
# Skip non-optimised tensors.
if not opt_uses_tensor(cdp.align_tensors[i]):
continue
# Add the parameters.
param_vector = param_vector + list(cdp.align_tensors[i].A_5D)
# Monte Carlo simulation data structures.
if sim_index != None:
# Populations.
if cdp.model in ['2-domain', 'population']:
probs = cdp.probs_sim[sim_index]
# Euler angles.
if cdp.model == '2-domain':
alpha = cdp.alpha_sim[sim_index]
beta = cdp.beta_sim[sim_index]
gamma = cdp.gamma_sim[sim_index]
# Normal data structures.
else:
# Populations.
if cdp.model in ['2-domain', 'population']:
probs = cdp.probs
# Euler angles.
if cdp.model == '2-domain':
alpha = cdp.alpha
beta = cdp.beta
gamma = cdp.gamma
# The probabilities (exclude that of state N).
if cdp.model in ['2-domain', 'population']:
param_vector = param_vector + probs[0:-1]
# The Euler angles.
if cdp.model == '2-domain':
for i in range(cdp.N):
param_vector.append(alpha[i])
param_vector.append(beta[i])
param_vector.append(gamma[i])
# The paramagnetic centre.
if hasattr(cdp, 'paramag_centre_fixed') and not cdp.paramag_centre_fixed:
if not hasattr(cdp, 'paramagnetic_centre'):
for i in range(3):
param_vector.append(0.0)
elif sim_index != None:
if cdp.paramagnetic_centre_sim[sim_index] == None:
for i in range(3):
param_vector.append(0.0)
else:
for i in range(3):
param_vector.append(cdp.paramagnetic_centre_sim[sim_index][i])
else:
for i in range(3):
param_vector.append(cdp.paramagnetic_centre[i])
# Convert all None values to zero (to avoid conversion to NaN).
for i in range(len(param_vector)):
if param_vector[i] == None:
param_vector[i] = 0.0
# Return a numpy arrary.
return array(param_vector, float64)
