def pdb(r=1.02, file_name='uniform.pdb', inc=None):
"""Create the bond vector distribution and save the PDB file."""
# Create the structural object.
structure = Internal()
# Add a molecule.
structure.add_molecule(name='dist')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Get the polar and azimuthal angles for the distribution.
phi, theta = angles_uniform(inc)
# Get the uniform vector distribution.
vectors = vect_dist_spherical_angles(inc=inc, distribution='uniform')
# Loop over the radial array of vectors (change in longitude).
atom_num = 1
new_vectors = []
for i in range(len(theta)):
# Loop over the vectors of the radial array (change in latitude).
for j in range(len(phi)):
# The index.
index = i + j*len(theta)
# The atomic positions.
pos1 = vectors[index] * 10
pos2 = pos1 + vectors[index] * r
# Store the rearranged vector (truncated as in the PDB).
trunc_vect = zeros(3, float64)
for k in range(3):
trunc_vect[k] = float("%.3f" % pos2[k]) - float("%.3f" % pos1[k])
new_vectors.append(trunc_vect)
# Residue number.
res = (atom_num + 1) / 2
# Add the vector as a N-H atom pair.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num, atom_name='N', res_name=AA_TABLE[SEQ[index]].upper(), res_num=res, pos=pos1, element='N')
mol.atom_add(pdb_record='ATOM', atom_num=atom_num+1, atom_name='H', res_name=AA_TABLE[SEQ[index]].upper(), res_num=res, pos=pos2, element='H')
# Connect.
mol.atom_connect(atom_num-1, atom_num)
# Move 2 atoms forwards.
atom_num += 2
# The PDB file.
file = open_write_file(file_name, force=True)
structure.write_pdb(file)
file.close()
# Return the vectors in the diffusion frame.
return new_vectors
def create_cone_pdb(mol=None, cone=None, start_res=1, apex=None, axis=None, R=None, inc=None, scale=30.0, distribution='regular', file=None, dir=None, force=False, axis_flag=True):
"""Create a PDB representation of the given cone object.
@keyword mol: The molecule container.
@type mol: MolContainer instance
@keyword cone: The cone object. This should provide the limit_check() method with determines the limits of the distribution accepting two arguments, the polar angle phi and the azimuthal angle theta, and return True if the point is in the limits or False if outside. It should also provide the theta_max() method for returning the theta value for the given phi, the phi_max() method for returning the phi value for the given theta.
@type cone: class instance
@keyword start_res: The starting residue number.
@type start_res: str
@keyword apex: The apex of the cone.
@type apex: rank-1, 3D numpy array
@keyword axis: The central axis of the cone. If not supplied, the z-axis will be used.
@type axis: rank-1, 3D numpy array
@keyword R: The rotation matrix.
@type R: rank-2, 3D numpy array
@keyword inc: The increment number used to determine the number of latitude and longitude lines.
@type inc: int
@keyword scale: The scaling factor to stretch the unit cone by.
@type scale: float
@keyword distribution: The type of point distribution to use. This can be 'uniform' or 'regular'.
@type distribution: str
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set to True will overwrite any pre-existing file.
@type force: bool
@keyword axis_flag: A flag which if True will create the cone's axis.
@type axis_flag: bool
"""
# No molecule supplied.
if mol == None:
# Create the structural object.
structure = Internal()
# Add a molecule.
structure.add_molecule(name='cone')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Create the object.
cone(mol=mol, cone=cone, start_res=start_res, apex=apex, axis=axis, R=R, inc=inc, scale=scale, distribution=distribution, axis_flag=axis_flag)
# Create the PDB file.
if file != None:
print("\nGenerating the PDB file.")
pdb_file = open_write_file(file_name=file, dir=dir, force=force)
structure.write_pdb(pdb_file)
pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
cdp.result_files.append(['cone_pdb', 'Cone PDB', get_file_path(file, dir)])
status.observers.result_file.notify()
def create_rotor_pdb(file=None, dir=None, rotor_angle=None, axis=None, axis_pt=True, centre=None, span=2e-9, blade_length=5e-10, force=False, staggered=False):
"""Create a PDB representation of a rotor motional model.
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword rotor_angle: The angle of the rotor motion in degrees.
@type rotor_angle: float
@keyword axis: The vector defining the rotor axis.
@type axis: numpy rank-1, 3D array
@keyword axis_pt: A point lying anywhere on the rotor axis. This is used to define the position of the axis in 3D space.
@type axis_pt: numpy rank-1, 3D array
@keyword centre: The central point of the representation. If this point is not on the rotor axis, then the closest point on the axis will be used for the centre.
@type centre: numpy rank-1, 3D array
@keyword span: The distance from the central point to the rotor blades (meters).
@type span: float
@keyword blade_length: The length of the representative rotor blades.
@type blade_length: float
@keyword force: A flag which if set will overwrite any pre-existing file.
@type force: bool
@keyword staggered: A flag which if True will cause the rotor blades to be staggered. This is used to avoid blade overlap.
@type staggered: bool
"""
# Test if the current pipe exists.
pipes.test()
# Convert the angle to radians.
rotor_angle = rotor_angle / 360.0 * 2.0 * pi
# Create the structural object.
structure = Internal()
# Generate the rotor object.
rotor_pdb(structure=structure, rotor_angle=rotor_angle, axis=axis, axis_pt=axis_pt, centre=centre, span=span, blade_length=blade_length, staggered=staggered)
# Print out.
print("\nGenerating the PDB file.")
# Open the PDB file for writing.
tensor_pdb_file = open_write_file(file, dir, force=force)
# Write the data.
structure.write_pdb(tensor_pdb_file)
# Close the file.
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append(['rotor_pdb', 'Rotor PDB', get_file_path(file, dir)])
status.observers.result_file.notify()
def setUp(self):
"""Set up for all the internal relax structural object unit tests."""
# The path to a PDB file.
self.test_pdb_path = status.install_path+sep+'test_suite'+sep+'shared_data'+sep+'structures'+sep+'Ap4Aase_res1-12.pdb'
expanded = path.split(self.test_pdb_path)
self.test_pdb_dir = expanded[0]
self.test_pdb_file_name = expanded[1]
self.test_pdb_root = file_root(self.test_pdb_path)
# Instantiate the structural data object.
self.data = Internal()
# Instantiate a MolContainer object.
self.mol_cont = MolContainer()
class Test_internal(UnitTestCase):
"""Unit tests for the functions of the 'pipe_control.structure.internal' module."""
def setUp(self):
"""Set up for all the internal relax structural object unit tests."""
# The path to a PDB file.
self.test_pdb_path = status.install_path+sep+'test_suite'+sep+'shared_data'+sep+'structures'+sep+'Ap4Aase_res1-12.pdb'
expanded = path.split(self.test_pdb_path)
self.test_pdb_dir = expanded[0]
self.test_pdb_file_name = expanded[1]
self.test_pdb_root = file_root(self.test_pdb_path)
# Instantiate the structural data object.
self.data = Internal()
# Instantiate a MolContainer object.
self.mol_cont = MolContainer()
def tearDown(self):
"""Reset the relax data storage object."""
# Delete the structural data object.
del self.data
# Reset relax.
reset()
def test__trim_helix1(self):
"""1st test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
# Residues deleted before the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[1, 2, 3, 22], res_data=res_data)
# Test that nothing has happened.
self.assertEqual(helix, new_helix)
def test__trim_helix2(self):
"""2nd test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
# Residues deleted after the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[51, 52, 53], res_data=res_data)
# Test that nothing has happened.
self.assertEqual(helix, new_helix)
def test__trim_helix3(self):
"""3rd test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'GLU', 24, 'A', 'GLU', 34, 1, 11]
# Trim the start of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[21, 22, 23], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix4(self):
"""4th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'VAL', 26, 'A', 'GLU', 34, 1, 9]
# Trim the start of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[21, 22, 23, 24, 25], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix5(self):
"""5th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'VAL', 26, 'A', 'GLU', 34, 1, 9]
# Trim the start of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[21, 22, 23, 24, 25, 30], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix6(self):
"""6th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'VAL', 26, 'A', 'GLU', 34, 1, 9]
# Trim the start of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[21, 22, 23, 24, 25, 40], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix7(self):
"""7th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'ILE', 23, 'A', 'LYS', 33, 1, 11]
# Trim the end of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[34, 35, 36], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix8(self):
"""8th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
# Trim nothing.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[35, 36], res_data=res_data)
# Test the trimming.
self.assertEqual(helix, new_helix)
def test__trim_helix9(self):
"""9th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'ILE', 23, 'A', 'ILE', 30, 1, 8]
# Trim the end of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[31, 32, 33, 34, 35], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix10(self):
"""10th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'ILE', 23, 'A', 'GLN', 31, 1, 9]
# Trim the end of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[24, 32, 33, 34, 35], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix11(self):
"""11th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'ASN', 25, 'A', 'GLN', 31, 1, 7]
# Trim the both ends of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[22, 23, 24, 32, 33, 34, 35], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix12(self):
"""12th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
trimmed_helix = ['H1', 'A', 'ASN', 25, 'A', 'GLN', 31, 1, 7]
# Trim the both ends of the helix.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[22, 23, 24, 27, 32, 33, 34, 35], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_helix, new_helix)
def test__trim_helix13(self):
"""13th test of the Internal._trim_helix() method."""
# The helix metadata of the internal structural object.
helix = ['H1', 'A', 'ILE', 23, 'A', 'GLU', 34, 1, 12]
# Trim everything.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_helix = self.data._trim_helix(helix=helix, trim_res_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], res_data=res_data)
# Test the trimming.
self.assertEqual(None, new_helix)
def test__trim_sheet1(self):
"""1st test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Residues deleted before the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[1, 2, 3, 22], res_data=res_data)
# Test that nothing has happened.
self.assertEqual(sheet, new_sheet)
def test__trim_sheet2(self):
"""2nd test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Residues deleted after the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[51, 52, 53], res_data=res_data)
# Test that nothing has happened.
self.assertEqual(sheet, new_sheet)
def test__trim_sheet3(self):
"""3rd test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'LYS', 'A', 11, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the start of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[8, 9, 10], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet4(self):
"""4th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'ILE', 'A', 13, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the start of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[8, 9, 10, 11, 12], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet5(self):
"""5th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'ILE', 'A', 13, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the start of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[8, 9, 10, 11, 12, 15], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet6(self):
"""6th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'ILE', 'A', 13, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the start of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[8, 9, 10, 11, 12, 30], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet7(self):
"""7th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'GLU', 'A', 16, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the end of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[17, 18, 19], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet8(self):
"""8th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim nothing.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[18, 19], res_data=res_data)
# Test the trimming.
self.assertEqual(sheet, new_sheet)
def test__trim_sheet9(self):
"""9th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'THR', 'A', 14, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the end of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[15, 16, 17, 18, 19], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet10(self):
"""10th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'THR', 'A', 14, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the end of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[11, 15, 16, 17, 18, 19], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet11(self):
"""11th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'LYS', 'A', 11, None, 'LEU', 'A', 15, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the both ends of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[9, 10, 16, 17, 18, 19], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet12(self):
"""12th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
trimmed_sheet = [1, 'BET', 5, 'LYS', 'A', 11, None, 'LEU', 'A', 15, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim the both ends of the sheet.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[9, 10, 13, 16, 17, 18, 19], res_data=res_data)
# Test the trimming.
self.assertEqual(trimmed_sheet, new_sheet)
def test__trim_sheet13(self):
"""13th test of the Internal._trim_sheet() method."""
# The sheet metadata of the internal structural object.
sheet = [1, 'BET', 5, 'GLY', 'A', 10, None, 'VAL', 'A', 17, None, 0, None, None, None, None, None, None, None, None, None, None]
# Trim everything.
res_data = {1: 'MET', 2: 'GLN', 3: 'ILE', 4: 'PHE', 5: 'VAL', 6: 'LYS', 7: 'THR', 8: 'LEU', 9: 'THR', 10: 'GLY', 11: 'LYS', 12: 'THR', 13: 'ILE', 14: 'THR', 15: 'LEU', 16: 'GLU', 17: 'VAL', 18: 'GLU', 19: 'PRO', 20: 'SER', 21: 'ASP', 22: 'THR', 23: 'ILE', 24: 'GLU', 25: 'ASN', 26: 'VAL', 27: 'LYS', 28: 'ALA', 29: 'LYS', 30: 'ILE', 31: 'GLN', 32: 'ASP', 33: 'LYS', 34: 'GLU'}
new_sheet = self.data._trim_sheet(sheet=sheet, trim_res_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35], res_data=res_data)
# Test the trimming.
self.assertEqual(None, new_sheet)
def test_atom_loop(self):
"""Test the Internal.atom_loop() method."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# Loop over the atoms.
atom_count = 0
for atom in self.data.atom_loop():
atom_count = atom_count + 1
# Test the number of atoms looped over.
self.assertEqual(atom_count, 150)
def test_atom_loop_mol_selection(self):
"""Test the Internal.atom_loop() method with the '#XXX' mol selection."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# Loop over the atoms.
atom_count = 0
for atom in self.data.atom_loop(atom_id='#XXX'):
atom_count = atom_count + 1
# Test the number of atoms looped over.
self.assertEqual(atom_count, 0)
def test_atom_loop_res_selection1(self):
"""Test the Internal.atom_loop() method with the ':8' res selection."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# Loop over the atoms.
atom_count = 0
for res_num, res_name in self.data.atom_loop(atom_id=':8', res_num_flag=True, res_name_flag=True):
# Test the residue name and number.
self.assertEqual(res_num, 8)
self.assertEqual(res_name, 'SER')
# Increment the atom count.
atom_count = atom_count + 1
# Test the number of atoms looped over.
self.assertEqual(atom_count, 11)
def test_atom_loop_res_selection2(self):
"""Test the Internal.atom_loop() method with the ':PRO' res selection."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# Loop over the atoms.
atom_count = 0
for atom in self.data.atom_loop(atom_id=':PRO', res_name_flag=True):
# Test the residue name.
self.assertEqual(atom, 'PRO')
# Increment the atom count.
atom_count = atom_count + 1
# Test the number of atoms looped over.
self.assertEqual(atom_count, 42)
def test_atom_loop_spin_selection1(self):
"""Test the Internal.atom_loop() method with the '@CA' spin selection."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# Loop over the atoms.
atom_count = 0
for spin_name in self.data.atom_loop(atom_id='@CA', atom_name_flag=True):
# Test the spin name.
self.assertEqual(spin_name, 'CA')
# Increment the atom count.
atom_count = atom_count + 1
# Test the number of atoms looped over.
self.assertEqual(atom_count, 12)
def test_atom_loop_spin_selection2(self):
"""Test the Internal.atom_loop() method with the '@163' spin selection."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# Loop over the atoms.
atom_count = 0
for mol_name, res_num, res_name, spin_num, spin_name, element, pos in self.data.atom_loop(atom_id='@140', 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):
# Test the spin info.
self.assertEqual(mol_name, self.test_pdb_root+'_mol1')
self.assertEqual(res_num, 11)
self.assertEqual(res_name, 'GLU')
self.assertEqual(spin_num, 140)
self.assertEqual(spin_name, 'OE1')
self.assertEqual(element, 'O')
self.assertEqual(pos.shape, (1, 3))
self.assertEqual(pos[0, 0], float('10.055'))
self.assertEqual(pos[0, 1], float('-2.74'))
self.assertEqual(pos[0, 2], float('-13.193'))
# Increment the atom count.
atom_count = atom_count + 1
# Test the number of atoms looped over.
self.assertEqual(atom_count, 1)
def test_load_pdb(self):
"""Load a PDB file using Internal.load_pdb()."""
# Load the PDB file.
self.data.load_pdb(self.test_pdb_path)
# The ModelContainer and MolContainer.
model = self.data.structural_data[0]
mol = model.mol[0]
# Test the structural data.
self.assertEqual(len(self.data.structural_data), 1)
self.assertEqual(len(model.mol), 1)
self.assertEqual(model.num, 1)
self.assertEqual(mol.mol_name, self.test_pdb_root+'_mol1')
self.assertEqual(mol.file_name, self.test_pdb_file_name)
self.assertEqual(mol.file_path, self.test_pdb_dir)
self.assertEqual(mol.file_model, 1)
self.assertEqual(mol.file_mol_num, 1)
# The real atomic data.
atom_name = ['N', 'CA', '1HA', '2HA', 'C', 'O', '1HT', '2HT', '3HT', 'N', 'CD', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', '1HG', '2HG', '1HD', '2HD', 'C', 'O', 'N', 'H', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', 'HG', 'CD1', '1HD1', '2HD1', '3HD1', 'CD2', '1HD2', '2HD2', '3HD2', 'C', 'O', 'N', 'H', 'CA', '1HA', '2HA', 'C', 'O', 'N', 'H', 'CA', 'HA', 'CB', '1HB', '2HB', 'OG', 'HG', 'C', 'O', 'N', 'H', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', '1HG', '2HG', 'SD', 'CE', '1HE', '2HE', '3HE', 'C', 'O', 'N', 'H', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', 'OD1', 'OD2', 'C', 'O', 'N', 'H', 'CA', 'HA', 'CB', '1HB', '2HB', 'OG', 'HG', 'C', 'O', 'N', 'CD', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', '1HG', '2HG', '1HD', '2HD', 'C', 'O', 'N', 'CD', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', '1HG', '2HG', '1HD', '2HD', 'C', 'O', 'N', 'H', 'CA', 'HA', 'CB', '1HB', '2HB', 'CG', '1HG', '2HG', 'CD', 'OE1', 'OE2', 'C', 'O', 'N', 'H', 'CA', '1HA', '2HA', 'C', 'O']
bonded = [[]]*174
chain_id = [None]*174
element = ['N', 'C', 'H', 'H', 'C', 'O', 'H', 'H', 'H', 'N', 'C', 'C', 'H', 'C', 'H', 'H', 'C', 'H', 'H', 'H', 'H', 'C', 'O', 'N', 'H', 'C', 'H', 'C', 'H', 'H', 'C', 'H', 'C', 'H', 'H', 'H', 'C', 'H', 'H', 'H', 'C', 'O', 'N', 'H', 'C', 'H', 'H', 'C', 'O', 'N', 'H', 'C', 'H', 'C', 'H', 'H', 'O', 'H', 'C', 'O', 'N', 'H', 'C', 'H', 'C', 'H', 'H', 'C', 'H', 'H', 'S', 'C', 'H', 'H', 'H', 'C', 'O', 'N', 'H', 'C', 'H', 'C', 'H', 'H', 'C', 'O', 'O', 'C', 'O', 'N', 'H', 'C', 'H', 'C', 'H', 'H', 'O', 'H', 'C', 'O', 'N', 'C', 'C', 'H', 'C', 'H', 'H', 'C', 'H', 'H', 'H', 'H', 'C', 'O', 'N', 'C', 'C', 'H', 'C', 'H', 'H', 'C', 'H', 'H', 'H', 'H', 'C', 'O', 'N', 'H', 'C', 'H', 'C', 'H', 'H', 'C', 'H', 'H', 'C', 'O', 'O', 'C', 'O', 'N', 'H', 'C', 'H', 'H', 'C', 'O']
pdb_record = ['ATOM']*174
res_name = ['GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'LEU', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'MET', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'ASP', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'SER', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'PRO', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLU', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY', 'GLY']
res_num = [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12]
seg_id = [None]*174
x = [8.442, 7.469, 8.013, 6.825, 6.610, 6.827, 9.398, 8.180, 8.448, 5.613, 5.281, 4.714, 5.222, 3.646, 3.332, 2.800, 4.319, 4.853, 3.587, 6.162, 4.805, 4.075, 3.593, 4.074, 4.475, 3.498, 3.572, 2.025, 1.965, 1.609, 1.176, 1.823, 0.176, 0.096, 0.509, -0.789, 0.474, 0.809, -0.595, 0.707, 4.264, 4.364, 4.809, 4.697, 5.561, 6.220, 6.156, 4.659, 4.746, 3.786, 3.770, 2.851, 2.368, 1.785, 1.177, 1.165, 2.360, 1.690, 3.546, 3.804, 3.814, 3.563, 4.442, 4.984, 5.411, 6.192, 4.872, 6.068, 6.868, 5.332, 6.747, 6.155, 5.409, 6.977, 5.721, 3.369, 2.255, 3.703, 4.604, 2.753, 1.851, 3.329, 4.182, 3.644, 2.319, 1.992, 1.854, 2.419, 1.251, 3.451, 4.359, 3.267, 2.246, 4.223, 4.054, 4.040, 5.573, 6.142, 3.488, 4.276, 2.795, 1.828, 2.929, 2.810, 1.772, 0.912, 2.067, 1.505, 0.464, 2.138, 0.938, 2.273, 4.268, 4.585, 5.076, 4.776, 6.392, 6.925, 7.120, 7.968, 7.464, 6.130, 6.384, 6.135, 4.210, 4.246, 6.325, 5.263, 7.477, 8.281, 7.587, 7.039, 9.047, 9.133, 9.654, 9.590, 10.670, 9.215, 9.190, 10.055, 8.012, 7.007, 7.361, 6.144, 5.925, 5.555, 6.329, 4.814, 4.894, 4.761]
y = [10.188, 9.889, 9.712, 10.745, 8.674, 7.991, 10.291, 11.073, 9.416, 8.385, 9.152, 7.243, 6.302, 7.443, 6.483, 7.963, 8.253, 7.605, 8.842, 9.327, 10.088, 7.251, 8.285, 6.099, 5.309, 5.986, 4.953, 6.396, 7.471, 6.106, 5.775, 5.225, 4.796, 4.954, 3.787, 4.949, 6.853, 7.828, 6.775, 6.720, 6.853, 8.068, 6.222, 5.251, 6.956, 6.273, 7.706, 7.634, 8.841, 6.847, 5.889, 7.360, 6.511, 8.230, 7.620, 8.669, 9.269, 9.652, 8.174, 9.362, 7.546, 6.604, 8.253, 9.095, 7.354, 7.976, 6.886, 6.258, 5.824, 5.499, 6.846, 5.570, 5.985, 5.190, 4.766, 8.771, 8.245, 9.789, 10.161, 10.351, 10.605, 11.610, 11.341, 12.287, 12.322, 11.787, 13.410, 9.322, 9.015, 8.776, 9.052, 7.758, 7.826, 7.990, 8.977, 7.248, 7.894, 8.285, 6.370, 6.214, 5.342, 5.431, 3.973, 3.943, 3.230, 3.234, 2.212, 3.991, 3.892, 3.624, 5.960, 5.908, 3.339, 3.179, 2.980, 3.150, 2.375, 2.876, 2.616, 3.262, 1.675, 3.264, 4.305, 2.758, 4.055, 2.299, 0.876, 0.258, 0.312, 0.871, -1.106, -1.253, -1.489, -2.564, -1.049, -1.041, -1.011, -0.052, -1.970, -2.740, -1.931, -2.037, -1.962, -2.949, -2.983, -3.917, -4.588, -4.488, -3.289, -3.932]
z = [6.302, 7.391, 8.306, 7.526, 7.089, 6.087, 6.697, 5.822, 5.604, 7.943, 9.155, 7.752, 7.908, 8.829, 9.212, 8.407, 9.880, 10.560, 10.415, 9.754, 8.900, 6.374, 5.909, 5.719, 6.139, 4.391, 4.081, 4.415, 4.326, 5.367, 3.307, 2.640, 3.889, 4.956, 3.700, 3.430, 2.493, 2.814, 2.633, 1.449, 3.403, 3.572, 2.369, 2.281, 1.371, 0.855, 1.868, 0.359, 0.149, -0.269, -0.055, -1.268, -1.726, -0.608, 0.037, -1.377, 0.162, 0.731, -2.354, -2.175, -3.496, -3.603, -4.606, -4.199, -5.387, -5.803, -6.196, -4.563, -5.146, -4.350, -3.001, -1.895, -1.241, -1.307, -2.472, -5.551, -5.582, -6.328, -6.269, -7.274, -6.735, -7.913, -8.518, -7.133, -8.791, -9.871, -8.395, -8.346, -8.584, -8.977, -8.732, -10.002, -10.355, -11.174, -11.584, -11.936, -10.759, -11.425, -9.403, -8.469, -9.921, -11.030, -9.410, -8.336, -10.080, -9.428, -10.291, -11.333, -11.606, -12.128, -10.723, -11.893, -9.781, -10.959, -8.768, -7.344, -8.971, -9.765, -7.642, -7.816, -7.251, -6.715, -6.584, -5.765, -7.175, -6.955, -9.288, -9.222, -9.654, -9.696, -10.009, -10.928, -10.249, -10.194, -9.475, -11.596, -11.540, -11.813, -12.724, -13.193, -13.137, -8.947, -7.774, -9.383, -10.338, -8.477, -8.138, -9.017, -7.265, -6.226]
# Test the atomic data.
for i in range(len(mol.atom_name)):
self.assertEqual(mol.atom_name[i], atom_name[i])
self.assertEqual(mol.bonded[i], bonded[i])
self.assertEqual(mol.chain_id[i], chain_id[i])
self.assertEqual(mol.element[i], element[i])
self.assertEqual(mol.pdb_record[i], pdb_record[i])
self.assertEqual(mol.res_name[i], res_name[i])
self.assertEqual(mol.res_num[i], res_num[i])
self.assertEqual(mol.seg_id[i], seg_id[i])
self.assertEqual(mol.x[i], x[i])
self.assertEqual(mol.y[i], y[i])
self.assertEqual(mol.z[i], z[i])
def create_diff_tensor_pdb(scale=1.8e-6, file=None, dir=None, force=False):
"""Create the PDB representation of the diffusion tensor.
@keyword scale: The scaling factor for the diffusion tensor.
@type scale: float
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set to True will overwrite any pre-existing file.
@type force: bool
"""
# Test if the current data pipe exists.
pipes.test()
# Calculate the centre of mass.
com = pipe_centre_of_mass()
# Create the structural object.
structure = Internal()
# Create an array of data pipes to loop over (hybrid support).
if cdp.pipe_type == 'hybrid':
pipe_list = cdp.hybrid_pipes
else:
pipe_list = [pipes.cdp_name()]
# The molecule names.
if cdp.pipe_type == 'hybrid':
mol_names = []
for pipe in pipe_list:
mol_names.append('diff_tensor_' % pipe)
else:
mol_names = ['diff_tensor']
# Loop over the pipes.
for pipe_index in range(len(pipe_list)):
# Get the pipe container.
pipe = pipes.get_pipe(pipe_list[pipe_index])
# Test if the diffusion tensor data is loaded.
if not hasattr(pipe, 'diff_tensor'):
raise RelaxNoTensorError('diffusion')
# Test if a structure has been loaded.
if not hasattr(cdp, 'structure'):
raise RelaxNoPdbError
# Add a new structure.
structure.add_molecule(name=mol_names[pipe_index])
# Alias the single molecule from the single model.
mol = structure.get_molecule(mol_names[pipe_index])
# The diffusion tensor type.
diff_type = pipe.diff_tensor.type
if diff_type == 'spheroid':
diff_type = pipe.diff_tensor.spheroid_type
# Simulation info.
sim_num = None
if hasattr(pipe.diff_tensor, 'tm_sim'):
# The number.
sim_num = len(pipe.diff_tensor.tm_sim)
# Tensor axes.
axes = []
sim_axes = []
if diff_type in ['oblate', 'prolate']:
axes.append(pipe.diff_tensor.Dpar * pipe.diff_tensor.Dpar_unit)
if sim_num != None:
sim_axes.append([])
for i in range(sim_num):
sim_axes[0].append(pipe.diff_tensor.Dpar_sim[i] * pipe.diff_tensor.Dpar_unit_sim[i])
if diff_type == 'ellipsoid':
axes.append(pipe.diff_tensor.Dx * pipe.diff_tensor.Dx_unit)
axes.append(pipe.diff_tensor.Dy * pipe.diff_tensor.Dy_unit)
axes.append(pipe.diff_tensor.Dz * pipe.diff_tensor.Dz_unit)
if sim_num != None:
sim_axes.append([])
sim_axes.append([])
sim_axes.append([])
for i in range(sim_num):
sim_axes[0].append(pipe.diff_tensor.Dx_sim[i] * pipe.diff_tensor.Dx_unit_sim[i])
sim_axes[1].append(pipe.diff_tensor.Dy_sim[i] * pipe.diff_tensor.Dy_unit_sim[i])
sim_axes[2].append(pipe.diff_tensor.Dz_sim[i] * pipe.diff_tensor.Dz_unit_sim[i])
# Create the object.
diffusion_tensor(mol=mol, tensor=pipe.diff_tensor.tensor, tensor_diag=pipe.diff_tensor.tensor_diag, diff_type=diff_type, rotation=pipe.diff_tensor.rotation, axes=axes, sim_axes=sim_axes, com=com, scale=scale)
# Create the PDB file.
######################
# Print out.
print("\nGenerating the PDB file.")
# Create the PDB file.
tensor_pdb_file = open_write_file(file, dir, force=force)
structure.write_pdb(tensor_pdb_file)
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append(['diff_tensor_pdb', 'Diffusion tensor PDB', get_file_path(file, dir)])
status.observers.result_file.notify()
def web_of_motion(file=None, dir=None, models=None, force=False):
"""Create a PDB representation of the motion between a set of models.
This will create a PDB file containing the atoms of all models, with identical atoms links using CONECT records. This function only supports the internal structural object.
@keyword file: The name of the PDB file to write.
@type file: str
@keyword dir: The directory where the PDB file will be placed. If set to None, then the file will be placed in the current directory.
@type dir: str or None
@keyword models: The optional list of models to restrict this to.
@type models: list of int or None
@keyword force: The force flag which if True will cause the file to be overwritten.
@type force: 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
# Validate the models.
cdp.structure.validate_models()
# Initialise the structural object.
web = Internal()
# The model list.
if models == None:
models = []
for k in range(len(cdp.structure.structural_data)):
models.append(cdp.structure.structural_data[k].num)
# Loop over the molecules.
for i in range(len(cdp.structure.structural_data[0].mol)):
# Alias the molecule of the first model.
mol1 = cdp.structure.structural_data[0].mol[i]
# Loop over the atoms.
for j in range(len(mol1.atom_name)):
# Loop over the models.
for k in range(len(cdp.structure.structural_data)):
# Skip the model.
if cdp.structure.structural_data[k].num not in models:
continue
# Alias.
mol = cdp.structure.structural_data[k].mol[i]
# Add the atom.
web.add_atom(mol_name=mol1.mol_name, atom_name=mol.atom_name[j], res_name=mol.res_name[j], res_num=mol.res_num[j], pos=[mol.x[j], mol.y[j], mol.z[j]], element=mol.element[j], chain_id=mol.chain_id[j], segment_id=mol.seg_id[j], pdb_record=mol.pdb_record[j])
# Loop over the models again, this time twice.
for k in range(len(models)):
for l in range(len(models)):
# Skip identical atoms.
if k == l:
continue
# The atom index.
index1 = j*len(models) + k
index2 = j*len(models) + l
# Connect to the previous atoms.
web.connect_atom(mol_name=mol1.mol_name, index1=index1, index2=index2)
# Append the PDB extension if needed.
if isinstance(file, str):
# The file path.
file = get_file_path(file, dir)
# Add '.pdb' to the end of the file path if it isn't there yet.
if not search(".pdb$", file):
file += '.pdb'
# Open the file for writing.
file = open_write_file(file, force=force)
# Write the structure.
web.write_pdb(file)
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes', node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0], file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0], file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0], file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0], dir=dir, file_version=file_version)
def create_rotor_pdb(file=None,
dir=None,
rotor_angle=None,
axis=None,
axis_pt=True,
centre=None,
span=2e-9,
blade_length=5e-10,
force=False,
staggered=False):
"""Create a PDB representation of a rotor motional model.
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword rotor_angle: The angle of the rotor motion in degrees.
@type rotor_angle: float
@keyword axis: The vector defining the rotor axis.
@type axis: numpy rank-1, 3D array
@keyword axis_pt: A point lying anywhere on the rotor axis. This is used to define the position of the axis in 3D space.
@type axis_pt: numpy rank-1, 3D array
@keyword centre: The central point of the representation. If this point is not on the rotor axis, then the closest point on the axis will be used for the centre.
@type centre: numpy rank-1, 3D array
@keyword span: The distance from the central point to the rotor blades (meters).
@type span: float
@keyword blade_length: The length of the representative rotor blades.
@type blade_length: float
@keyword force: A flag which if set will overwrite any pre-existing file.
@type force: bool
@keyword staggered: A flag which if True will cause the rotor blades to be staggered. This is used to avoid blade overlap.
@type staggered: bool
"""
# Test if the current pipe exists.
check_pipe()
# Convert the angle to radians.
rotor_angle = rotor_angle / 360.0 * 2.0 * pi
# Create the structural object.
structure = Internal()
# Generate the rotor object.
rotor(structure=structure,
rotor_angle=rotor_angle,
axis=axis,
axis_pt=axis_pt,
centre=centre,
span=span,
blade_length=blade_length,
staggered=staggered)
# Print out.
print("\nGenerating the PDB file.")
# Open the PDB file for writing.
tensor_pdb_file = open_write_file(file, dir, force=force)
# Write the data.
structure.write_pdb(tensor_pdb_file)
# Close the file.
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append(
['rotor_pdb', 'Rotor PDB',
get_file_path(file, dir)])
status.observers.result_file.notify()
def create_vector_dist(length=None,
symmetry=True,
file=None,
dir=None,
force=False):
"""Create a PDB representation of the vector distribution.
@keyword length: The length to set the vectors to in the PDB file.
@type length: float
@keyword symmetry: The symmetry flag which if set will create a second PDB chain 'B' which is the same as chain 'A' but with the vectors reversed.
@type symmetry: bool
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set will overwrite any pre-existing file.
@type force: bool
"""
# Test if the current pipe exists.
check_pipe()
# Test if a structure has been loaded.
if not hasattr(cdp, 'structure') or not cdp.structure.num_models() > 0:
raise RelaxNoPdbError
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if unit vectors exist.
vectors = False
for interatom in interatomic_loop():
if hasattr(interatom, 'vector'):
vectors = True
break
if not vectors:
raise RelaxNoVectorsError
# Initialise.
#############
# Create the structural object.
structure = Internal()
# Add a structure.
structure.add_molecule(name='vector_dist')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Initialise the residue and atom numbers.
res_num = 1
atom_num = 1
# Centre of mass.
#################
# Calculate the centre of mass.
R = pipe_centre_of_mass()
# Increment the residue number.
res_num = res_num + 1
# The vectors.
##############
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(spin_hash=interatom._spin_hash1)
spin2 = return_spin(spin_hash=interatom._spin_hash2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num,
atom_name=spin1.name,
res_name=spin1._res_name,
chain_id='A',
res_num=spin1._res_num,
pos=R,
segment_id=None,
element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num + 1,
atom_name=spin2.name,
res_name=spin2._res_name,
chain_id='A',
res_num=spin2._res_num,
pos=R + vector,
segment_id=None,
element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num - 1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Symmetry chain.
if symmetry:
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(spin_hash=interatom._spin_hash1)
spin2 = return_spin(spin_hash=interatom._spin_hash2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num,
atom_name=spin1.name,
res_name=spin1._res_name,
chain_id='B',
res_num=spin1._res_num,
pos=R,
segment_id=None,
element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num + 1,
atom_name=spin2.name,
res_name=spin2._res_name,
chain_id='B',
res_num=spin2._res_num,
pos=R - vector,
segment_id=None,
element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num - 1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Create the PDB file.
######################
# Print out.
print("\nGenerating the PDB file.")
# Open the PDB file for writing.
tensor_pdb_file = open_write_file(file, dir, force=force)
# Write the data.
structure.write_pdb(tensor_pdb_file)
# Close the file.
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append([
'vector_dist_pdb', 'Vector distribution PDB',
get_file_path(file, dir)
])
status.observers.result_file.notify()
def cone_pdb(cone_type=None, scale=1.0, file=None, dir=None, force=False):
"""Create a PDB file containing a geometric object representing the various cone models.
Currently the only cone types supported are 'diff in cone' and 'diff on cone'.
@param cone_type: The type of cone model to represent.
@type cone_type: str
@param scale: The size of the geometric object is eqaul to the average pivot-CoM
vector length multiplied by this scaling factor.
@type scale: float
@param file: The name of the PDB file to create.
@type file: str
@param dir: The name of the directory to place the PDB file into.
@type dir: str
@param force: Flag which if set to True will cause any pre-existing file to be
overwritten.
@type force: int
"""
# Test if the cone models have been determined.
if cone_type == 'diff in cone':
if not hasattr(cdp, 'S_diff_in_cone'):
raise RelaxError("The diffusion in a cone model has not yet been determined.")
elif cone_type == 'diff on cone':
if not hasattr(cdp, 'S_diff_on_cone'):
raise RelaxError("The diffusion on a cone model has not yet been determined.")
else:
raise RelaxError("The cone type " + repr(cone_type) + " is unknown.")
# The number of increments for the filling of the cone objects.
inc = 20
# The rotation matrix.
R = zeros((3, 3), float64)
two_vect_to_R(array([0, 0, 1], float64), cdp.ave_pivot_CoM/norm(cdp.ave_pivot_CoM), R)
# The isotropic cone object.
if cone_type == 'diff in cone':
angle = cdp.theta_diff_in_cone
elif cone_type == 'diff on cone':
angle = cdp.theta_diff_on_cone
cone_obj = Iso_cone(angle)
# Create the structural object.
structure = Internal()
# Add a structure.
structure.add_molecule(name='cone')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Add the pivot point.
mol.atom_add(pdb_record='HETATM', atom_num=1, atom_name='R', res_name='PIV', res_num=1, pos=cdp.pivot_point, element='C')
# Generate the average pivot-CoM vectors.
print("\nGenerating the average pivot-CoM vectors.")
sim_vectors = None
if hasattr(cdp, 'ave_pivot_CoM_sim'):
sim_vectors = cdp.ave_pivot_CoM_sim
res_num = generate_vector_residues(mol=mol, vector=cdp.ave_pivot_CoM, atom_name='Ave', res_name_vect='AVE', sim_vectors=sim_vectors, res_num=2, origin=cdp.pivot_point, scale=scale)
# Generate the cone outer edge.
print("\nGenerating the cone outer edge.")
cap_start_atom = mol.atom_num[-1]+1
cone_edge(mol=mol, cone_obj=cone_obj, res_name='CON', res_num=3, apex=cdp.pivot_point, R=R, scale=norm(cdp.pivot_CoM), inc=inc)
# Generate the cone cap, and stitch it to the cone edge.
if cone_type == 'diff in cone':
print("\nGenerating the cone cap.")
cone_start_atom = mol.atom_num[-1]+1
generate_vector_dist(mol=mol, res_name='CON', res_num=3, centre=cdp.pivot_point, R=R, phi_max_fn=cone_obj.phi_max, scale=norm(cdp.pivot_CoM), inc=inc)
# Create the PDB file.
print("\nGenerating the PDB file.")
pdb_file = open_write_file(file, dir, force=force)
structure.write_pdb(pdb_file)
pdb_file.close()
def create_geometric_rep(format='PDB',
file=None,
dir=None,
compress_type=0,
size=30.0,
inc=36,
force=False):
"""Create a PDB file containing a geometric object representing the frame order dynamics.
@keyword format: The format for outputting the geometric representation. Currently only the 'PDB' format is supported.
@type format: str
@keyword file: The name of the file of the PDB representation of the frame order dynamics to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword compress_type: The compression type. The integer values correspond to the compression type: 0, no compression; 1, Bzip2 compression; 2, Gzip compression.
@type compress_type: int
@keyword size: The size of the geometric object in Angstroms.
@type size: float
@keyword inc: The number of increments for the filling of the cone objects.
@type inc: int
@keyword force: Flag which if set to True will cause any pre-existing file to be overwritten.
@type force: bool
"""
# Printout.
subsection(
file=sys.stdout,
text=
"Creating a PDB file containing a geometric object representing the frame order dynamics."
)
# Checks.
check_parameters(escalate=2)
# Initialise.
titles = []
structures = []
representation = []
sims = []
file_root = []
# Symmetry for inverted representations?
sym = True
if cdp.model in [MODEL_ROTOR, MODEL_FREE_ROTOR, MODEL_DOUBLE_ROTOR]:
sym = False
# The standard representation.
titles.append("Representation A")
structures.append(Internal())
if sym:
representation.append('A')
file_root.append("%s_A" % file)
else:
representation.append(None)
file_root.append(file)
sims.append(False)
# The inverted representation.
if sym:
titles.append("Representation A")
structures.append(Internal())
representation.append('B')
file_root.append("%s_B" % file)
sims.append(False)
# The standard MC simulation representation.
if hasattr(cdp, 'sim_number'):
titles.append("MC simulation representation A")
structures.append(Internal())
if sym:
representation.append('A')
file_root.append("%s_sim_A" % file)
else:
representation.append(None)
file_root.append("%s_sim" % file)
sims.append(True)
# The inverted MC simulation representation.
if hasattr(cdp, 'sim_number') and sym:
titles.append("MC simulation representation B")
structures.append(Internal())
representation.append('B')
file_root.append("%s_sim_B" % file)
sims.append(True)
# Loop over each structure and add the contents.
for i in range(len(structures)):
# Printout.
subsubsection(file=sys.stdout, text="Creating the %s." % titles[i])
# Create a model for each Monte Carlo simulation.
if sims[i]:
for sim_i in range(cdp.sim_number):
structures[i].add_model(model=sim_i + 1)
# Add the pivots.
add_pivots(structure=structures[i], sims=sims[i])
# Add all rotor objects.
add_rotors(structure=structures[i],
representation=representation[i],
size=size,
sims=sims[i])
# Add the axis systems.
add_axes(structure=structures[i],
representation=representation[i],
size=size,
sims=sims[i])
# Add the cone objects.
if cdp.model not in [
MODEL_ROTOR, MODEL_FREE_ROTOR, MODEL_DOUBLE_ROTOR
]:
add_cones(structure=structures[i],
representation=representation[i],
size=size,
inc=inc,
sims=sims[i])
# Add atoms for creating titles.
add_titles(structure=structures[i],
representation=representation[i],
displacement=size + 10,
sims=sims[i])
# Create the PDB file.
if format == 'PDB':
pdb_file = open_write_file(file_root[i] + '.pdb',
dir,
compress_type=compress_type,
force=force)
structures[i].write_pdb(pdb_file)
pdb_file.close()
# GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program. If not, see <http://www.gnu.org/licenses/>. #
# #
###############################################################################
# Module docstring.
"""Create a PDB representation for the real pivot point used to generate the data."""
# relax module imports.
from lib.io import open_write_file
from lib.structure.internal.object import Internal
# Create the structural object.
structure = Internal()
# Add a molecule.
structure.add_molecule(name='piv')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Add the original pivot.
mol.atom_add(atom_name='N',
res_name='PIV',
res_num=1,
pos=[37.254, 0.5, 16.7465],
element='N')
# Add the shifted pivot.
class PipeContainer(Prototype):
"""Class containing all the program data."""
def __init__(self):
"""Set up all the PipeContainer data structures."""
# The molecule-residue-spin object.
self.mol = MoleculeList()
# The interatomic data object.
self.interatomic = InteratomList()
# The data pipe type.
self.pipe_type = None
# Hybrid models.
self.hybrid_pipes = []
def __repr__(self):
"""The string representation of the object.
Rather than using the standard Python conventions (either the string representation of the
value or the "<...desc...>" notation), a rich-formatted description of the object is given.
"""
# Intro text.
text = "The data pipe storage object.\n"
# Special objects/methods (to avoid the getattr() function call on).
spec_obj = [
'exp_info', 'mol', 'interatomic', 'diff_tensor', 'structure'
]
# Objects.
text = text + "\n"
text = text + "Objects:\n"
for name in dir(self):
# Molecular list.
if name == 'mol':
text = text + " mol: The molecule list (for the storage of the spin system specific data)\n"
# Interatomic data list.
if name == 'interatomic':
text = text + " interatomic: The interatomic data list (for the storage of the inter-spin system data)\n"
# Diffusion tensor.
if name == 'diff_tensor':
text = text + " diff_tensor: The Brownian rotational diffusion tensor data object\n"
# Molecular structure.
if name == 'structure':
text = text + " structure: The 3D molecular data object\n"
# The experimental info data container.
if name == 'exp_info':
text = text + " exp_info: The data container for experimental information\n"
# Skip the PipeContainer methods.
if name in self.__class__.__dict__:
continue
# Skip certain objects.
if match("^_", name) or name in spec_obj:
continue
# Add the object's attribute to the text string.
text = text + " " + name + ": " + repr(getattr(self, name)) + "\n"
# Return the text representation.
return text
def _back_compat_hook(self, file_version=None):
"""Method for converting old data structures to the new ones.
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
"""
# Relaxation data.
self._back_compat_hook_ri_data()
def _back_compat_hook_ri_data(self):
"""Converting the old relaxation data structures to the new ones."""
# Nothing to do.
if not (hasattr(cdp, 'frq_labels') and hasattr(cdp, 'noe_r1_table')
and hasattr(cdp, 'remap_table')):
return
# Initialise the new structures.
cdp.ri_ids = []
cdp.ri_type = {}
frq = {
} # This will be placed into cdp later as cdp.spectrometer_frq still exists.
# Generate the new structures.
for i in range(cdp.num_ri):
# The ID.
ri_id = "%s_%s" % (cdp.ri_labels[i],
cdp.frq_labels[cdp.remap_table[i]])
# Not unique.
if ri_id in cdp.ri_ids:
# Loop until a unique ID is found.
for j in range(100):
# New id.
new_id = "%s_%s" % (ri_id, j)
# Unique.
if not new_id in cdp.ri_ids:
ri_id = new_id
break
# Add the ID.
cdp.ri_ids.append(ri_id)
# The relaxation data type.
cdp.ri_type[ri_id] = cdp.ri_labels[i]
# The frequency data.
frq[ri_id] = cdp.frq[cdp.remap_table[i]]
# Delete the old structures.
del cdp.frq
del cdp.frq_labels
del cdp.noe_r1_table
del cdp.num_frq
del cdp.num_ri
del cdp.remap_table
del cdp.ri_labels
# Set the frequencies.
cdp.frq = frq
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes',
node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0],
file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0],
file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0],
file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0],
dir=dir,
file_version=file_version)
def is_empty(self):
"""Method for testing if the data pipe is empty.
@return: True if the data pipe is empty, False otherwise.
@rtype: bool
"""
# Is the molecule structure data object empty?
if hasattr(self, 'structure'):
return False
# Is the molecule/residue/spin data object empty?
if not self.mol.is_empty():
return False
# Is the interatomic data object empty?
if not self.interatomic.is_empty():
return False
# Tests for the initialised data (the pipe type can be set in an empty data pipe, so this isn't checked).
if self.hybrid_pipes:
return False
# An object has been added to the container.
for name in dir(self):
# Skip the objects initialised in __init__().
if name in ['mol', 'interatomic', 'pipe_type', 'hybrid_pipes']:
continue
# Skip the PipeContainer methods.
if name in self.__class__.__dict__:
continue
# Skip special objects.
if match("^_", name):
continue
# An object has been added.
return False
# The data pipe is empty.
return True
def to_xml(self, doc, element, pipe_type=None):
"""Create a XML element for the current data pipe.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The XML element to add the pipe XML element to.
@type element: XML element object
@keyword pipe_type: The type of the pipe being converted to XML.
@type pipe_type: str
"""
# Add all simple python objects within the PipeContainer to the global element.
global_element = doc.createElement('global')
element.appendChild(global_element)
global_element.setAttribute(
'desc', 'Global data located in the top level of the data pipe')
fill_object_contents(
doc,
global_element,
object=self,
blacklist=[
'align_tensors', 'diff_tensor', 'exp_info', 'interatomic',
'hybrid_pipes', 'mol', 'pipe_type', 'structure'
] + list(self.__class__.__dict__.keys()))
# Hybrid info.
self.xml_create_hybrid_element(doc, element)
# Add the experimental information.
if hasattr(self, 'exp_info'):
self.exp_info.to_xml(doc, element)
# Add the diffusion tensor data.
if hasattr(self, 'diff_tensor'):
self.diff_tensor.to_xml(doc, element)
# Add the alignment tensor data.
if hasattr(self, 'align_tensors'):
self.align_tensors.to_xml(doc, element)
# Add the molecule-residue-spin data.
self.mol.to_xml(doc, element, pipe_type=pipe_type)
# Add the interatomic data.
self.interatomic.to_xml(doc, element, pipe_type=pipe_type)
# Add the structural data, if it exists.
if hasattr(self, 'structure'):
self.structure.to_xml(doc, element)
def xml_create_hybrid_element(self, doc, element):
"""Create an XML element for the data pipe hybridisation information.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The element to add the hybridisation info to.
@type element: XML element object
"""
# Create the hybrid element and add it to the higher level element.
hybrid_element = doc.createElement('hybrid')
element.appendChild(hybrid_element)
# Set the hybridisation attributes.
hybrid_element.setAttribute('desc',
'Data pipe hybridisation information')
# Create an element to store the pipes list.
list_element = doc.createElement('pipes')
hybrid_element.appendChild(list_element)
# Add the pipes list.
text_val = doc.createTextNode(str(self.hybrid_pipes))
list_element.appendChild(text_val)
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes',
node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0],
file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0],
file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0],
file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0],
dir=dir,
file_version=file_version)
def cone_pdb(cone_type=None, scale=1.0, file=None, dir=None, force=False):
"""Create a PDB file containing a geometric object representing the various cone models.
Currently the only cone types supported are 'diff in cone' and 'diff on cone'.
@param cone_type: The type of cone model to represent.
@type cone_type: str
@param scale: The size of the geometric object is eqaul to the average pivot-CoM
vector length multiplied by this scaling factor.
@type scale: float
@param file: The name of the PDB file to create.
@type file: str
@param dir: The name of the directory to place the PDB file into.
@type dir: str
@param force: Flag which if set to True will cause any pre-existing file to be
overwritten.
@type force: int
"""
# Test if the cone models have been determined.
if cone_type == 'diff in cone':
if not hasattr(cdp, 'S_diff_in_cone'):
raise RelaxError(
"The diffusion in a cone model has not yet been determined.")
elif cone_type == 'diff on cone':
if not hasattr(cdp, 'S_diff_on_cone'):
raise RelaxError(
"The diffusion on a cone model has not yet been determined.")
else:
raise RelaxError("The cone type " + repr(cone_type) + " is unknown.")
# The number of increments for the filling of the cone objects.
inc = 20
# The rotation matrix.
R = zeros((3, 3), float64)
two_vect_to_R(array([0, 0, 1], float64),
cdp.ave_pivot_CoM / norm(cdp.ave_pivot_CoM), R)
# The isotropic cone object.
if cone_type == 'diff in cone':
angle = cdp.theta_diff_in_cone
elif cone_type == 'diff on cone':
angle = cdp.theta_diff_on_cone
cone_obj = Iso_cone(angle)
# Create the structural object.
structure = Internal()
# Add a structure.
structure.add_molecule(name='cone')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Add the pivot point.
mol.atom_add(pdb_record='HETATM',
atom_num=1,
atom_name='R',
res_name='PIV',
res_num=1,
pos=cdp.pivot_point,
element='C')
# Generate the average pivot-CoM vectors.
print("\nGenerating the average pivot-CoM vectors.")
sim_vectors = None
if hasattr(cdp, 'ave_pivot_CoM_sim'):
sim_vectors = cdp.ave_pivot_CoM_sim
res_num = generate_vector_residues(mol=mol,
vector=cdp.ave_pivot_CoM,
atom_name='Ave',
res_name_vect='AVE',
sim_vectors=sim_vectors,
res_num=2,
origin=cdp.pivot_point,
scale=scale)
# Generate the cone outer edge.
print("\nGenerating the cone outer edge.")
cap_start_atom = mol.atom_num[-1] + 1
cone_edge(mol=mol,
cone_obj=cone_obj,
res_name='CON',
res_num=3,
apex=cdp.pivot_point,
R=R,
scale=norm(cdp.pivot_CoM),
inc=inc)
# Generate the cone cap, and stitch it to the cone edge.
if cone_type == 'diff in cone':
print("\nGenerating the cone cap.")
cone_start_atom = mol.atom_num[-1] + 1
generate_vector_dist(mol=mol,
res_name='CON',
res_num=3,
centre=cdp.pivot_point,
R=R,
phi_max_fn=cone_obj.phi_max,
scale=norm(cdp.pivot_CoM),
inc=inc)
# Create the PDB file.
print("\nGenerating the PDB file.")
pdb_file = open_write_file(file, dir, force=force)
structure.write_pdb(pdb_file)
pdb_file.close()
def pdb(r=1.02, file_name='uniform.pdb', inc=None):
"""Create the bond vector distribution and save the PDB file."""
# Create the structural object.
structure = Internal()
# Add a molecule.
structure.add_molecule(name='dist')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Get the polar and azimuthal angles for the distribution.
phi, theta = angles_uniform(inc)
# Get the uniform vector distribution.
vectors = vect_dist_spherical_angles(inc=inc, distribution='uniform')
# Loop over the radial array of vectors (change in longitude).
atom_num = 1
new_vectors = []
for i in range(len(theta)):
# Loop over the vectors of the radial array (change in latitude).
for j in range(len(phi)):
# The index.
index = i + j * len(theta)
# The atomic positions.
pos1 = vectors[index] * 10
pos2 = pos1 + vectors[index] * r
# Store the rearranged vector (truncated as in the PDB).
trunc_vect = zeros(3, float64)
for k in range(3):
trunc_vect[k] = float("%.3f" % pos2[k]) - float(
"%.3f" % pos1[k])
new_vectors.append(trunc_vect)
# Residue number.
res = (atom_num + 1) / 2
# Add the vector as a N-H atom pair.
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num,
atom_name='N',
res_name=AA_TABLE[SEQ[index]].upper(),
res_num=res,
pos=pos1,
element='N')
mol.atom_add(pdb_record='ATOM',
atom_num=atom_num + 1,
atom_name='H',
res_name=AA_TABLE[SEQ[index]].upper(),
res_num=res,
pos=pos2,
element='H')
# Connect.
mol.atom_connect(atom_num - 1, atom_num)
# Move 2 atoms forwards.
atom_num += 2
# The PDB file.
file = open_write_file(file_name, force=True)
structure.write_pdb(file)
file.close()
# Return the vectors in the diffusion frame.
return new_vectors
def create_vector_dist(length=None, symmetry=True, file=None, dir=None, force=False):
"""Create a PDB representation of the vector distribution.
@keyword length: The length to set the vectors to in the PDB file.
@type length: float
@keyword symmetry: The symmetry flag which if set will create a second PDB chain 'B' which is the same as chain 'A' but with the vectors reversed.
@type symmetry: bool
@keyword file: The name of the PDB file to create.
@type file: str
@keyword dir: The name of the directory to place the PDB file into.
@type dir: str
@keyword force: Flag which if set will overwrite any pre-existing file.
@type force: bool
"""
# Test if the current pipe exists.
pipes.test()
# Test if a structure has been loaded.
if not hasattr(cdp, 'structure') or not cdp.structure.num_models() > 0:
raise RelaxNoPdbError
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if unit vectors exist.
vectors = False
for interatom in interatomic_loop():
if hasattr(interatom, 'vector'):
vectors = True
break
if not vectors:
raise RelaxNoVectorsError
# Initialise.
#############
# Create the structural object.
structure = Internal()
# Add a structure.
structure.add_molecule(name='vector_dist')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Initialise the residue and atom numbers.
res_num = 1
atom_num = 1
# Centre of mass.
#################
# Calculate the centre of mass.
R = pipe_centre_of_mass()
# Increment the residue number.
res_num = res_num + 1
# The vectors.
##############
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(interatom.spin_id1)
spin2 = return_spin(interatom.spin_id2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num, atom_name=spin1.name, res_name=spin1._res_name, chain_id='A', res_num=spin1._res_num, pos=R, segment_id=None, element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num+1, atom_name=spin2.name, res_name=spin2._res_name, chain_id='A', res_num=spin2._res_num, pos=R+vector, segment_id=None, element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num-1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Symmetry chain.
if symmetry:
# Loop over the interatomic data containers.
for interatom in interatomic_loop():
# Get the spins.
spin1 = return_spin(interatom.spin_id1)
spin2 = return_spin(interatom.spin_id2)
# Skip deselected spin systems.
if not spin1.select or not spin2.select:
continue
# Skip containers missing vectors.
if not hasattr(interatom, 'vector'):
continue
# Scale the vector.
vector = interatom.vector * length * 1e10
# Add the first spin as the central atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num, atom_name=spin1.name, res_name=spin1._res_name, chain_id='B', res_num=spin1._res_num, pos=R, segment_id=None, element=spin1.element)
# Add the second spin as the end atom.
mol.atom_add(pdb_record='ATOM', atom_num=atom_num+1, atom_name=spin2.name, res_name=spin2._res_name, chain_id='B', res_num=spin2._res_num, pos=R-vector, segment_id=None, element=spin2.element)
# Connect the two atoms.
mol.atom_connect(index1=atom_num-1, index2=atom_num)
# Increment the atom number.
atom_num = atom_num + 2
# Create the PDB file.
######################
# Print out.
print("\nGenerating the PDB file.")
# Open the PDB file for writing.
tensor_pdb_file = open_write_file(file, dir, force=force)
# Write the data.
structure.write_pdb(tensor_pdb_file)
# Close the file.
tensor_pdb_file.close()
# Add the file to the results file list.
if not hasattr(cdp, 'result_files'):
cdp.result_files = []
if dir == None:
dir = getcwd()
cdp.result_files.append(['vector_dist_pdb', 'Vector distribution PDB', get_file_path(file, dir)])
status.observers.result_file.notify()
class PipeContainer(Prototype):
"""Class containing all the program data."""
def __init__(self):
"""Set up all the PipeContainer data structures."""
# The molecule-residue-spin object.
self.mol = MoleculeList()
# The interatomic data object.
self.interatomic = InteratomList()
# The data pipe type.
self.pipe_type = None
# Hybrid models.
self.hybrid_pipes = []
def __repr__(self):
"""The string representation of the object.
Rather than using the standard Python conventions (either the string representation of the
value or the "<...desc...>" notation), a rich-formatted description of the object is given.
"""
# Intro text.
text = "The data pipe storage object.\n"
# Special objects/methods (to avoid the getattr() function call on).
spec_obj = ['exp_info', 'mol', 'interatomic', 'diff_tensor', 'structure']
# Objects.
text = text + "\n"
text = text + "Objects:\n"
for name in dir(self):
# Molecular list.
if name == 'mol':
text = text + " mol: The molecule list (for the storage of the spin system specific data)\n"
# Interatomic data list.
if name == 'interatomic':
text = text + " interatomic: The interatomic data list (for the storage of the inter-spin system data)\n"
# Diffusion tensor.
if name == 'diff_tensor':
text = text + " diff_tensor: The Brownian rotational diffusion tensor data object\n"
# Molecular structure.
if name == 'structure':
text = text + " structure: The 3D molecular data object\n"
# The experimental info data container.
if name == 'exp_info':
text = text + " exp_info: The data container for experimental information\n"
# Skip the PipeContainer methods.
if name in list(self.__class__.__dict__.keys()):
continue
# Skip certain objects.
if match("^_", name) or name in spec_obj:
continue
# Add the object's attribute to the text string.
text = text + " " + name + ": " + repr(getattr(self, name)) + "\n"
# Return the text representation.
return text
def _back_compat_hook(self, file_version=None):
"""Method for converting old data structures to the new ones.
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
"""
# Relaxation data.
self._back_compat_hook_ri_data()
def _back_compat_hook_ri_data(self):
"""Converting the old relaxation data structures to the new ones."""
# Nothing to do.
if not (hasattr(cdp, 'frq_labels') and hasattr(cdp, 'noe_r1_table') and hasattr(cdp, 'remap_table')):
return
# Initialise the new structures.
cdp.ri_ids = []
cdp.ri_type = {}
frq = {} # This will be placed into cdp later as cdp.spectrometer_frq still exists.
# Generate the new structures.
for i in range(cdp.num_ri):
# The ID.
ri_id = "%s_%s" % (cdp.ri_labels[i], cdp.frq_labels[cdp.remap_table[i]])
# Not unique.
if ri_id in cdp.ri_ids:
# Loop until a unique ID is found.
for j in range(100):
# New id.
new_id = "%s_%s" % (ri_id, j)
# Unique.
if not new_id in cdp.ri_ids:
ri_id = new_id
break
# Add the ID.
cdp.ri_ids.append(ri_id)
# The relaxation data type.
cdp.ri_type[ri_id] = cdp.ri_labels[i]
# The frequency data.
frq[ri_id] = cdp.frq[cdp.remap_table[i]]
# Delete the old structures.
del cdp.frq
del cdp.frq_labels
del cdp.noe_r1_table
del cdp.num_frq
del cdp.num_ri
del cdp.remap_table
del cdp.ri_labels
# Set the frequencies.
cdp.frq = frq
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes', node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0], file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0], file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0], file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0], dir=dir, file_version=file_version)
def is_empty(self):
"""Method for testing if the data pipe is empty.
@return: True if the data pipe is empty, False otherwise.
@rtype: bool
"""
# Is the molecule structure data object empty?
if hasattr(self, 'structure'):
return False
# Is the molecule/residue/spin data object empty?
if not self.mol.is_empty():
return False
# Is the interatomic data object empty?
if not self.interatomic.is_empty():
return False
# Tests for the initialised data (the pipe type can be set in an empty data pipe, so this isn't checked).
if self.hybrid_pipes:
return False
# An object has been added to the container.
for name in dir(self):
# Skip the objects initialised in __init__().
if name in ['mol', 'interatomic', 'pipe_type', 'hybrid_pipes']:
continue
# Skip the PipeContainer methods.
if name in list(self.__class__.__dict__.keys()):
continue
# Skip special objects.
if match("^_", name):
continue
# An object has been added.
return False
# The data pipe is empty.
return True
def to_xml(self, doc, element):
"""Create a XML element for the current data pipe.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The XML element to add the pipe XML element to.
@type element: XML element object
"""
# Add all simple python objects within the PipeContainer to the global element.
global_element = doc.createElement('global')
element.appendChild(global_element)
global_element.setAttribute('desc', 'Global data located in the top level of the data pipe')
fill_object_contents(doc, global_element, object=self, blacklist=['align_tensors', 'diff_tensor', 'exp_info', 'interatomic', 'hybrid_pipes', 'mol', 'pipe_type', 'structure'] + list(self.__class__.__dict__.keys()))
# Hybrid info.
self.xml_create_hybrid_element(doc, element)
# Add the experimental information.
if hasattr(self, 'exp_info'):
self.exp_info.to_xml(doc, element)
# Add the diffusion tensor data.
if hasattr(self, 'diff_tensor'):
self.diff_tensor.to_xml(doc, element)
# Add the alignment tensor data.
if hasattr(self, 'align_tensors'):
self.align_tensors.to_xml(doc, element)
# Add the molecule-residue-spin data.
self.mol.to_xml(doc, element)
# Add the interatomic data.
self.interatomic.to_xml(doc, element)
# Add the structural data, if it exists.
if hasattr(self, 'structure'):
self.structure.to_xml(doc, element)
def xml_create_hybrid_element(self, doc, element):
"""Create an XML element for the data pipe hybridisation information.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The element to add the hybridisation info to.
@type element: XML element object
"""
# Create the hybrid element and add it to the higher level element.
hybrid_element = doc.createElement('hybrid')
element.appendChild(hybrid_element)
# Set the hybridisation attributes.
hybrid_element.setAttribute('desc', 'Data pipe hybridisation information')
# Create an element to store the pipes list.
list_element = doc.createElement('pipes')
hybrid_element.appendChild(list_element)
# Add the pipes list.
text_val = doc.createTextNode(str(self.hybrid_pipes))
list_element.appendChild(text_val)
# Create a PDB representation for the real pivot point used to generate the data.
# relax module imports.
from lib.io import open_write_file
from lib.structure.internal.object import Internal
# Create the structural object.
structure = Internal()
# Add a molecule.
structure.add_molecule(name='piv')
# Alias the single molecule from the single model.
mol = structure.structural_data[0].mol[0]
# Add the original pivot.
mol.atom_add(atom_name='N', res_name='PIV', res_num=1, pos=[ 37.254, 0.5, 16.7465], element='N')
# Add the shifted pivot.
mol.atom_add(atom_name='N', res_name='SFT', res_num=2, pos=[ 38.968163825736738, 2.6192628972111, 13.499077238576398], element='N')
# Save as a PDB file.
file = open_write_file('pivot_point.pdb', force=True)
structure.write_pdb(file)
file.close()
