def rna_seq(self):
"""Generate the RNA sequence of the noe_rna_hbond.dat restraint file."""
# Info.
mol_names = ["A", "B"]
res_nums = [[1, 2, 3, 4], [4, 3, 2, 1]]
spin_names = [
[["N1", "N6", "H62"], ["H3", "N3", "O4"], ["H1", "N1", "H22", "N2", "O6"], ["N3", "O2", "H42", "N4"]],
[["H3", "N3", "O4"], ["N1", "N6", "H62"], ["N3", "O2", "H42", "N4"], ["H1", "N1", "H22", "N2", "O6"]],
]
# Loop over the molecules.
for i in range(len(mol_names)):
# Create the molecule.
create_molecule(mol_names[i])
# Loop over the residues.
for j in range(len(res_nums[i])):
# Create the residue.
create_residue(res_nums[i][j], mol_name=mol_names[i])
# Loop over the atoms.
for k in range(len(spin_names[i][j])):
# Create the spin.
create_spin(spin_names[i][j][k], res_num=res_nums[i][j], mol_name=mol_names[i])
# Display the sequence for debugging.
self.interpreter.sequence.display()
def read_spins(file=None, dir=None, dim=1, spin_id_col=None, mol_name_col=None, res_num_col=None, res_name_col=None, spin_num_col=None, spin_name_col=None, sep=None, spin_id=None, verbose=True):
"""Read the peak intensity data.
@keyword file: The name of the file containing the peak intensities.
@type file: str
@keyword dir: The directory where the file is located.
@type dir: str
@keyword dim: The dimension of the peak list to associate the data with.
@type dim: int
@keyword spin_id_col: The column containing the spin ID strings (used by the generic intensity file format). If supplied, the mol_name_col, res_name_col, res_num_col, spin_name_col, and spin_num_col arguments must be none.
@type spin_id_col: int or None
@keyword mol_name_col: The column containing the molecule name information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type mol_name_col: int or None
@keyword res_name_col: The column containing the residue name information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type res_name_col: int or None
@keyword res_num_col: The column containing the residue number information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type res_num_col: int or None
@keyword spin_name_col: The column containing the spin name information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type spin_name_col: int or None
@keyword spin_num_col: The column containing the spin number information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type spin_num_col: int or None
@keyword sep: The column separator which, if None, defaults to whitespace.
@type sep: str or None
@keyword spin_id: The spin ID string used to restrict data loading to a subset of all spins. If 'auto' is provided for a NMRPipe seriesTab formatted file, the ID's are auto generated in form of Z_Ai.
@type spin_id: None or str
@keyword verbose: A flag which if True will cause all relaxation data loaded to be printed out.
@type verbose: bool
"""
# Data checks.
check_pipe()
# Check the file name.
if file == None:
raise RelaxError("The file name must be supplied.")
# Read the peak list data.
peak_list = read_peak_list(file=file, dir=dir, spin_id_col=spin_id_col, mol_name_col=mol_name_col, res_num_col=res_num_col, res_name_col=res_name_col, spin_num_col=spin_num_col, spin_name_col=spin_name_col, sep=sep, spin_id=spin_id)
# Loop over the peak_list.
created_spins = []
for assign in peak_list:
mol_name = assign.mol_names[dim-1]
res_num = assign.res_nums[dim-1]
res_name = assign.res_names[dim-1]
spin_num = assign.spin_nums[dim-1]
spin_name = assign.spin_names[dim-1]
# Generate the spin_id.
spin_id = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_name=spin_name)
# Check if the spin already exist.
if return_spin(spin_id=spin_id) == None:
# Create the spin if not exist.
create_spin(spin_num=spin_num, spin_name=spin_name, res_num=res_num, res_name=res_name, mol_name=mol_name)
# Test that data exists.
check_mol_res_spin_data()
def generate_sequence(N=0, spin_ids=None, spin_nums=None, spin_names=None, res_nums=None, res_names=None, mol_names=None, isotopes=None, elements=None):
"""Generate the sequence data from the BRMB information.
@keyword N: The number of spins.
@type N: int
@keyword spin_ids: The list of spin IDs.
@type spin_ids: list of str
@keyword spin_nums: The list of spin numbers.
@type spin_nums: list of int or None
@keyword spin_names: The list of spin names.
@type spin_names: list of str or None
@keyword res_nums: The list of residue numbers.
@type res_nums: list of int or None
@keyword res_names: The list of residue names.
@type res_names: list of str or None
@keyword mol_names: The list of molecule names.
@type mol_names: list of str or None
@keyword isotopes: The optional list of isotope types.
@type isotopes: list of str or None
@keyword elements: The optional list of element types.
@type elements: list of str or None
"""
# The blank data.
if not spin_nums:
spin_nums = [None] * N
if not spin_names:
spin_names = [None] * N
if not res_nums:
res_nums = [None] * N
if not res_names:
res_names = [None] * N
if not mol_names:
mol_names = [None] * N
# Generate the spin IDs.
spin_ids = []
for i in range(N):
spin_ids.append(generate_spin_id(mol_name=mol_names[i], res_num=res_nums[i], spin_name=spin_names[i]))
# Loop over the spin data.
for i in range(N):
# The spin already exists.
spin = return_spin(spin_ids[i])
if spin:
continue
# Create the spin.
spin = create_spin(spin_num=spin_nums[i], spin_name=spin_names[i], res_num=res_nums[i], res_name=res_names[i], mol_name=mol_names[i])
# Set the spin isotope and element.
spin_id = spin._spin_ids[0]
if elements:
set_spin_element(spin_id=spin_id, element=elements[i], force=True)
if isotopes and elements:
isotope = "%s%s" % (isotopes[i], elements[i])
set_spin_isotope(spin_id=spin_id, isotope=isotope, force=True)
# Clean up the spin metadata.
metadata_cleanup()
def rna_seq(self):
"""Generate the RNA sequence of the noe_rna_hbond.dat restraint file."""
# Info.
mol_names = ['A', 'B']
res_nums = [
[1, 2, 3, 4],
[4, 3, 2, 1]
]
spin_names = [
[['N1', 'N6', 'H62'],
['H3', 'N3', 'O4'],
['H1', 'N1', 'H22', 'N2', 'O6'],
['N3', 'O2', 'H42', 'N4']],
[['H3', 'N3', 'O4'],
['N1', 'N6', 'H62'],
['N3', 'O2', 'H42', 'N4'],
['H1', 'N1', 'H22', 'N2', 'O6']]
]
# Loop over the molecules.
for i in range(len(mol_names)):
# Create the molecule.
create_molecule(mol_names[i])
# Loop over the residues.
for j in range(len(res_nums[i])):
# Create the residue.
create_residue(res_nums[i][j], mol_name=mol_names[i])
# Loop over the atoms.
for k in range(len(spin_names[i][j])):
# Create the spin.
create_spin(spin_names[i][j][k], res_num=res_nums[i][j], mol_name=mol_names[i])
# Display the sequence for debugging.
self.interpreter.sequence.display()
def attach_protons():
"""Attach a single proton to all heteronuclei."""
# Loop over all spins.
mol_names = []
res_nums = []
res_names = []
for spin, mol_name, res_num, res_name, spin_id in spin_loop(full_info=True, return_id=True):
# The spin is already a proton.
if hasattr(spin, 'element') and spin.element == 'H':
continue
# Get the interatomic data container.
interatoms = return_interatom_list(spin_id)
proton_found = False
if len(interatoms):
for i in range(len(interatoms)):
# Get the attached spin.
spin_attached = return_spin(interatoms[i].spin_id1)
if id(spin_attached) == id(spin):
spin_attached = return_spin(interatoms[i].spin_id2)
# Is it a proton?
if hasattr(spin_attached, 'element') and spin_attached.element == 'H' or spin.name == 'H':
proton_found = True
break
# Attached proton found.
if proton_found:
continue
# Store the sequence info.
mol_names.append(mol_name)
res_nums.append(res_num)
res_names.append(res_name)
# Create all protons (this must be done out of the spin loop, as it affects the looping!).
ids = []
for i in range(len(mol_names)):
# Create the spin container.
spin = create_spin(spin_name='H', res_name=res_names[i], res_num=res_nums[i], mol_name=mol_names[i])
ids.append(generate_spin_id(mol_name=mol_names[i], res_num=res_nums[i], res_name=res_names[i], spin_name='H'))
print("Creating the spins %s." % ids)
# Set the element and spin type.
set_spin_element(spin_id='@H', element='H')
set_spin_isotope(spin_id='@H', isotope='1H')
def attach_protons():
"""Attach a single proton to all heteronuclei."""
# Loop over all spins.
mol_names = []
res_nums = []
res_names = []
for spin, mol_name, res_num, res_name, spin_id in spin_loop(full_info=True, return_id=True):
# The spin is already a proton.
if hasattr(spin, 'element') and spin.element == 'H':
continue
# Get the interatomic data container.
interatoms = return_interatom_list(spin_hash=spin._hash)
proton_found = False
if len(interatoms):
for i in range(len(interatoms)):
# Get the attached spin.
spin_attached = return_spin(spin_hash=interatoms[i]._spin_hash1)
if id(spin_attached) == id(spin):
spin_attached = return_spin(spin_hash=interatoms[i]._spin_hash2)
# Is it a proton?
if hasattr(spin_attached, 'element') and spin_attached.element == 'H' or spin.name == 'H':
proton_found = True
break
# Attached proton found.
if proton_found:
continue
# Store the sequence info.
mol_names.append(mol_name)
res_nums.append(res_num)
res_names.append(res_name)
# Create all protons (this must be done out of the spin loop, as it affects the looping!).
ids = []
for i in range(len(mol_names)):
# Create the spin container.
spin = create_spin(spin_name='H', res_name=res_names[i], res_num=res_nums[i], mol_name=mol_names[i])[0]
ids.append(generate_spin_id(mol_name=mol_names[i], res_num=res_nums[i], res_name=res_names[i], spin_name='H'))
print("Creating the spins %s." % ids)
# Set the element and spin type.
set_spin_element(spin_id='@H', element='H')
set_spin_isotope(spin_id='@H', isotope='1H')
def generate(mol_name=None, res_num=None, res_name=None, spin_num=None, spin_name=None, pipe=None, select=True, verbose=True):
"""Generate the sequence item-by-item by adding a single molecule/residue/spin container as necessary.
@keyword mol_name: The molecule name.
@type mol_name: str or None
@keyword res_num: The residue number.
@type res_num: int or None
@keyword res_name: The residue name.
@type res_name: str or None
@keyword spin_num: The spin number.
@type spin_num: int or None
@keyword spin_name: The spin name.
@type spin_name: str or None
@keyword pipe: The data pipe in which to generate the sequence. This defaults to the current data pipe.
@type pipe: str
@keyword select: The spin selection flag.
@type select: bool
@keyword verbose: A flag which if True will cause info about each spin to be printed out as the sequence is generated.
@type verbose: bool
"""
# The current data pipe.
if pipe == None:
pipe = pipes.cdp_name()
# A new molecule.
if not return_molecule(generate_spin_id(mol_name=mol_name), pipe=pipe):
create_molecule(mol_name=mol_name, pipe=pipe)
# A new residue.
curr_res = return_residue(generate_spin_id(mol_name=mol_name, res_num=res_num, res_name=res_name), pipe=pipe)
if not curr_res or ((res_num != None and curr_res.num != res_num) or (res_name != None and curr_res.name != res_name)):
create_residue(mol_name=mol_name, res_num=res_num, res_name=res_name, pipe=pipe)
# A new spin.
curr_spin = return_spin(generate_spin_id(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name), pipe=pipe)
if not curr_spin or ((spin_num != None and curr_spin.num != spin_num) or (spin_name != None and curr_spin.name != spin_name)):
# Add the spin.
curr_spin = create_spin(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name, pipe=pipe)
# Set the selection flag.
curr_spin.select = select
def generate(mol_name=None, res_num=None, res_name=None, spin_num=None, spin_name=None, pipe=None, select=True, verbose=True):
"""Generate the sequence item-by-item by adding a single molecule/residue/spin container as necessary.
@keyword mol_name: The molecule name.
@type mol_name: str or None
@keyword res_num: The residue number.
@type res_num: int or None
@keyword res_name: The residue name.
@type res_name: str or None
@keyword spin_num: The spin number.
@type spin_num: int or None
@keyword spin_name: The spin name.
@type spin_name: str or None
@keyword pipe: The data pipe in which to generate the sequence. This defaults to the current data pipe.
@type pipe: str
@keyword select: The spin selection flag.
@type select: bool
@keyword verbose: A flag which if True will cause info about each spin to be printed out as the sequence is generated.
@type verbose: bool
"""
# The current data pipe.
if pipe == None:
pipe = pipes.cdp_name()
# A new molecule.
if not return_molecule(generate_spin_id(mol_name=mol_name), pipe=pipe):
create_molecule(mol_name=mol_name, pipe=pipe)
# A new residue.
curr_res = return_residue(generate_spin_id(mol_name=mol_name, res_num=res_num, res_name=res_name), pipe=pipe)
if not curr_res or ((res_num != None and curr_res.num != res_num) or (res_name != None and curr_res.name != res_name)):
create_residue(mol_name=mol_name, res_num=res_num, res_name=res_name, pipe=pipe)
# A new spin.
curr_spin = return_spin(spin_id=generate_spin_id(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name), pipe=pipe)
if not curr_spin or ((spin_num != None and curr_spin.num != spin_num) or (spin_name != None and curr_spin.name != spin_name)):
# Add the spin.
curr_spin = create_spin(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name, pipe=pipe)[0]
# Set the selection flag.
curr_spin.select = select
def generate_sequence(N=0,
spin_ids=None,
spin_nums=None,
spin_names=None,
res_nums=None,
res_names=None,
mol_names=None,
isotopes=None,
elements=None):
"""Generate the sequence data from the BRMB information.
@keyword N: The number of spins.
@type N: int
@keyword spin_ids: The list of spin IDs.
@type spin_ids: list of str
@keyword spin_nums: The list of spin numbers.
@type spin_nums: list of int or None
@keyword spin_names: The list of spin names.
@type spin_names: list of str or None
@keyword res_nums: The list of residue numbers.
@type res_nums: list of int or None
@keyword res_names: The list of residue names.
@type res_names: list of str or None
@keyword mol_names: The list of molecule names.
@type mol_names: list of str or None
@keyword isotopes: The optional list of isotope types.
@type isotopes: list of str or None
@keyword elements: The optional list of element types.
@type elements: list of str or None
"""
# The blank data.
if not spin_nums:
spin_nums = [None] * N
if not spin_names:
spin_names = [None] * N
if not res_nums:
res_nums = [None] * N
if not res_names:
res_names = [None] * N
if not mol_names:
mol_names = [None] * N
# Generate the spin IDs.
spin_ids = []
for i in range(N):
spin_ids.append(
generate_spin_id(mol_name=mol_names[i],
res_num=res_nums[i],
spin_name=spin_names[i]))
# Loop over the spin data.
for i in range(N):
# The spin already exists.
spin = return_spin(spin_id=spin_ids[i])
if spin:
continue
# Create the spin.
spin = create_spin(spin_num=spin_nums[i],
spin_name=spin_names[i],
res_num=res_nums[i],
res_name=res_names[i],
mol_name=mol_names[i])[0]
# Set the spin isotope and element.
spin_id = spin._spin_ids[0]
if elements:
set_spin_element(spin_id=spin_id, element=elements[i], force=True)
if isotopes and elements:
isotope = "%s%s" % (isotopes[i], elements[i])
set_spin_isotope(spin_id=spin_id, isotope=isotope, force=True)
# Clean up the spin metadata.
metadata_cleanup()
def copy(pipe_from=None, pipe_to=None, preserve_select=False, empty=True, verbose=True):
"""Copy the molecule, residue, and spin sequence data from one data pipe to another.
@keyword pipe_from: The data pipe to copy the sequence data from. This defaults to the current data pipe.
@type pipe_from: str
@keyword pipe_to: The data pipe to copy the sequence data to. This defaults to the current data pipe.
@type pipe_to: str
@keyword preserve_select: A flag which if True will cause spin selections to be preserved.
@type preserve_select: bool
@keyword empty: A flag which if True will create a molecule, residue, and spin sequence in the target pipe lacking all of the spin data of the source pipe. If False, then the spin data will also be copied.
@keyword verbose: A flag which if True will cause info about each spin to be printed out as the sequence is generated.
@type verbose: bool
"""
# Defaults.
if pipe_from == None and pipe_to == None:
raise RelaxError("The pipe_from and pipe_to arguments cannot both be set to None.")
elif pipe_from == None:
pipe_from = pipes.cdp_name()
elif pipe_to == None:
pipe_to = pipes.cdp_name()
# Test if the pipe_from and pipe_to data pipes exist.
check_pipe(pipe_from)
check_pipe(pipe_to)
# Test if pipe_from contains sequence data.
if not exists_mol_res_spin_data(pipe_from):
raise RelaxNoSequenceError
# Test if pipe_to contains sequence data.
if exists_mol_res_spin_data(pipe_to):
raise RelaxSequenceError
# Loop over the spins of the pipe_from data pipe.
for spin, mol_name, res_num, res_name in spin_loop(pipe=pipe_from, full_info=True):
# Generate the new sequence.
new_spin = create_spin(spin_num=spin.num, spin_name=spin.name, res_num=res_num, res_name=res_name, mol_name=mol_name, pipe=pipe_to)
# Preserve selection.
if preserve_select:
new_spin.select = spin.select
else:
select = True
# Copy all the spin data.
if not empty:
# Duplicate all the objects of the container.
for name in dir(spin):
# Skip special objects.
if search('^_', name):
continue
# Skip the spin ID.
#if name in ['spin_id']:
# continue
# Skip class methods.
if name in spin.__class__.__dict__:
continue
# Duplicate all other objects.
obj = deepcopy(getattr(spin, name))
setattr(new_spin, name, obj)
# Print out.
if verbose:
display(mol_name_flag=True, res_num_flag=True, res_name_flag=True, spin_num_flag=True, spin_name_flag=True)
def copy(pipe_from=None, pipe_to=None, preserve_select=False, empty=True, verbose=True):
"""Copy the molecule, residue, and spin sequence data from one data pipe to another.
@keyword pipe_from: The data pipe to copy the sequence data from. This defaults to the current data pipe.
@type pipe_from: str
@keyword pipe_to: The data pipe to copy the sequence data to. This defaults to the current data pipe.
@type pipe_to: str
@keyword preserve_select: A flag which if True will cause spin selections to be preserved.
@type preserve_select: bool
@keyword empty: A flag which if True will create a molecule, residue, and spin sequence in the target pipe lacking all of the spin data of the source pipe. If False, then the spin data will also be copied.
@keyword verbose: A flag which if True will cause info about each spin to be printed out as the sequence is generated.
@type verbose: bool
"""
# Defaults.
if pipe_from == None and pipe_to == None:
raise RelaxError("The pipe_from and pipe_to arguments cannot both be set to None.")
elif pipe_from == None:
pipe_from = pipes.cdp_name()
elif pipe_to == None:
pipe_to = pipes.cdp_name()
# Test if the pipe_from and pipe_to data pipes exist.
check_pipe(pipe_from)
check_pipe(pipe_to)
# Test if pipe_from contains sequence data.
if not exists_mol_res_spin_data(pipe_from):
raise RelaxNoSequenceError
# Test if pipe_to contains sequence data.
if exists_mol_res_spin_data(pipe_to):
raise RelaxSequenceError
# Loop over the spins of the pipe_from data pipe.
for spin, mol_name, res_num, res_name in spin_loop(pipe=pipe_from, full_info=True):
# Generate the new sequence.
new_spin = create_spin(spin_num=spin.num, spin_name=spin.name, res_num=res_num, res_name=res_name, mol_name=mol_name, pipe=pipe_to)[0]
# Preserve selection.
if preserve_select:
new_spin.select = spin.select
else:
select = True
# Copy all the spin data.
if not empty:
# Duplicate all the objects of the container.
for name in dir(spin):
# Skip special objects.
if search('^_', name):
continue
# Skip the spin ID.
#if name in ['spin_id']:
# continue
# Skip class methods.
if name in spin.__class__.__dict__:
continue
# Duplicate all other objects.
obj = deepcopy(getattr(spin, name))
setattr(new_spin, name, obj)
# Print out.
if verbose:
display(mol_name_flag=True, res_num_flag=True, res_name_flag=True, spin_num_flag=True, spin_name_flag=True)
def read_spins(file=None,
dir=None,
dim=1,
spin_id_col=None,
mol_name_col=None,
res_num_col=None,
res_name_col=None,
spin_num_col=None,
spin_name_col=None,
sep=None,
spin_id=None,
verbose=True):
"""Read the peak intensity data.
@keyword file: The name of the file containing the peak intensities.
@type file: str
@keyword dir: The directory where the file is located.
@type dir: str
@keyword dim: The dimension of the peak list to associate the data with.
@type dim: int
@keyword spin_id_col: The column containing the spin ID strings (used by the generic intensity file format). If supplied, the mol_name_col, res_name_col, res_num_col, spin_name_col, and spin_num_col arguments must be none.
@type spin_id_col: int or None
@keyword mol_name_col: The column containing the molecule name information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type mol_name_col: int or None
@keyword res_name_col: The column containing the residue name information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type res_name_col: int or None
@keyword res_num_col: The column containing the residue number information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type res_num_col: int or None
@keyword spin_name_col: The column containing the spin name information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type spin_name_col: int or None
@keyword spin_num_col: The column containing the spin number information (used by the generic intensity file format). If supplied, spin_id_col must be None.
@type spin_num_col: int or None
@keyword sep: The column separator which, if None, defaults to whitespace.
@type sep: str or None
@keyword spin_id: The spin ID string used to restrict data loading to a subset of all spins. If 'auto' is provided for a NMRPipe seriesTab formatted file, the ID's are auto generated in form of Z_Ai.
@type spin_id: None or str
@keyword verbose: A flag which if True will cause all relaxation data loaded to be printed out.
@type verbose: bool
"""
# Data checks.
check_pipe()
# Check the file name.
if file == None:
raise RelaxError("The file name must be supplied.")
# Read the peak list data.
peak_list = read_peak_list(file=file,
dir=dir,
spin_id_col=spin_id_col,
mol_name_col=mol_name_col,
res_num_col=res_num_col,
res_name_col=res_name_col,
spin_num_col=spin_num_col,
spin_name_col=spin_name_col,
sep=sep,
spin_id=spin_id)
# Loop over the peak_list.
created_spins = []
for assign in peak_list:
mol_name = assign.mol_names[dim - 1]
res_num = assign.res_nums[dim - 1]
res_name = assign.res_names[dim - 1]
spin_num = assign.spin_nums[dim - 1]
spin_name = assign.spin_names[dim - 1]
# Generate the spin_id.
spin_id = generate_spin_id_unique(mol_name=mol_name,
res_num=res_num,
res_name=res_name,
spin_name=spin_name)
# Check if the spin already exist.
if return_spin(spin_id=spin_id) == None:
# Create the spin if not exist.
create_spin(spin_num=spin_num,
spin_name=spin_name,
res_num=res_num,
res_name=res_name,
mol_name=mol_name)
# Test that data exists.
check_mol_res_spin_data()
def _read_1_2_results(self, file_data, verbosity=1):
"""Read the relax 1.2 model-free results file.
@param file_data: The processed results file data.
@type file_data: list of lists of str
@keyword verbosity: A variable specifying the amount of information to print. The higher
the value, the greater the verbosity.
@type verbosity: int
"""
# Extract and remove the header.
header = file_data[0]
file_data = file_data[1:]
# Sort the column numbers.
col = self._read_1_2_col_numbers(header)
# Test the file.
if len(col) < 2:
raise RelaxInvalidDataError
# Initialise some data structures and flags.
sim_num = None
sims = []
all_select_sim = []
diff_data_set = False
diff_error_set = False
diff_sim_set = None
model_type = None
pdb = False
pdb_model = None
pdb_heteronuc = None
pdb_proton = None
ri_labels = None
# Generate the sequence.
if verbosity:
print("\nGenerating the sequence.")
for file_line in file_data:
# The data set.
data_set = file_line[col['data_set']]
# Stop creating the sequence once the data_set is no longer 'value'.
if data_set != 'value':
break
# Sequence.
self._generate_sequence(file_line, col, verbosity)
# Count the number of simulations.
for file_line in file_data:
# The data set.
data_set = file_line[col['data_set']]
# Simulation number.
if data_set != 'value' and data_set != 'error':
# Extract the number from the data_set string.
sim_num = data_set.split('_')
try:
sim_num = int(sim_num[1])
except:
raise RelaxError("The simulation number '%s' is invalid." % sim_num)
if sim_num != None:
cdp.sim_number = sim_num + 1
# Loop over the lines of the file data.
for file_line in file_data:
# The data set.
data_set = file_line[col['data_set']]
# The spin info (for relax 1.2).
if 'num' in col:
mol_name = None
res_num = int(file_line[col['num']])
res_name = file_line[col['name']]
spin_num = None
spin_name = None
if col['nucleus'] < len(file_line) and search('N', file_line[col['nucleus']]):
spin_name = 'N'
if col['nucleus'] < len(file_line) and search('C', file_line[col['nucleus']]):
spin_name = 'C'
# The spin info.
else:
mol_name = file_line[col['mol_name']]
res_num = int(file_line[col['res_num']])
res_name = file_line[col['res_name']]
spin_num = int(file_line[col['spin_num']])
spin_name = file_line[col['spin_name']]
# Create the spin ID.
spin_id = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name)
# Get the spin container.
spin = return_spin(spin_id)
# Create a new spin container for the proton, then set up a dipole interaction between the two spins.
if data_set == 'value' and spin_name:
h_spin = create_spin(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_name='H')
h_spin.select = False
h_spin.element = 'H'
h_spin.isotope = '1H'
spin_id2 = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_name='H')
define(spin_id, spin_id2, verbose=False)
# Backwards compatibility for the reading of the results file from versions 1.2.0 to 1.2.9.
if len(file_line) == 4:
continue
# Set the nuclear isotope types and spin names (absent from the 1.2 results file).
if data_set == 'value':
if file_line[col['nucleus']] != 'None':
if search('N', file_line[col['nucleus']]):
spin.isotope = '15N'
if spin.name == None:
spin.name = 'N'
elif search('C', file_line[col['nucleus']]):
spin.isotope = '13C'
if spin.name == None:
spin.name = 'C'
# Simulation number.
if data_set != 'value' and data_set != 'error':
# Extract the number from the data_set string.
sim_num = data_set.split('_')
try:
sim_num = int(sim_num[1])
except:
raise RelaxError("The simulation number '%s' is invalid." % sim_num)
# A new simulation number.
if sim_num not in sims:
# Update the sims array and append an empty array to the selected sims array.
sims.append(sim_num)
all_select_sim.append([])
# Selected simulations.
all_select_sim[-1].append(bool(file_line[col['select']]))
# Initial printout for the simulation.
if verbosity:
if diff_sim_set == None:
print("\nLoading simulations.")
if sim_num != diff_sim_set:
print(data_set)
# Diffusion tensor data.
if data_set == 'value' and not diff_data_set:
self._read_1_2_set_diff_tensor(file_line, col, data_set, verbosity, sim_num=sim_num)
diff_data_set = True
# Diffusion tensor errors.
elif data_set == 'error' and not diff_error_set:
self._read_1_2_set_diff_tensor(file_line, col, data_set, verbosity, sim_num=sim_num)
diff_error_set = True
# Diffusion tensor simulation data.
elif data_set != 'value' and data_set != 'error' and sim_num != diff_sim_set:
# Set up the diffusion tensor.
if not hasattr(cdp.diff_tensor, '_sim_num') or cdp.diff_tensor._sim_num == None:
cdp.diff_tensor.set_sim_num(cdp.sim_number)
self._read_1_2_set_diff_tensor(file_line, col, data_set, verbosity, sim_num=sim_num)
diff_sim_set = sim_num
# Model type.
if model_type == None:
self._fix_params(file_line, col, verbosity)
# PDB.
if not pdb:
if self._load_structure(file_line, col, verbosity):
pdb = True
# XH vector, heteronucleus, and proton.
if data_set == 'value':
self._set_xh_vect(file_line, col, spin, spin_id1=spin_id, spin_id2=spin_id2, verbosity=verbosity)
# Relaxation data.
self._load_relax_data(file_line, col, data_set, spin, verbosity)
# Model-free data.
self._load_model_free_data(file_line, col, data_set, spin, spin_id, verbosity)
# Set up the simulations.
if len(sims):
# Convert the selected simulation array of arrays into a Numeric matrix, transpose it, then convert back to a Python list.
all_select_sim = transpose(array(all_select_sim))
all_select_sim = all_select_sim.tolist()
# Set up the Monte Carlo simulations.
pipe_control.monte_carlo.setup(number=len(sims), all_select_sim=all_select_sim)
# Turn the simulation state to off!
cdp.sim_state = False
def read_1_2_results(file_data, verbosity=1):
"""Read the relax 1.2 model-free results file.
@param file_data: The processed results file data.
@type file_data: list of lists of str
@keyword verbosity: A variable specifying the amount of information to print. The higher
the value, the greater the verbosity.
@type verbosity: int
"""
# Extract and remove the header.
header = file_data[0]
file_data = file_data[1:]
# Sort the column numbers.
col = read_1_2_col_numbers(header)
# Test the file.
if len(col) < 2:
raise RelaxInvalidDataError
# Initialise some data structures and flags.
sim_num = None
sims = []
all_select_sim = []
diff_data_set = False
diff_error_set = False
diff_sim_set = None
model_type = None
pdb = False
pdb_model = None
pdb_heteronuc = None
pdb_proton = None
ri_labels = None
# Generate the sequence.
if verbosity:
print("\nGenerating the sequence.")
for file_line in file_data:
# The data set.
data_set = file_line[col['data_set']]
# Stop creating the sequence once the data_set is no longer 'value'.
if data_set != 'value':
break
# Sequence.
generate_sequence(file_line, col, verbosity)
# Count the number of simulations.
for file_line in file_data:
# The data set.
data_set = file_line[col['data_set']]
# Simulation number.
if data_set != 'value' and data_set != 'error':
# Extract the number from the data_set string.
sim_num = data_set.split('_')
try:
sim_num = int(sim_num[1])
except:
raise RelaxError("The simulation number '%s' is invalid." %
sim_num)
if sim_num != None:
cdp.sim_number = sim_num + 1
# Loop over the lines of the file data.
for file_line in file_data:
# The data set.
data_set = file_line[col['data_set']]
# The spin info (for relax 1.2).
if 'num' in col:
mol_name = None
res_num = int(file_line[col['num']])
res_name = file_line[col['name']]
spin_num = None
spin_name = None
if col['nucleus'] < len(file_line) and search(
'N', file_line[col['nucleus']]):
spin_name = 'N'
if col['nucleus'] < len(file_line) and search(
'C', file_line[col['nucleus']]):
spin_name = 'C'
# The spin info.
else:
mol_name = file_line[col['mol_name']]
res_num = int(file_line[col['res_num']])
res_name = file_line[col['res_name']]
spin_num = int(file_line[col['spin_num']])
spin_name = file_line[col['spin_name']]
# Create the spin ID.
spin_id = generate_spin_id_unique(mol_name=mol_name,
res_num=res_num,
res_name=res_name,
spin_num=spin_num,
spin_name=spin_name)
# Get the spin container.
spin = return_spin(spin_id=spin_id)
# Create a new spin container for the proton, then set up a dipole interaction between the two spins.
if data_set == 'value' and spin_name:
h_spin = create_spin(mol_name=mol_name,
res_num=res_num,
res_name=res_name,
spin_name='H')[0]
h_spin.select = False
h_spin.element = 'H'
h_spin.isotope = '1H'
spin_id2 = generate_spin_id_unique(mol_name=mol_name,
res_num=res_num,
res_name=res_name,
spin_name='H')
define_dipole_pair(spin_id1=spin_id,
spin_id2=spin_id2,
spin1=spin,
spin2=h_spin,
verbose=False)
# Backwards compatibility for the reading of the results file from versions 1.2.0 to 1.2.9.
if len(file_line) == 4:
continue
# Set the nuclear isotope types and spin names (absent from the 1.2 results file).
if data_set == 'value':
if file_line[col['nucleus']] != 'None':
if search('N', file_line[col['nucleus']]):
spin.isotope = '15N'
if spin.name == None:
spin.name = 'N'
elif search('C', file_line[col['nucleus']]):
spin.isotope = '13C'
if spin.name == None:
spin.name = 'C'
# Simulation number.
if data_set != 'value' and data_set != 'error':
# Extract the number from the data_set string.
sim_num = data_set.split('_')
try:
sim_num = int(sim_num[1])
except:
raise RelaxError("The simulation number '%s' is invalid." %
sim_num)
# A new simulation number.
if sim_num not in sims:
# Update the sims array and append an empty array to the selected sims array.
sims.append(sim_num)
all_select_sim.append([])
# Selected simulations.
all_select_sim[-1].append(bool(file_line[col['select']]))
# Initial printout for the simulation.
if verbosity:
if diff_sim_set == None:
print("\nLoading simulations.")
if sim_num != diff_sim_set:
print(data_set)
# Diffusion tensor data.
if data_set == 'value' and not diff_data_set:
read_1_2_set_diff_tensor(file_line,
col,
data_set,
verbosity,
sim_num=sim_num)
diff_data_set = True
# Diffusion tensor errors.
elif data_set == 'error' and not diff_error_set:
read_1_2_set_diff_tensor(file_line,
col,
data_set,
verbosity,
sim_num=sim_num)
diff_error_set = True
# Diffusion tensor simulation data.
elif data_set != 'value' and data_set != 'error' and sim_num != diff_sim_set:
# Set up the diffusion tensor.
if not hasattr(cdp.diff_tensor,
'_sim_num') or cdp.diff_tensor._sim_num == None:
cdp.diff_tensor.set_sim_num(cdp.sim_number)
read_1_2_set_diff_tensor(file_line,
col,
data_set,
verbosity,
sim_num=sim_num)
diff_sim_set = sim_num
# Model type.
if model_type == None:
fix_params(file_line, col, verbosity)
# PDB.
if not pdb:
if load_structure(file_line, col, verbosity):
pdb = True
# XH vector, heteronucleus, and proton.
if data_set == 'value':
set_xh_vect(file_line,
col,
spin,
spin_id1=spin_id,
spin_id2=spin_id2,
spin_hash1=spin._hash,
spin_hash2=h_spin._hash,
verbosity=verbosity)
# Relaxation data.
load_relax_data(file_line, col, data_set, spin, verbosity)
# Model-free data.
load_model_free_data(file_line, col, data_set, spin, spin_id,
verbosity)
# Set up the simulations.
if len(sims):
# Convert the selected simulation array of arrays into a Numeric matrix, transpose it, then convert back to a Python list.
all_select_sim = transpose(array(all_select_sim))
all_select_sim = all_select_sim.tolist()
# Set up the Monte Carlo simulations.
pipe_control.error_analysis.monte_carlo_setup(
number=len(sims), all_select_sim=all_select_sim)
# Turn the simulation state to off!
cdp.sim_state = False
def load_spins(spin_id=None, str_id=None, mol_name_target=None, ave_pos=False):
"""Load the spins from the structural object into the relax data store.
@keyword spin_id: The molecule, residue, and spin identifier string.
@type spin_id: str
@keyword str_id: The structure identifier. This can be the file name, model number, or structure number.
@type str_id: int or str
@keyword mol_name: The name of target molecule container, overriding the name of the loaded structures
@type mol_name: str or None
@keyword ave_pos: A flag specifying if the average atom position or the atom position from all loaded structures is loaded into the SpinContainer.
@type ave_pos: bool
"""
# Test if the current data pipe exists.
pipes.test()
# Test if the structure exists.
if not hasattr(cdp, 'structure') or not cdp.structure.num_models() or not cdp.structure.num_molecules():
raise RelaxNoPdbError
# Print out.
print("Adding the following spins to the relax data store.\n")
# Init the data for printing out.
mol_names = []
res_nums = []
res_names = []
spin_nums = []
spin_names = []
# Loop over all atoms of the spin_id selection.
for mol_name, res_num, res_name, atom_num, atom_name, element, pos in cdp.structure.atom_loop(atom_id=spin_id, str_id=str_id, mol_name_flag=True, res_num_flag=True, res_name_flag=True, atom_num_flag=True, atom_name_flag=True, element_flag=True, pos_flag=True, ave=ave_pos):
# Override the molecule name.
if mol_name_target:
mol_name = mol_name_target
# Remove the '+' regular expression character from the mol, res, and spin names!
if mol_name and search('\+', mol_name):
mol_name = mol_name.replace('+', '')
if res_name and search('\+', res_name):
res_name = res_name.replace('+', '')
if atom_name and search('\+', atom_name):
atom_name = atom_name.replace('+', '')
# Generate a spin ID for the current atom.
id = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=atom_num, spin_name=atom_name)
# Create the spin.
try:
spin_cont = create_spin(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=atom_num, spin_name=atom_name)
# Otherwise, get the spin container.
except RelaxError:
spin_cont = return_spin(id)
# Append all the spin ID info for printing later.
if mol_name_target:
mol_names.append(mol_name_target)
else:
mol_names.append(mol_name)
res_nums.append(res_num)
res_names.append(res_name)
spin_nums.append(atom_num)
spin_names.append(atom_name)
# Position vector.
spin_cont.pos = pos
# Add the element.
spin_cont.element = element
# Catch no data.
if len(mol_names) == 0:
warn(RelaxWarning("No spins matching the '%s' ID string could be found." % spin_id))
return
# Print out.
write_spin_data(file=sys.stdout, mol_names=mol_names, res_nums=res_nums, res_names=res_names, spin_nums=spin_nums, spin_names=spin_names)
