def duplicate_data(self, pipe_from=None, pipe_to=None, model_info=None, global_stats=False, verbose=True):
"""Duplicate the data specific to a single hybrid data pipe.
@keyword pipe_from: The data pipe to copy the data from.
@type pipe_from: str
@keyword pipe_to: The data pipe to copy the data to.
@type pipe_to: str
@keyword model_info: The model information from model_loop().
@type model_info: unknown
@keyword global_stats: The global statistics flag.
@type global_stats: bool
@keyword verbose: A flag which if True will cause info to be printed out.
@type verbose: bool
"""
# First create the pipe_to data pipe, if it doesn't exist, but don't switch to it.
if not pipes.has_pipe(pipe_to):
pipes.create(pipe_to, pipe_type='hybrid', switch=False)
# Get the data pipes.
dp_from = pipes.get_pipe(pipe_from)
dp_to = pipes.get_pipe(pipe_to)
# Test that the target data pipe has no sequence loaded.
if not exists_mol_res_spin_data(pipe_to):
raise RelaxSequenceError(pipe_to)
# Duplicate the hybrid pipe list data structure.
dp_to.hybrid_pipes = dp_from.hybrid_pipes
def peak_intensity_type(ri_id=None, type=None):
"""Set the type of intensity measured for the peaks.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword type: The peak intensity type, one of 'height' or 'volume'.
@type type: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['height', 'volume']
if type not in valid:
raise RelaxError(
"The '%s' peak intensity type is unknown. Please select one of %s."
% (type, valid))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the type.
cdp.exp_info.setup_peak_intensity_type(ri_id, type)
def write(ri_id=None, file=None, dir=None, bc=False, force=False):
"""Write relaxation data to a file.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword file: The name of the file to create.
@type file: str
@keyword dir: The directory to write to.
@type dir: str or None
@keyword bc: A flag which if True will cause the back calculated relaxation data to be written.
@type bc: bool
@keyword force: A flag which if True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
pipes.test()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Create the file name if none is given.
if file == None:
file = ri_id + ".out"
# Write the data.
value.write(param=ri_id, file=file, dir=dir, bc=bc, force=force, return_value=return_value, return_data_desc=return_data_desc)
def temp_control(ri_id=None, method=None):
"""Set the temperature control method.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword method: The temperature control method.
@type method: str
"""
# Test if the current pipe exists.
pipes.test()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['single scan interleaving', 'temperature compensation block', 'single scan interleaving and temperature compensation block', 'single fid interleaving', 'single experiment interleaving', 'no temperature control applied']
if method not in valid:
raise RelaxError("The '%s' method is unknown. Please select one of %s." % (method, valid))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the method.
cdp.exp_info.temp_control_setup(ri_id, method)
def duplicate_data(self,
pipe_from=None,
pipe_to=None,
model_info=None,
global_stats=False,
verbose=True):
"""Duplicate the data specific to a single hybrid data pipe.
@keyword pipe_from: The data pipe to copy the data from.
@type pipe_from: str
@keyword pipe_to: The data pipe to copy the data to.
@type pipe_to: str
@keyword model_info: The model information from model_loop().
@type model_info: unknown
@keyword global_stats: The global statistics flag.
@type global_stats: bool
@keyword verbose: A flag which if True will cause info to be printed out.
@type verbose: bool
"""
# First create the pipe_to data pipe, if it doesn't exist, but don't switch to it.
if not pipes.has_pipe(pipe_to):
pipes.create(pipe_to, pipe_type='hybrid', switch=False)
# Get the data pipes.
dp_from = pipes.get_pipe(pipe_from)
dp_to = pipes.get_pipe(pipe_to)
# Test that the target data pipe has no sequence loaded.
if not exists_mol_res_spin_data(pipe_to):
raise RelaxSequenceError(pipe_to)
# Duplicate the hybrid pipe list data structure.
dp_to.hybrid_pipes = dp_from.hybrid_pipes
def __deselect_spins():
"""Deselect spins with no or too little data, that are overfitting, etc."""
# Test if sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Is structural data required?
need_vect = False
if hasattr(cdp, 'diff_tensor') and (cdp.diff_tensor.type == 'spheroid' or
cdp.diff_tensor.type == 'ellipsoid'):
need_vect = True
# Loop over the sequence.
for spin in spin_loop():
# Relaxation data and errors must exist!
if (not hasattr(spin, 'ri_data')
or spin.ri_data == None) or (not hasattr(spin, 'ri_data_err')
or spin.ri_data_err == None):
spin.select = False
# Require 3 or more relaxation data points.
elif len(spin.ri_data) < 3:
spin.select = False
# Require at least as many data points as params to prevent over-fitting.
elif hasattr(spin, 'params') and spin.params and len(
spin.params) > len(spin.ri_data):
spin.select = False
def select_model(model=None, spin_id=None):
"""Function for the selection of a preset model-free model.
@param model: The name of the model.
@type model: str
@param spin_id: The spin identification string.
@type spin_id: str
"""
# Test if the current data pipe exists.
check_pipe()
# Test if the pipe type is 'mf'.
function_type = pipes.get_type()
if function_type != "mf":
raise RelaxFuncSetupError(specific_analyses.get_string(function_type))
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Obtain the model info.
equation, params = model_map(model)
# Set up the model.
model_setup(model, equation, params, spin_id)
def peak_intensity_type(ri_id=None, type=None):
"""Set the type of intensity measured for the peaks.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword type: The peak intensity type, one of 'height' or 'volume'.
@type type: str
"""
# Test if the current pipe exists.
pipes.test()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['height', 'volume']
if type not in valid:
raise RelaxError("The '%s' peak intensity type is unknown. Please select one of %s." % (type, valid))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the type.
cdp.exp_info.setup_peak_intensity_type(ri_id, type)
def angle_diff_frame():
"""Function for calculating the angle defining the XH vector in the diffusion frame."""
# Test if the current data pipe exists.
check_pipe()
# Test if the PDB file has been loaded.
if not hasattr(cdp, 'structure'):
raise RelaxNoPdbError
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if the diffusion tensor data is loaded.
if not hasattr(cdp, 'diff_tensor'):
raise RelaxNoTensorError('diffusion')
# Sphere.
if cdp.diff_tensor.type == 'sphere':
return
# Spheroid.
elif cdp.diff_tensor.type == 'spheroid':
spheroid_frame()
# Ellipsoid.
elif cdp.diff_tensor.type == 'ellipsoid':
raise RelaxError("No coded yet.")
def _select_model(self, model='exp'):
"""Function for selecting the model of the exponential curve.
@keyword model: The exponential curve type. Can be one of 'exp' or 'inv'.
@type model: str
"""
# Test if the current pipe exists.
pipes.test()
# Test if the pipe type is set to 'relax_fit'.
function_type = cdp.pipe_type
if function_type != 'relax_fit':
raise RelaxFuncSetupError(specific_setup.get_string(function_type))
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Two parameter exponential fit.
if model == 'exp':
print("Two parameter exponential fit.")
params = ['rx', 'i0']
# Three parameter inversion recovery fit.
elif model == 'inv':
print("Three parameter inversion recovery fit.")
params = ['rx', 'i0', 'iinf']
# Invalid model.
else:
raise RelaxError("The model '" + model + "' is invalid.")
# Set up the model.
self._model_setup(model, params)
def delete():
"""Delete all the model-free data."""
# Test if the current pipe exists.
check_pipe()
# Test if the pipe type is set to 'mf'.
function_type = pipes.get_type()
if function_type != "mf":
raise RelaxFuncSetupError(specific_analyses.setup.get_string(function_type))
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Get all data structure names.
names = api_model_free.data_names(scope="spin")
# Loop over the spins.
for spin in spin_loop():
# Loop through the data structure names.
for name in names:
# Skip the data structure if it does not exist.
if not hasattr(spin, name):
continue
# Delete the data.
delattr(spin, name)
def temp_calibration(ri_id=None, method=None):
"""Set the temperature calibration method.
@keyword ri_id: The relaxation data type, ie 'R1', 'R2', or 'NOE'.
@type ri_id: str
@keyword method: The temperature calibration method.
@type method: str
"""
# Test if the current pipe exists.
pipes.test()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['methanol', 'monoethylene glycol', 'no calibration applied']
if method not in valid:
warn(RelaxWarning("The '%s' method is unknown. Please try to use one of %s." % (method, valid)))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the method.
cdp.exp_info.temp_calibration_setup(ri_id, method)
def __deselect_spins():
"""Deselect spins with no or too little data, that are overfitting, etc."""
# Test if sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Is structural data required?
need_vect = False
if hasattr(cdp, 'diff_tensor') and (cdp.diff_tensor.type == 'spheroid' or cdp.diff_tensor.type == 'ellipsoid'):
need_vect = True
# Loop over the sequence.
for spin in spin_loop():
# Relaxation data must exist!
if not hasattr(spin, 'ri_data'):
spin.select = False
# Require 3 or more relaxation data points.
elif len(spin.ri_data) < 3:
spin.select = False
# Require at least as many data points as params to prevent over-fitting.
elif hasattr(spin, 'params') and spin.params and len(spin.params) > len(spin.ri_data):
spin.select = False
def select_model(model=None, spin_id=None):
"""Function for the selection of a preset model-free model.
@param model: The name of the model.
@type model: str
@param spin_id: The spin identification string.
@type spin_id: str
"""
# Test if the current data pipe exists.
check_pipe()
# Test if the pipe type is 'mf'.
function_type = pipes.get_type()
if function_type != 'mf':
raise RelaxFuncSetupError(specific_analyses.get_string(function_type))
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Obtain the model info.
equation, params = model_map(model)
# Set up the model.
model_setup(model, equation, params, spin_id)
def type(ri_id=None, ri_type=None):
"""Set or reset the frequency associated with the ID.
@param ri_id: The relaxation data ID string.
@type ri_id: str
@param ri_type: The relaxation data type, ie 'R1', 'R2', or 'NOE'.
@type ri_type: str
"""
# Test if the current data pipe exists.
check_pipe()
# Test if sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check if the type is valid.
if ri_type not in VALID_TYPES:
raise RelaxError("The relaxation data type '%s' must be one of %s." %
(ri_type, VALID_TYPES))
# Initialise if needed.
if not hasattr(cdp, 'ri_type'):
cdp.ri_type = {}
# Set the type.
cdp.ri_type[ri_id] = ri_type
def temp_calibration(ri_id=None, method=None):
"""Set the temperature calibration method.
@keyword ri_id: The relaxation data type, ie 'R1', 'R2', or 'NOE'.
@type ri_id: str
@keyword method: The temperature calibration method.
@type method: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['methanol', 'monoethylene glycol', 'no calibration applied']
if method not in valid:
warn(
RelaxWarning(
"The '%s' method is unknown. Please try to use one of %s." %
(method, valid)))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the method.
cdp.exp_info.temp_calibration_setup(ri_id, method)
def type(ri_id=None, ri_type=None):
"""Set or reset the frequency associated with the ID.
@param ri_id: The relaxation data ID string.
@type ri_id: str
@param ri_type: The relaxation data type, ie 'R1', 'R2', or 'NOE'.
@type ri_type: str
"""
# Test if the current data pipe exists.
pipes.test()
# Test if sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check if the type is valid.
if ri_type not in VALID_TYPES:
raise RelaxError("The relaxation data type '%s' must be one of %s." % (ri_type, VALID_TYPES))
# Initialise if needed.
if not hasattr(cdp, 'ri_type'):
cdp.ri_type = {}
# Set the type.
cdp.ri_type[ri_id] = ri_type
def delete():
"""Delete all the model-free data."""
# Test if the current pipe exists.
check_pipe()
# Test if the pipe type is set to 'mf'.
function_type = pipes.get_type()
if function_type != 'mf':
raise RelaxFuncSetupError(
specific_analyses.setup.get_string(function_type))
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Get all data structure names.
names = api_model_free.data_names(scope='spin')
# Loop over the spins.
for spin in spin_loop():
# Loop through the data structure names.
for name in names:
# Skip the data structure if it does not exist.
if not hasattr(spin, name):
continue
# Delete the data.
delattr(spin, name)
def test_exists_mol_res_spin_data(self):
"""Test the function for determining if molecule-residue-spin data exists.
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# This should be True.
self.failUnless(mol_res_spin.exists_mol_res_spin_data())
def test_exists_mol_res_spin_data(self):
"""Test the function for determining if molecule-residue-spin data exists.
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# This should be True.
self.failUnless(mol_res_spin.exists_mol_res_spin_data())
def create(algor='LM', dir=None, force=False):
"""Create the Dasha script file 'dasha_script' for controlling the program.
@keyword algor: The optimisation algorithm to use. This can be the Levenberg-Marquardt algorithm 'LM' or the Newton-Raphson algorithm 'NR'.
@type algor: str
@keyword dir: The optional directory to place the script into.
@type dir: str or None
@keyword force: A flag which if True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Determine the parameter set.
model_type = determine_model_type()
# Test if diffusion tensor data for the data_pipe exists.
if model_type != 'local_tm' and not hasattr(cdp, 'diff_tensor'):
raise RelaxNoTensorError('diffusion')
# Test if the PDB file has been loaded (for the spheroid and ellipsoid).
if model_type != 'local_tm' and cdp.diff_tensor.type != 'sphere' and not hasattr(
cdp, 'structure'):
raise RelaxNoPdbError
# Test the optimisation algorithm.
if algor not in ['LM', 'NR']:
raise RelaxError(
"The Dasha optimisation algorithm '%s' is unknown, it should either be 'LM' or 'NR'."
% algor)
# Deselect certain spins.
__deselect_spins()
# Directory creation.
if dir == None:
dir = pipes.cdp_name()
mkdir_nofail(dir, verbosity=0)
# Calculate the angle alpha of the XH vector in the spheroid diffusion frame.
if cdp.diff_tensor.type == 'spheroid':
angles.spheroid_frame()
# Calculate the angles theta and phi of the XH vector in the ellipsoid diffusion frame.
elif cdp.diff_tensor.type == 'ellipsoid':
angles.ellipsoid_frame()
# The 'dasha_script' file.
script = open_write_file(file_name='dasha_script', dir=dir, force=force)
create_script(script, model_type, algor)
script.close()
def cpmgfit_input(dir=None, binary='cpmgfit', spin_id=None, force=False):
"""Create the CPMGFit input files.
@keyword dir: The optional directory to place the files into. If None, then the files will be placed into a directory named after the dispersion model.
@type dir: str or None
@keyword binary: The name of the CPMGFit binary file. This can include the path to the binary.
@type binary: str
@keyword spin_id: The spin ID string to restrict the file creation to.
@type spin_id: str
@keyword force: A flag which if True will cause all pre-existing files to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if the experiment type has been set.
if not hasattr(cdp, 'exp_type'):
raise RelaxError("The relaxation dispersion experiment type has not been specified.")
# Test if the model has been set.
if not hasattr(cdp, 'model_type'):
raise RelaxError("The relaxation dispersion model has not been specified.")
# Directory creation.
if dir != None:
mkdir_nofail(dir, verbosity=0)
# The 'run.sh' script.
batch = open_write_file('batch_run.sh', dir, force)
batch.write("#! /bin/sh\n\n")
# Generate the input files for each spin.
for spin, spin_id in spin_loop(return_id=True, skip_desel=True):
# Translate the model.
function = translate_model(spin.model)
# Create the input file.
file_in = create_spin_input(function=function, spin=spin, spin_id=spin_id, dir=dir)
# The output file name.
file_out = spin_file_name(spin_id=spin_id, output=True)
# Add the file to the batch script.
batch.write("%s -grid -xmgr -f %s | tee %s\n" % (binary, file_in, file_out))
# Close the batch script, then make it executable.
batch.close()
if dir:
chmod(dir + sep + 'batch_run.sh', S_IRWXU|S_IRGRP|S_IROTH)
else:
chmod('batch_run.sh', S_IRWXU|S_IRGRP|S_IROTH)
def cpmgfit_input(dir=None, binary='cpmgfit', spin_id=None, force=False):
"""Create the CPMGFit input files.
@keyword dir: The optional directory to place the files into. If None, then the files will be placed into a directory named after the dispersion model.
@type dir: str or None
@keyword binary: The name of the CPMGFit binary file. This can include the path to the binary.
@type binary: str
@keyword spin_id: The spin ID string to restrict the file creation to.
@type spin_id: str
@keyword force: A flag which if True will cause all pre-existing files to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if the experiment type has been set.
if not hasattr(cdp, 'exp_type'):
raise RelaxError("The relaxation dispersion experiment type has not been specified.")
# Test if the model has been set.
if not hasattr(cdp, 'model_type'):
raise RelaxError("The relaxation dispersion model has not been specified.")
# Directory creation.
if dir != None:
mkdir_nofail(dir, verbosity=0)
# The 'run.sh' script.
batch = open_write_file('batch_run.sh', dir, force)
batch.write("#! /bin/sh\n\n")
# Generate the input files for each spin.
for spin, spin_id in spin_loop(return_id=True, skip_desel=True):
# Translate the model.
function = translate_model(spin.model)
# Create the input file.
file_in = create_spin_input(function=function, spin=spin, spin_id=spin_id, dir=dir)
# The output file name.
file_out = spin_file_name(spin_id=spin_id, output=True)
# Add the file to the batch script.
batch.write("%s -grid -xmgr -f %s | tee %s\n" % (binary, file_in, file_out))
# Close the batch script, then make it executable.
batch.close()
if dir:
chmod(dir + sep + 'batch_run.sh', S_IRWXU|S_IRGRP|S_IROTH)
else:
chmod('batch_run.sh', S_IRWXU|S_IRGRP|S_IROTH)
def check_pipe_setup(pipe=None, pcs_id=None, sequence=False, N=False, tensors=False, pcs=False, paramag_centre=False):
"""Check that the current data pipe has been setup sufficiently.
@keyword pipe: The data pipe to check, defaulting to the current pipe.
@type pipe: None or str
@keyword pcs_id: The PCS ID string to check for in cdp.pcs_ids.
@type pcs_id: None or str
@keyword sequence: A flag which when True will invoke the sequence data check.
@type sequence: bool
@keyword N: A flag which if True will check that cdp.N is set.
@type N: bool
@keyword tensors: A flag which if True will check that alignment tensors exist.
@type tensors: bool
@keyword pcs: A flag which if True will check that PCSs exist.
@type pcs: bool
@keyword paramag_centre: A flag which if True will check that the paramagnetic centre has been set.
@type paramag_centre: bool
"""
# The data pipe.
if pipe == None:
pipe = pipes.cdp_name()
# Get the data pipe.
dp = pipes.get_pipe(pipe)
# Test if the current data pipe exists.
check_pipe(pipe)
# Test if sequence data exists.
if sequence and not exists_mol_res_spin_data(pipe):
raise RelaxNoSequenceError(pipe)
# Check for dp.N.
if N and not hasattr(dp, 'N'):
raise RelaxError("The number of states N has not been set.")
# Check that alignment tensors are present.
if tensors and (not hasattr(dp, 'align_tensors') or len(dp.align_tensors) == 0):
raise RelaxNoTensorError('alignment')
# Test for the alignment ID.
if pcs_id and (not hasattr(dp, 'align_ids') or pcs_id not in dp.align_ids):
raise RelaxNoAlignError(pcs_id, pipe)
# Test if PCS data exists.
if pcs and not hasattr(dp, 'align_ids'):
raise RelaxNoAlignError()
if pcs and not hasattr(dp, 'pcs_ids'):
raise RelaxNoPCSError()
elif pcs and pcs_id and pcs_id not in dp.pcs_ids:
raise RelaxNoPCSError(pcs_id)
# Test if the paramagnetic centre is set.
if paramag_centre and not hasattr(cdp, 'paramagnetic_centre'):
raise RelaxError("The paramagnetic centre has not been defined.")
def remove_tm(spin_id=None):
"""Remove local tm from the set of model-free parameters for the given spins.
@param spin_id: The spin identification string.
@type spin_id: str or None
"""
# Test if the current data pipe exists.
check_pipe()
# Test if the pipe type is 'mf'.
function_type = pipes.get_type()
if function_type != 'mf':
raise RelaxFuncSetupError(specific_analyses.get_string(function_type))
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the spins.
for spin in spin_loop(spin_id):
# Skip deselected spins.
if not spin.select:
continue
# Test if a local tm parameter exists.
if not hasattr(spin, 'params') or not 'local_tm' in spin.params:
continue
# Remove tm.
spin.params.remove('local_tm')
# Model name.
if match('^tm', spin.model):
spin.model = spin.model[1:]
# Delete the local tm variable.
del spin.local_tm
# Set all the minimisation stats to None.
spin.chi2 = None
spin.iter = None
spin.f_count = None
spin.g_count = None
spin.h_count = None
spin.warning = None
# Set the global minimisation stats to None.
cdp.chi2 = None
cdp.iter = None
cdp.f_count = None
cdp.g_count = None
cdp.h_count = None
cdp.warning = None
def remove_tm(spin_id=None):
"""Remove local tm from the set of model-free parameters for the given spins.
@param spin_id: The spin identification string.
@type spin_id: str or None
"""
# Test if the current data pipe exists.
check_pipe()
# Test if the pipe type is 'mf'.
function_type = pipes.get_type()
if function_type != "mf":
raise RelaxFuncSetupError(specific_analyses.get_string(function_type))
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the spins.
for spin in spin_loop(spin_id):
# Skip deselected spins.
if not spin.select:
continue
# Test if a local tm parameter exists.
if not hasattr(spin, "params") or not "local_tm" in spin.params:
continue
# Remove tm.
spin.params.remove("local_tm")
# Model name.
if match("^tm", spin.model):
spin.model = spin.model[1:]
# Delete the local tm variable.
del spin.local_tm
# Set all the minimisation stats to None.
spin.chi2 = None
spin.iter = None
spin.f_count = None
spin.g_count = None
spin.h_count = None
spin.warning = None
# Set the global minimisation stats to None.
cdp.chi2 = None
cdp.iter = None
cdp.f_count = None
cdp.g_count = None
cdp.h_count = None
cdp.warning = None
def create(algor='LM', dir=None, force=False):
"""Create the Dasha script file 'dasha_script' for controlling the program.
@keyword algor: The optimisation algorithm to use. This can be the Levenberg-Marquardt algorithm 'LM' or the Newton-Raphson algorithm 'NR'.
@type algor: str
@keyword dir: The optional directory to place the script into.
@type dir: str or None
@keyword force: A flag which if True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Determine the parameter set.
model_type = determine_model_type()
# Test if diffusion tensor data for the data_pipe exists.
if model_type != 'local_tm' and not hasattr(cdp, 'diff_tensor'):
raise RelaxNoTensorError('diffusion')
# Test if the PDB file has been loaded (for the spheroid and ellipsoid).
if model_type != 'local_tm' and cdp.diff_tensor.type != 'sphere' and not hasattr(cdp, 'structure'):
raise RelaxNoPdbError
# Test the optimisation algorithm.
if algor not in ['LM', 'NR']:
raise RelaxError("The Dasha optimisation algorithm '%s' is unknown, it should either be 'LM' or 'NR'." % algor)
# Deselect certain spins.
__deselect_spins()
# Directory creation.
if dir == None:
dir = pipes.cdp_name()
mkdir_nofail(dir, verbosity=0)
# Calculate the angle alpha of the XH vector in the spheroid diffusion frame.
if cdp.diff_tensor.type == 'spheroid':
angles.spheroid_frame()
# Calculate the angles theta and phi of the XH vector in the ellipsoid diffusion frame.
elif cdp.diff_tensor.type == 'ellipsoid':
angles.ellipsoid_frame()
# The 'dasha_script' file.
script = open_write_file(file_name='dasha_script', dir=dir, force=force)
create_script(script, model_type, algor)
script.close()
def _num_instances_spin(self):
"""Return the number of instances, equal to the number of selected spins.
@return: The number of instances (equal to the number of spins).
@rtype: int
"""
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Return the number of spins.
return count_spins()
def _num_instances_spin(self):
"""Return the number of instances, equal to the number of selected spins.
@return: The number of instances (equal to the number of spins).
@rtype: int
"""
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Return the number of spins.
return count_spins()
def check_pipe_setup(pipe=None, rdc_id=None, sequence=False, N=False, tensors=False, rdc=False):
"""Check that the current data pipe has been setup sufficiently.
@keyword pipe: The data pipe to check, defaulting to the current pipe.
@type pipe: None or str
@keyword rdc_id: The RDC ID string to check for in cdp.rdc_ids.
@type rdc_id: None or str
@keyword sequence: A flag which when True will invoke the sequence data check.
@type sequence: bool
@keyword N: A flag which if True will check that cdp.N is set.
@type N: bool
@keyword tensors: A flag which if True will check that alignment tensors exist.
@type tensors: bool
@keyword rdc: A flag which if True will check that RDCs exist.
@type rdc: bool
"""
# The data pipe.
if pipe == None:
pipe = pipes.cdp_name()
# Get the data pipe.
dp = pipes.get_pipe(pipe)
# Test if the current data pipe exists.
pipes.test(pipe)
# Test if sequence data exists.
if sequence and not exists_mol_res_spin_data(pipe):
raise RelaxNoSequenceError(pipe)
# Check for dp.N.
if N and not hasattr(dp, 'N'):
raise RelaxError("The number of states N has not been set.")
# Check that alignment tensors are present.
if tensors and (not hasattr(dp, 'align_tensors') or len(dp.align_tensors) == 0):
raise RelaxNoTensorError('alignment')
# Test for the alignment ID.
if rdc_id and (not hasattr(dp, 'align_ids') or rdc_id not in dp.align_ids):
raise RelaxNoAlignError(rdc_id, pipe)
# Test if RDC data exists.
if rdc and not hasattr(dp, 'align_ids'):
raise RelaxNoAlignError()
if rdc and not hasattr(dp, 'rdc_ids'):
raise RelaxNoRDCError()
elif rdc and rdc_id and rdc_id not in dp.rdc_ids:
raise RelaxNoRDCError(rdc_id)
def test_exists_mol_res_spin_data_no_data(self):
"""Determine if molecule-residue-spin data exists when no data exists.
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
# This should be False.
self.failIf(mol_res_spin.exists_mol_res_spin_data())
def test_exists_mol_res_spin_data_no_data(self):
"""Determine if molecule-residue-spin data exists when no data exists.
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
# This should be False.
self.failIf(mol_res_spin.exists_mol_res_spin_data())
def macro_apply(data_type=None, style="classic", colour_start_name=None, colour_start_rgb=None, colour_end_name=None, colour_end_rgb=None, colour_list=None):
"""Execute a Molmol macro.
@keyword data_type: The data type to map to the structure.
@type data_type: str
@keyword style: The style of the macro.
@type style: str
@keyword colour_start_name: The name of the starting colour of the linear gradient.
@type colour_start_name: str
@keyword colour_start_rgb: The RGB array starting colour of the linear gradient.
@type colour_start_rgb: RBG colour array (len 3 with vals from 0 to 1)
@keyword colour_end_name: The name of the ending colour of the linear gradient.
@type colour_end_name: str
@keyword colour_end_rgb: The RGB array ending colour of the linear gradient.
@type colour_end_rgb: RBG colour array (len 3 with vals from 0 to 1)
@keyword colour_list: The colour list to search for the colour names. Can be either 'molmol' or 'x11'.
@type colour_list: str or None
"""
# Test if the current data pipe exists.
pipes.test()
# Test if sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Check the arguments.
if colour_start_name != None and colour_start_rgb != None:
raise RelaxError("The starting colour name and RGB colour array cannot both be supplied.")
if colour_end_name != None and colour_end_rgb != None:
raise RelaxError("The ending colour name and RGB colour array cannot both be supplied.")
# Merge the colour args.
if colour_start_name != None:
colour_start = colour_start_name
else:
colour_start = colour_start_rgb
if colour_end_name != None:
colour_end = colour_end_name
else:
colour_end = colour_end_rgb
# Create the macro.
commands = create_macro(data_type=data_type, style=style, colour_start=colour_start, colour_end=colour_end, colour_list=colour_list)
# Loop over the commands and execute them.
for command in commands:
molmol_obj.exec_cmd(command)
def sel_all():
"""Select all residues.
@raises RelaxNoSequenceError: If no molecule/residue/spins sequence data exists.
"""
# Test if the current data pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the spins and select them.
for spin in spin_loop():
spin.select = True
def desel_all():
"""Deselect all spins.
@raises RelaxNoSequenceError: If no molecule/residue/spins sequence data exists.
"""
# Test if the current data pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the spins and deselect them.
for spin in spin_loop():
spin.select = False
def sel_all():
"""Select all residues.
@raises RelaxNoSequenceError: If no molecule/residue/spins sequence data exists.
"""
# Test if the current data pipe exists.
pipes.test()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the spins and select them.
for spin in spin_loop():
spin.select = True
def read(ri_id=None, file=None, dir=None):
"""Read the DC data file and place all the data into the relax data store.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword file: The name of the file to open.
@type file: str
@keyword dir: The directory containing the file (defaults to the current directory if None).
@type dir: str or None
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Extract the data from the file.
dc_object = create_object(file=file, dir=dir)
# Name the spins if needed.
name_spin(name=dc_object.sample_information.spin_name,
force=False,
warn_flag=False)
# Pack the data.
values = []
errors = []
spin_ids = []
for res_id in dc_object.results.sequence:
spin_ids.append('%s@%s' %
(res_id, dc_object.sample_information.atom_name))
values.append(dc_object.results.Rx[res_id])
errors.append(dc_object.results.Rx_err[res_id])
pack_data(ri_id,
dc_object.ri_type,
dc_object.parameters.frq,
values,
errors,
spin_ids=spin_ids)
# Set the integration method.
peak_intensity_type(ri_id=ri_id, type=dc_object.details.int_type)
# Set the DC as used software.
software_select('Bruker DC', version=dc_object.version)
def overfit_deselect(self, data_check=True, verbose=True):
"""Deselect spins which have insufficient data to support minimisation.
@keyword data_check: A flag to signal if the presence of base data is to be checked for.
@type data_check: bool
@keyword verbose: A flag which if True will allow printouts.
@type verbose: bool
"""
# Print out.
if verbose:
print("\nOver-fit spin deselection:")
# Test the sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over spin data.
deselect_flag = False
for spin, spin_id in spin_loop(return_id=True):
# Skip deselected spins.
if not spin.select:
continue
# Check if data exists.
if not hasattr(spin, 'intensities'):
warn(RelaxDeselectWarning(spin_id, 'missing intensity data'))
spin.select = False
deselect_flag = True
continue
# Require 3 or more data points.
elif len(spin.intensities) < 3:
warn(RelaxDeselectWarning(spin_id, 'insufficient data, 3 or more data points are required'))
spin.select = False
deselect_flag = True
continue
# Check that the number of relaxation times is complete.
if len(spin.intensities) != len(cdp.relax_times):
raise RelaxError("The %s peak intensity points of the spin '%s' does not match the expected number of %s (the IDs %s do not match %s)." % (len(spin.intensities), spin_id, len(cdp.relax_times), list(spin.intensities.keys()), list(cdp.relax_times.keys())))
# Final printout.
if verbose and not deselect_flag:
print("No spins have been deselected.")
def nessy_input(file='save.NESSY', dir=None, spin_id=None, force=False):
"""Create the NESSY input files.
@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 binary: The name of the CPMGFit binary file. This can include the path to the binary.
@type binary: str
@keyword spin_id: The spin ID string to restrict the file creation to.
@type spin_id: str
@keyword force: A flag which if True will cause all pre-existing files to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if the experiment type has been set.
if not hasattr(cdp, 'exp_type'):
raise RelaxError(
"The relaxation dispersion experiment type has not been specified."
)
# Directory creation.
if dir != None:
mkdir_nofail(dir, verbosity=0)
# The save file.
save_file = open_write_file(file, dir, force)
# Create the NESSY data object.
data = Nessy_data(spin_id=spin_id)
# Create the NESSY file.
write_program_setup(file=save_file, dir=dir, data=data)
# Loop over the experiments.
for ei in range(data.num_exp):
write_sequence(file=save_file, data=data, ei=ei)
write_cpmg_datasets(file=save_file, data=data, ei=ei)
write_spinlock_datasets(file=save_file, data=data, ei=ei)
write_experiment_setup(file=save_file, data=data, ei=ei)
def display(param=None, scaling=1.0):
"""Display spin specific data values.
@keyword param: The name of the parameter to display.
@type param: str
@keyword scaling: The value to scale the parameter by.
@type scaling: float
"""
# Test if the current pipe exists.
check_pipe()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Print the data.
write_data(param=param, file=sys.stdout, scaling=scaling)
def display(param=None, scaling=1.0):
"""Display spin specific data values.
@keyword param: The name of the parameter to display.
@type param: str
@keyword scaling: The value to scale the parameter by.
@type scaling: float
"""
# Test if the current pipe exists.
check_pipe()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Print the data.
write_data(param=param, file=sys.stdout, scaling=scaling)
def test_exists_mol_res_spin_data_single_mol(self):
"""Determine if molecule-residue-spin data exists (with data for a single molecule).
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
dp = pipes.get_pipe('orig')
# Name the first molecule.
dp.mol[0].name = 'TOM40'
# This should be True.
self.failUnless(mol_res_spin.exists_mol_res_spin_data())
def test_exists_mol_res_spin_data_single_spin_num(self):
"""Determine if molecule-residue-spin data exists (when a single spin is numbered).
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
dp = pipes.get_pipe('orig')
# Number the first spin.
dp.mol[0].res[0].spin[0].num = 234
# This should be True.
self.failUnless(mol_res_spin.exists_mol_res_spin_data())
def test_exists_mol_res_spin_data_single_mol(self):
"""Determine if molecule-residue-spin data exists (with data for a single molecule).
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
dp = pipes.get_pipe('orig')
# Name the first molecule.
dp.mol[0].name = 'TOM40'
# This should be True.
self.failUnless(mol_res_spin.exists_mol_res_spin_data())
def test_exists_mol_res_spin_data_single_spin_num(self):
"""Determine if molecule-residue-spin data exists (when a single spin is numbered).
The function tested is pipe_control.mol_res_spin.exists_mol_res_spin_data().
"""
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
dp = pipes.get_pipe('orig')
# Number the first spin.
dp.mol[0].res[0].spin[0].num = 234
# This should be True.
self.failUnless(mol_res_spin.exists_mol_res_spin_data())
def assemble_data(self):
"""Assemble the data required for the auto-analysis.
See the docstring for auto_analyses.relax_fit for details. All data is taken from the relax data store, so data upload from the GUI to there must have been previously performed.
@return: A container with all the data required for the auto-analysis.
@rtype: class instance, list of str
"""
# The data container.
data = Container()
missing = []
# The pipe name and bundle.
data.pipe_name = self.data.pipe_name
data.pipe_bundle = self.data.pipe_bundle
# The frequency.
frq = gui_to_str(self.field_nmr_frq.GetValue())
if frq == None:
missing.append('NMR frequency')
# File root.
data.file_root = '%s.%s' % (self.analysis_type, frq)
# Check if sequence data is loaded
if not exists_mol_res_spin_data():
missing.append("Sequence data")
# Spectral data.
if not hasattr(cdp, 'spectrum_ids') or len(cdp.spectrum_ids) < 3:
missing.append("Spectral data")
# Increment size.
data.inc = gui_to_int(self.grid_inc.GetValue())
# The number of Monte Carlo simulations to be used for error analysis at the end of the analysis.
data.mc_sim_num = gui_to_int(self.mc_sim_num.GetValue())
# Results directory.
data.save_dir = self.data.save_dir
# Return the container and list of missing data.
return data, missing
def assemble_data(self):
"""Assemble the data required for the auto-analysis.
See the docstring for auto_analyses.relax_fit for details. All data is taken from the relax data store, so data upload from the GUI to there must have been previously performed.
@return: A container with all the data required for the auto-analysis.
@rtype: class instance, list of str
"""
# The data container.
data = Container()
missing = []
# The pipe name and bundle.
data.pipe_name = self.data.pipe_name
data.pipe_bundle = self.data.pipe_bundle
# The frequency.
frq = gui_to_str(self.field_nmr_frq.GetValue())
if frq == None:
missing.append('NMR frequency')
# File root.
data.file_root = '%s.%s' % (self.analysis_type, frq)
# Check if sequence data is loaded
if not exists_mol_res_spin_data():
missing.append("Sequence data")
# Spectral data.
if not hasattr(cdp, 'spectrum_ids') or len(cdp.spectrum_ids) < 3:
missing.append("Spectral data")
# Increment size.
data.inc = gui_to_int(self.grid_inc.GetValue())
# The number of Monte Carlo simulations to be used for error analysis at the end of the analysis.
data.mc_sim_num = gui_to_int(self.mc_sim_num.GetValue())
# Results directory.
data.save_dir = self.data.save_dir
# Return the container and list of missing data.
return data, missing
def nessy_input(file='save.NESSY', dir=None, spin_id=None, force=False):
"""Create the NESSY input files.
@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 binary: The name of the CPMGFit binary file. This can include the path to the binary.
@type binary: str
@keyword spin_id: The spin ID string to restrict the file creation to.
@type spin_id: str
@keyword force: A flag which if True will cause all pre-existing files to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
pipes.test()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if the experiment type has been set.
if not hasattr(cdp, 'exp_type'):
raise RelaxError("The relaxation dispersion experiment type has not been specified.")
# Directory creation.
if dir != None:
mkdir_nofail(dir, verbosity=0)
# The save file.
save_file = open_write_file(file, dir, force)
# Create the NESSY data object.
data = Nessy_data(spin_id=spin_id)
# Create the NESSY file.
write_program_setup(file=save_file, dir=dir, data=data)
# Loop over the experiments.
for ei in range(data.num_exp):
write_sequence(file=save_file, data=data, ei=ei)
write_cpmg_datasets(file=save_file, data=data, ei=ei)
write_spinlock_datasets(file=save_file, data=data, ei=ei)
write_experiment_setup(file=save_file, data=data, ei=ei)
def write(param=None, file=None, dir=None, scaling=1.0, return_value=None, return_data_desc=None, comment=None, bc=False, force=False):
"""Write data to a file.
@keyword param: The name of the parameter to write to file.
@type param: str
@keyword file: The file to write the data to.
@type file: str
@keyword dir: The name of the directory to place the file into (defaults to the current directory).
@type dir: str
@keyword scaling: The value to scale the parameter by.
@type scaling: float
@keyword return_value: An optional function which if supplied will override the default value returning function.
@type return_value: None or func
@keyword return_data_desc: An optional function which if supplied will override the default parameter description returning function.
@type return_data_desc: None or func
@keyword comment: Text which will be added to the start of the file as comments. All lines will be prefixed by '# '.
@type comment: str
@keyword bc: A flag which if True will cause the back calculated values to be written.
@type bc: bool
@keyword force: A flag which if True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Open the file for writing.
file_path = get_file_path(file, dir)
file = open_write_file(file, dir, force)
# Write the data.
write_data(param=param, file=file, scaling=scaling, return_value=return_value, return_data_desc=return_data_desc, comment=comment, bc=bc)
# Close the file.
file.close()
# Add the file to the results file list.
add_result_file(type='text', label='Text', file=file_path)
def write(param=None, file=None, dir=None, scaling=1.0, return_value=None, return_data_desc=None, comment=None, bc=False, force=False):
"""Write data to a file.
@keyword param: The name of the parameter to write to file.
@type param: str
@keyword file: The file to write the data to.
@type file: str
@keyword dir: The name of the directory to place the file into (defaults to the current directory).
@type dir: str
@keyword scaling: The value to scale the parameter by.
@type scaling: float
@keyword return_value: An optional function which if supplied will override the default value returning function.
@type return_value: None or func
@keyword return_data_desc: An optional function which if supplied will override the default parameter description returning function.
@type return_data_desc: None or func
@keyword comment: Text which will be added to the start of the file as comments. All lines will be prefixed by '# '.
@type comment: str
@keyword bc: A flag which if True will cause the back calculated values to be written.
@type bc: bool
@keyword force: A flag which if True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Open the file for writing.
file_path = get_file_path(file, dir)
file = open_write_file(file, dir, force)
# Write the data.
write_data(param=param, file=file, scaling=scaling, return_value=return_value, return_data_desc=return_data_desc, comment=comment, bc=bc)
# Close the file.
file.close()
# Add the file to the results file list.
add_result_file(type='text', label='Text', file=file_path)
def display(ri_id=None):
"""Display relaxation data corresponding to the ID.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
"""
# Test if the current pipe exists.
pipes.test()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Print the data.
value.write_data(param=ri_id, file=sys.stdout, return_value=return_value, return_data_desc=return_data_desc)
def sel_spin(spin_id=None, boolean='OR', change_all=False):
"""Select specific spins.
@keyword spin_id: The spin identification string.
@type spin_id: str or None
@param boolean: The boolean operator used to select the spin systems with. It
can be one of 'OR', 'NOR', 'AND', 'NAND', 'XOR', or 'XNOR'.
This will be ignored if the change_all flag is set.
@type boolean: str
@keyword change_all: A flag which if True will cause all spins not specified in the
file to be deselected. Only the boolean operator 'OR' is
compatible with this flag set to True (all others will be
ignored).
@type change_all: bool
@raises RelaxNoSequenceError: If no molecule/residue/spins sequence data exists.
@raises RelaxError: If the boolean operator is unknown.
"""
# Test if the current data pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# First deselect all spins if the change_all flag is set.
if change_all:
# Loop over all spins.
for spin in spin_loop():
spin.select = False
# Loop over the specified spins.
for spin in spin_loop(spin_id):
# Select just the specified residues.
if change_all:
spin.select = True
# Boolean selections.
else:
spin.select = boolean_select(current=spin.select, boolean=boolean)
def select_model(model='exp'):
"""Function for selecting the model of the exponential curve.
@keyword model: The exponential curve type. Can be one of 'exp', 'inv', or 'sat'.
@type model: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if the pipe type is set to 'relax_fit'.
function_type = cdp.pipe_type
if function_type != 'relax_fit':
raise RelaxFuncSetupError(specific_setup.get_string(function_type))
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Two parameter exponential fit.
if model == 'exp':
print("Two parameter exponential fit.")
params = ['rx', 'i0']
# Three parameter inversion recovery fit.
elif model == 'inv':
print("The inversion recovery experiment.")
params = ['rx', 'i0', 'iinf']
# The saturation recovery.
elif model == 'sat':
print("The saturation recovery experiment.")
params = ['rx', 'iinf']
# Invalid model.
else:
raise RelaxError("The model '" + model + "' is invalid.")
# Set up the model.
model_setup(model, params)
def fix(element, fixed):
"""Fix or allow certain model components values to vary during optimisation.
@param element: The model component to fix or unfix. If set to 'diff', then the diffusion
parameters can be toggled. If set to 'all_spins', then all spins can be
toggled. If set to 'all', then all model components are toggled.
@type element: str.
"""
# Test if the current data pipe exists.
check_pipe()
# Diffusion tensor.
if element == 'diff' or element == 'all':
# Test if the diffusion tensor data is loaded.
if not hasattr(cdp, 'diff_tensor'):
raise RelaxNoTensorError('diffusion')
# Set the fixed flag.
cdp.diff_tensor.set_fixed(fixed)
# All spins.
if element == 'all_spins' or element == 'all':
# Test if sequence data exists.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the sequence and set the fixed flag.
for spin in spin_loop():
# Skip deselected spins.
if not spin.select:
continue
# Set the flag.
spin.fixed = fixed
# Unknown.
if element not in ['diff', 'all_spins', 'all']:
raise RelaxError("The 'element' argument " + repr(element) + " is unknown.")
def read(ri_id=None, file=None, dir=None):
"""Read the DC data file and place all the data into the relax data store.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword file: The name of the file to open.
@type file: str
@keyword dir: The directory containing the file (defaults to the current directory if None).
@type dir: str or None
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Extract the data from the file.
values, errors, res_nums, int_type, frq, ri_type, spin_name, isotope, version = parse_file(
file=file, dir=dir)
# Name the spins if needed.
name_spin(name=spin_name, force=False)
# Modify the residue numbers by adding the heteronucleus name.
if isotope:
atom_name = element_from_isotope(isotope)
for i in range(len(res_nums)):
res_nums[i] += '@' + atom_name
# Pack the data.
pack_data(ri_id, ri_type, frq, values, errors, spin_ids=res_nums)
# Set the integration method.
peak_intensity_type(ri_id=ri_id, type=int_type)
# Set the DC as used software.
software_select('Bruker DC', version=version)
def reverse(spin_id=None):
"""Reversal of spin selections.
@keyword spin_id: The spin identification string.
@type spin_id: str or None
@raises RelaxNoSequenceError: If no molecule/residue/spins sequence data exists.
"""
# Test if the current data pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Loop over the spin systems and reverse the selection flag.
for spin in spin_loop(spin_id):
# Reverse the selection.
if spin.select:
spin.select = False
else:
spin.select = True
def _hybridise(self, hybrid=None, pipe_list=None):
"""Create the hybrid data pipe.
@keyword hybrid: The name of the new hybrid data pipe.
@type hybrid: str
@keyword pipe_list: The list of data pipes that the hybrid is composed of.
@type pipe_list: list of str
"""
# Test if the hybrid data pipe already exists.
if hybrid in pipes.pipe_names():
raise RelaxPipeError(hybrid)
# Loop over the pipes to be hybridised and check them.
pipe_type = pipes.get_type(pipe_list[0])
for pipe in pipe_list:
# Switch to the data pipe.
pipes.switch(pipe)
# Test if the pipe exists.
check_pipe()
# Check that the pipe types match.
if pipes.get_type() != pipe_type:
raise RelaxError("The data pipe types do not match.")
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Check that the sequence data matches in all pipes.
for i in range(1, len(pipe_list)):
compare_sequence(pipe_list[0], pipe_list[1])
# Create the data pipe.
pipes.create(pipe_name=hybrid, pipe_type='hybrid')
# Store the pipe list forming the hybrid.
cdp.hybrid_pipes = pipe_list
def temp_control(ri_id=None, method=None):
"""Set the temperature control method.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword method: The temperature control method.
@type method: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = [
'single scan interleaving', 'temperature compensation block',
'single scan interleaving and temperature compensation block',
'single fid interleaving', 'single experiment interleaving',
'no temperature control applied'
]
if method not in valid:
raise RelaxError(
"The '%s' method is unknown. Please select one of %s." %
(method, valid))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the method.
cdp.exp_info.temp_control_setup(ri_id, method)
def write(ri_id=None, file=None, dir=None, bc=False, force=False):
"""Write relaxation data to a file.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword file: The name of the file to create.
@type file: str
@keyword dir: The directory to write to.
@type dir: str or None
@keyword bc: A flag which if True will cause the back calculated relaxation data to be written.
@type bc: bool
@keyword force: A flag which if True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Create the file name if none is given.
if file == None:
file = ri_id + ".out"
# Write the data.
value.write(param=ri_id,
file=file,
dir=dir,
bc=bc,
force=force,
return_value=return_value,
return_data_desc=return_data_desc)
def display(ri_id=None):
"""Display relaxation data corresponding to the ID.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if the sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Print the data.
value.write_data(param=ri_id,
file=sys.stdout,
return_value=return_value,
return_data_desc=return_data_desc)
