def test_parent_pointers():
atom = struct.Atom()
bond = struct.Bond()
residue = struct.Residue()
chain = struct.Chain()
molecule = struct.Molecule()
complex = struct.Complex()
assert_no_parents(atom, bond, residue, chain, molecule, complex)
complex.add_molecule(molecule)
molecule.add_chain(chain)
chain.add_residue(residue)
residue.add_atom(atom)
residue.add_bond(bond)
assert_parents(atom, bond, residue, chain, molecule, complex)
complex.remove_molecule(molecule)
molecule.remove_chain(chain)
chain.remove_residue(residue)
residue.remove_atom(atom)
residue.remove_bond(bond)
assert_no_parents(atom, bond, residue, chain, molecule, complex)
def test_matrices():
a = Matrix(3, 4)
b = Matrix(4, 3)
v = Matrix(4, 1)
v[0][0] = 12.5
v[1][0] = 9.36
v[2][0] = 24.1
v[3][0] = 1.0
result_mul = Matrix(3, 3)
result_mul[0] = [42, 48, 54]
result_mul[1] = [114, 136, 158]
result_mul[2] = [186, 224, 262]
result_mul_v = Matrix(3, 1)
result_mul_v[0][0] = 60.56
result_mul_v[1][0] = 248.4
result_mul_v[2][0] = 436.24
for i in range(12):
a[int(i / 4)][int(i % 4)] = i
b[int(i / 3)][int(i % 3)] = i
assert_equal(a * b, result_mul)
assert_equal(a * v, result_mul_v)
res_atom_global_pos = Vector3(-20.33947, 0.1491127, -9.878754)
complex = struct.Complex()
atom = struct.Atom()
atom.position.set(7.2, 2.6, -21.56)
complex.position.set(-3.197371, -2.314157, 5.071643)
complex.rotation.set(0.09196287, 0.4834483, 0.3486853, 0.797646)
m = complex.get_complex_to_workspace_matrix()
m_inv = complex.get_workspace_to_complex_matrix()
atom_global_pos = m * atom.position
assert_equal(atom_global_pos, res_atom_global_pos)
assert_equal(m_inv * atom_global_pos, atom.position)
def test_thrombin():
input_dir = test_assets + ("/sdf/small_thrombin.sdf")
output_dir = test_output_dir + ("/testOutput.sdf")
complex1 = struct.Complex.io.from_sdf(path=input_dir)
complex1 = complex1.convert_to_frames()
#fact checks
counters = count_structures(complex1)
(molecule_count, chain_count, residue_count, bond_count, atom_count) = counters
assert(molecule_count == 3)
assert(chain_count == 3)
assert(residue_count == 3)
assert(bond_count == 237)
assert(atom_count == 228)
#
complex1.io.to_sdf(output_dir)
complex2 = struct.Complex.io.from_sdf(path=output_dir)
complex2 = complex2.convert_to_frames()
#fact checks
counters = count_structures(complex2)
(molecule_count, chain_count, residue_count, bond_count, atom_count) = counters
assert(molecule_count == 3)
assert(chain_count == 3)
assert(residue_count == 3)
assert(bond_count == 237)
assert(atom_count == 228)
compare_atom_positions(complex1, complex2)
assert_equal(complex1, complex2, options)
assert_not_equal(complex2, struct.Complex(), options)
def test_pdb():
input_dir = test_assets + ("/pdb/1fsv.pdb")
output_dir = test_output_dir + ("/testOutput.pdb")
complex1 = struct.Complex.io.from_pdb(path=input_dir)
complex1.io.to_pdb(output_dir)
complex2 = struct.Complex.io.from_pdb(path=input_dir)
compare_atom_positions(complex1, complex2)
assert_equal(complex1, complex2, options)
assert_not_equal(complex2, struct.Complex(), options)
def create_complex():
val = struct.Complex()
val.index = 1000
val._molecules = [struct.Molecule(), create_molecule(), struct.Molecule(), create_molecule()]
val.boxed = True
val.visible = False
val.computing = False
val.set_current_frame(0)
val.name = "COMPLEX_NAME"
val._remarks = dict([("key1", "val1"), ("key2","val2"),("key3", "val3"), ("key4","val4")])
val.position = Vector3(1,2,3)
val.rotation = Quaternion(1,2,3,4)
return val
def read_write_read(filename):
global i
output_file = test_output_dir + "/testOutput" + str(i) + ".sdf"
i += 1
complex1 = struct.Complex.io.from_sdf(path=filename)
complex1.io.to_sdf(output_file)
complex2 = struct.Complex.io.from_sdf(path=output_file)
compare_atom_positions(complex1, complex2)
assert_equal(complex1, complex2, options)
assert_not_equal(complex2, struct.Complex(), options)
return complex1, complex2
def test_structure_creates():
assert_equal(structure.Atom().__class__,
_structure._Atom._create().__class__)
assert_equal(structure.Bond().__class__,
_structure._Bond._create().__class__)
assert_equal(structure.Residue().__class__,
_structure._Residue._create().__class__)
assert_equal(structure.Chain().__class__,
_structure._Chain._create().__class__)
assert_equal(structure.Molecule().__class__,
_structure._Molecule._create().__class__)
assert_equal(structure.Complex().__class__,
_structure._Complex._create().__class__)
assert_equal(structure.Workspace().__class__,
_structure._Workspace._create().__class__)
def test_equality():
assert_equal(create_atom(), create_atom(), options)
assert_equal(create_bond(), create_bond(), options)
assert_equal(create_residue(), create_residue(), options)
assert_equal(create_chain(), create_chain(), options)
assert_equal(create_molecule(), create_molecule(), options)
assert_equal(create_complex(), create_complex(), options)
assert_equal(create_workspace(), create_workspace(), options)
assert_not_equal(create_atom(), struct.Atom(), options)
assert_not_equal(create_bond(), struct.Bond(), options)
assert_not_equal(create_residue(), struct.Residue(), options)
assert_not_equal(create_chain(), struct.Chain(), options)
assert_not_equal(create_molecule(), struct.Molecule(), options)
assert_not_equal(create_complex(), struct.Complex(), options)
assert_not_equal(create_workspace(), struct.Workspace(), options)
def test_tebgit():
input_dir = test_assets + ("/mmcif/tebgit.cif")
output_dir = test_output_dir + ("/testOutput.cif")
complex1 = struct.Complex.io.from_mmcif(path=input_dir)
#fact checks
counters = count_structures(complex1)
(molecule_count, chain_count, residue_count, bond_count,
atom_count) = counters
assert (molecule_count == 1)
assert (chain_count == 1)
assert (residue_count == 1)
assert (bond_count == 0)
assert (atom_count == 28)
#
complex1.io.to_mmcif(output_dir)
complex2 = struct.Complex.io.from_mmcif(path=output_dir)
compare_atom_positions(complex1, complex2)
assert_equal(complex1, complex2, options)
assert_not_equal(complex2, struct.Complex(), options)
def create_workspace():
workspace = struct.Workspace()
workspace.complexes = [struct.Complex(), create_complex(), struct.Complex(), create_complex()]
workspace.position = Vector3(1,2,3)
workspace.rotation = Quaternion(1,2,3,4)
return workspace
def create_conformer_tree(molecule_count):
complex = alter_object(struct.Complex())
for molecule in create_frames(molecule_count):
complex.add_molecule(molecule)
return complex
