def param_num():
"""Determine the number of parameters in the model.
@return: The number of model parameters.
@rtype: int
"""
# Determine the data type.
data_types = base_data_types()
# Init.
num = 0
# Alignment tensor params.
if ('rdc' in data_types
or 'pcs' in data_types) and not align_tensor.all_tensors_fixed():
# Loop over the alignments.
for i in range(len(cdp.align_tensors)):
# Skip non-optimised tensors.
if not opt_uses_tensor(cdp.align_tensors[i]):
continue
# Add 5 tensor parameters.
num += 5
# Populations.
if cdp.model in ['2-domain', 'population']:
num = num + (cdp.N - 1)
# Euler angles.
if cdp.model == '2-domain':
num = num + 3 * cdp.N
# The paramagnetic centre.
if hasattr(cdp, 'paramag_centre_fixed') and not cdp.paramag_centre_fixed:
num = num + 3
# Return the param number.
return num
def param_num():
"""Determine the number of parameters in the model.
@return: The number of model parameters.
@rtype: int
"""
# Determine the data type.
data_types = base_data_types()
# Init.
num = 0
# Alignment tensor params.
if ('rdc' in data_types or 'pcs' in data_types) and not align_tensor.all_tensors_fixed():
# Loop over the alignments.
for i in range(len(cdp.align_tensors)):
# Skip non-optimised tensors.
if not opt_uses_tensor(cdp.align_tensors[i]):
continue
# Add 5 tensor parameters.
num += 5
# Populations.
if cdp.model in ['2-domain', 'population']:
num = num + (cdp.N - 1)
# Euler angles.
if cdp.model == '2-domain':
num = num + 3*cdp.N
# The paramagnetic centre.
if hasattr(cdp, 'paramag_centre_fixed') and not cdp.paramag_centre_fixed:
num = num + 3
# Return the param number.
return num
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 update_model():
"""Update the model parameters as necessary."""
# Initialise the list of model parameters.
if not hasattr(cdp, 'params'):
cdp.params = []
# Determine the number of states (loaded as structural models), if not already set.
if not hasattr(cdp, 'N'):
# Set the number.
if hasattr(cdp, 'structure'):
cdp.N = cdp.structure.num_models()
# Otherwise return as the rest cannot be updated without N.
else:
return
# Set up the parameter arrays.
if not cdp.params:
# Add the probability or population weight parameters.
if cdp.model in ['2-domain', 'population']:
for i in range(cdp.N - 1):
cdp.params.append('p' + repr(i))
# Add the Euler angle parameters.
if cdp.model == '2-domain':
for i in range(cdp.N):
cdp.params.append('alpha' + repr(i))
cdp.params.append('beta' + repr(i))
cdp.params.append('gamma' + repr(i))
# Initialise the probability and Euler angle arrays.
if cdp.model in ['2-domain', 'population']:
if not hasattr(cdp, 'probs'):
cdp.probs = [None] * cdp.N
if cdp.model == '2-domain':
if not hasattr(cdp, 'alpha'):
cdp.alpha = [None] * cdp.N
if not hasattr(cdp, 'beta'):
cdp.beta = [None] * cdp.N
if not hasattr(cdp, 'gamma'):
cdp.gamma = [None] * cdp.N
# Determine the data type.
data_types = base_data_types()
# Set up tensors for each alignment.
if hasattr(cdp, 'align_ids'):
for id in cdp.align_ids:
# No tensors initialised.
if not hasattr(cdp, 'align_tensors'):
align_tensor.init(tensor=id, align_id=id)
# Find if the tensor corresponding to the id exists.
exists = False
for tensor in cdp.align_tensors:
if id == tensor.align_id:
exists = True
# Initialise the tensor.
if not exists:
align_tensor.init(tensor=id, align_id=id)
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 update_model():
"""Update the model parameters as necessary."""
# Initialise the list of model parameters.
if not hasattr(cdp, 'params'):
cdp.params = []
# Determine the number of states (loaded as structural models), if not already set.
if not hasattr(cdp, 'N'):
# Set the number.
if hasattr(cdp, 'structure'):
cdp.N = cdp.structure.num_models()
# Otherwise return as the rest cannot be updated without N.
else:
return
# Set up the parameter arrays.
if not cdp.params:
# Add the probability or population weight parameters.
if cdp.model in ['2-domain', 'population']:
for i in range(cdp.N-1):
cdp.params.append('p' + repr(i))
# Add the Euler angle parameters.
if cdp.model == '2-domain':
for i in range(cdp.N):
cdp.params.append('alpha' + repr(i))
cdp.params.append('beta' + repr(i))
cdp.params.append('gamma' + repr(i))
# Initialise the probability and Euler angle arrays.
if cdp.model in ['2-domain', 'population']:
if not hasattr(cdp, 'probs'):
cdp.probs = [None] * cdp.N
if cdp.model == '2-domain':
if not hasattr(cdp, 'alpha'):
cdp.alpha = [None] * cdp.N
if not hasattr(cdp, 'beta'):
cdp.beta = [None] * cdp.N
if not hasattr(cdp, 'gamma'):
cdp.gamma = [None] * cdp.N
# Determine the data type.
data_types = base_data_types()
# Set up tensors for each alignment.
if hasattr(cdp, 'align_ids'):
for id in cdp.align_ids:
# No tensors initialised.
if not hasattr(cdp, 'align_tensors'):
align_tensor.init(tensor=id, align_id=id, params=[0.0, 0.0, 0.0, 0.0, 0.0])
# Find if the tensor corresponding to the id exists.
exists = False
for tensor in cdp.align_tensors:
if id == tensor.align_id:
exists = True
# Initialise the tensor.
if not exists:
align_tensor.init(tensor=id, align_id=id, params=[0.0, 0.0, 0.0, 0.0, 0.0])
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)
def grid_search(self, lower=None, upper=None, inc=None, scaling_matrix=None, constraints=False, verbosity=0, sim_index=None):
"""The grid search function.
@param lower: The lower bounds of the grid search which must be equal to the number of parameters in the model.
@type lower: list of lists of floats
@param upper: The upper bounds of the grid search which must be equal to the number of parameters in the model.
@type upper: list of lists of floats
@param 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.
@type inc: list of lists of int
@keyword scaling_matrix: The per-model list of diagonal and square scaling matrices.
@type scaling_matrix: list of numpy rank-2, float64 array or list of None
@param constraints: If True, constraints are applied during the grid search (elinating parts of the grid). If False, no constraints are used.
@type constraints: bool
@param 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')
# The number of parameters.
n = param_num()
# Determine the data type.
data_types = base_data_types()
# The number of tensors to optimise.
tensor_num = align_tensor.num_tensors(skip_fixed=True)
# Custom sub-grid search for when only tensors are optimised (as each tensor is independent, the number of points collapses from inc**(5*N) to N*inc**5).
if cdp.model == 'fixed' and tensor_num > 1 and ('rdc' in data_types or 'pcs' in data_types) and not align_tensor.all_tensors_fixed() and hasattr(cdp, 'paramag_centre_fixed') and cdp.paramag_centre_fixed:
# Print out.
print("Optimising each alignment tensor separately.")
# Store the alignment tensor fixed flags.
fixed_flags = []
for i in range(len(cdp.align_ids)):
# Get the tensor object.
tensor = align_tensor.return_tensor(index=i, skip_fixed=False)
# Store the flag.
fixed_flags.append(tensor.fixed)
# Fix the tensor.
tensor.set('fixed', True)
# Loop over each sub-grid.
for i in range(len(cdp.align_ids)):
# Skip the tensor if originally fixed.
if fixed_flags[i]:
continue
# Get the tensor object.
tensor = align_tensor.return_tensor(index=i, skip_fixed=False)
# Unfix the current tensor.
tensor.set('fixed', False)
# Grid search parameter subsets.
lower_sub = lower[0][i*5:i*5+5]
upper_sub = upper[0][i*5:i*5+5]
inc_sub = inc[0][i*5:i*5+5]
# Minimisation of the sub-grid.
self.minimise(min_algor='grid', lower=[lower_sub], upper=[upper_sub], inc=[inc_sub], scaling_matrix=[None], constraints=constraints, verbosity=verbosity, sim_index=sim_index)
# Fix the tensor again.
tensor.set('fixed', True)
# Reset the state of the tensors.
for i in range(len(cdp.align_ids)):
# Get the tensor object.
tensor = align_tensor.return_tensor(index=i, skip_fixed=False)
# Fix the tensor.
tensor.set('fixed', fixed_flags[i])
# All other minimisation.
else:
self.minimise(min_algor='grid', lower=lower, upper=upper, inc=inc, scaling_matrix=scaling_matrix, constraints=constraints, verbosity=verbosity, sim_index=sim_index)
def grid_search(self,
lower=None,
upper=None,
inc=None,
scaling_matrix=None,
constraints=False,
verbosity=0,
sim_index=None):
"""The grid search function.
@param lower: The lower bounds of the grid search which must be equal to the number of parameters in the model.
@type lower: list of lists of floats
@param upper: The upper bounds of the grid search which must be equal to the number of parameters in the model.
@type upper: list of lists of floats
@param 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.
@type inc: list of lists of int
@keyword scaling_matrix: The per-model list of diagonal and square scaling matrices.
@type scaling_matrix: list of numpy rank-2, float64 array or list of None
@param constraints: If True, constraints are applied during the grid search (elinating parts of the grid). If False, no constraints are used.
@type constraints: bool
@param 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')
# The number of parameters.
n = param_num()
# Determine the data type.
data_types = base_data_types()
# The number of tensors to optimise.
tensor_num = align_tensor.num_tensors(skip_fixed=True)
# Custom sub-grid search for when only tensors are optimised (as each tensor is independent, the number of points collapses from inc**(5*N) to N*inc**5).
if cdp.model == 'fixed' and tensor_num > 1 and (
'rdc' in data_types or 'pcs' in data_types
) and not align_tensor.all_tensors_fixed() and hasattr(
cdp, 'paramag_centre_fixed') and cdp.paramag_centre_fixed:
# Print out.
print("Optimising each alignment tensor separately.")
# Store the alignment tensor fixed flags.
fixed_flags = []
for i in range(len(cdp.align_ids)):
# Get the tensor object.
tensor = align_tensor.return_tensor(index=i, skip_fixed=False)
# Store the flag.
fixed_flags.append(tensor.fixed)
# Fix the tensor.
tensor.set('fixed', True)
# Loop over each sub-grid.
for i in range(len(cdp.align_ids)):
# Skip the tensor if originally fixed.
if fixed_flags[i]:
continue
# Get the tensor object.
tensor = align_tensor.return_tensor(index=i, skip_fixed=False)
# Unfix the current tensor.
tensor.set('fixed', False)
# Grid search parameter subsets.
lower_sub = lower[0][i * 5:i * 5 + 5]
upper_sub = upper[0][i * 5:i * 5 + 5]
inc_sub = inc[0][i * 5:i * 5 + 5]
# Minimisation of the sub-grid.
self.minimise(min_algor='grid',
lower=[lower_sub],
upper=[upper_sub],
inc=[inc_sub],
scaling_matrix=[None],
constraints=constraints,
verbosity=verbosity,
sim_index=sim_index)
# Fix the tensor again.
tensor.set('fixed', True)
# Reset the state of the tensors.
for i in range(len(cdp.align_ids)):
# Get the tensor object.
tensor = align_tensor.return_tensor(index=i, skip_fixed=False)
# Fix the tensor.
tensor.set('fixed', fixed_flags[i])
# All other minimisation.
else:
self.minimise(min_algor='grid',
lower=lower,
upper=upper,
inc=inc,
scaling_matrix=scaling_matrix,
constraints=constraints,
verbosity=verbosity,
sim_index=sim_index)
