mirror of
https://github.com/openmm/openmm
synced 2026-06-03 06:39:48 +09:00
131 lines
6.1 KiB
Python
131 lines
6.1 KiB
Python
|
|
def validate_preserved(self, topology_before, topology_after, chain_dict, residue_dict, atom_dict):
|
|
""" Validate that the residues and atoms are correctly preserved in the given topologies. """
|
|
|
|
# validate that residues are preserved
|
|
residues_before = [residue for residue in topology_before.residues()]
|
|
residues_after = [residue for residue in topology_after.residues()]
|
|
for residue_index in residue_dict:
|
|
# validate that before and after residues have the same name
|
|
self.assertTrue(residues_before[residue_index].name ==
|
|
residues_after[residue_dict[residue_index]].name)
|
|
# validate that before and after residues come from the same chain
|
|
self.assertTrue(chain_dict[residues_before[residue_index].chain.index] ==
|
|
residues_after[residue_dict[residue_index]].chain.index)
|
|
|
|
# validate that atoms are preserved
|
|
atoms_before = [atom for atom in topology_before.atoms()]
|
|
atoms_after = [atom for atom in topology_after.atoms()]
|
|
for atom_index in atom_dict:
|
|
# validate that before and after atoms have the same name
|
|
self.assertTrue(atoms_before[atom_index].name ==
|
|
atoms_after[atom_dict[atom_index]].name)
|
|
# validate that before and after atoms are the same element
|
|
self.assertTrue(atoms_before[atom_index].element ==
|
|
atoms_after[atom_dict[atom_index]].element)
|
|
# validate that before and after atoms come from the same residue
|
|
self.assertTrue(residue_dict[atoms_before[atom_index].residue.index] ==
|
|
atoms_after[atom_dict[atom_index]].residue.index)
|
|
# end of validate_preserved()
|
|
|
|
def validate_deltas(self, topology_before, topology_after, chain_delta, residue_delta, atoms_delta):
|
|
""" Validate that the number of chains, residues, and atoms have changes the expected amounts. """
|
|
|
|
# validate that the correct number of chains are deleted
|
|
chains_before = [chain for chain in topology_before.chains()]
|
|
chains_after = [chain for chain in topology_after.chains()]
|
|
self.assertTrue(len(chains_after) == len(chains_before) + chain_delta)
|
|
|
|
# validate that the correct number of residues are deleted
|
|
residues_before = [residue for residue in topology_before.residues()]
|
|
residues_after = [residue for residue in topology_after.residues()]
|
|
self.assertTrue(len(residues_after) == len(residues_before) + residue_delta)
|
|
|
|
# validate that the correct number of atoms are deleted
|
|
atoms_before = [atom for atom in topology_before.atoms()]
|
|
atoms_after = [atom for atom in topology_after.atoms()]
|
|
self.assertTrue(len(atoms_after) == len(atoms_before) + atoms_delta)
|
|
# end of validate_deltas()
|
|
|
|
def validate_equivalence(self, topology_before, topology_after):
|
|
""" Validate that two topologies are equivalent. """
|
|
|
|
# First, check that they have the same number of each type of atom.
|
|
|
|
# construct dictionaries with the counts of each atom by symbol
|
|
atom_count_before = {}
|
|
for atom in topology_before.atoms():
|
|
if atom.element.symbol not in atom_count_before:
|
|
atom_count_before[atom.element.symbol] = 1
|
|
else:
|
|
atom_count_before[atom.element.symbol] += 1
|
|
|
|
atom_count_after = {}
|
|
for atom in topology_after.atoms():
|
|
if atom.element.symbol not in atom_count_after:
|
|
atom_count_after[atom.element.symbol] = 1
|
|
else:
|
|
atom_count_after[atom.element.symbol] += 1
|
|
|
|
# make sure the dictionaries are equivalent
|
|
self.assertTrue(atom_count_before==atom_count_after)
|
|
|
|
# Next, we want to confirm that every hydrogen is in exactly one bond
|
|
# and that heavy atoms are bonded to the same number of hydrogens.
|
|
# To achieve this, we build two dictionaries for each topology; one for
|
|
# hydrogens and one for heavy atoms. The keys will be the atom indices.
|
|
|
|
def build_bond_dicts(topology):
|
|
hydrogen_bonds = {}
|
|
heavy_atom_bonds = {}
|
|
for bond in topology.bonds():
|
|
if bond[0].element.symbol=='H':
|
|
if bond[0].index not in hydrogen_bonds:
|
|
hydrogen_bonds[bond[0].index] = 1
|
|
else:
|
|
hydrogen_bonds[bond[0].index] += 1
|
|
if bond[1].index not in heavy_atom_bonds:
|
|
heavy_atom_bonds[bond[1].index] = 1
|
|
else:
|
|
heavy_atom_bonds[bond[1].index] += 1
|
|
elif bond[1].element.symbol=='H':
|
|
if bond[1].index not in hydrogen_bonds:
|
|
hydrogen_bonds[bond[1].index] = 1
|
|
else:
|
|
hydrogen_bonds[bond[1].index] += 1
|
|
if bond[0].index not in heavy_atom_bonds:
|
|
heavy_atom_bonds[bond[0].index] = 1
|
|
else:
|
|
heavy_atom_bonds[bond[0].index] += 1
|
|
|
|
return (hydrogen_bonds, heavy_atom_bonds)
|
|
|
|
(hydrogen_bonds_before, heavy_atom_bonds_before) = build_bond_dicts(topology_before)
|
|
(hydrogen_bonds_after, heavy_atom_bonds_after) = build_bond_dicts(topology_after)
|
|
|
|
atom_list_before = []
|
|
for atom in topology_before.atoms():
|
|
if atom.element.symbol != 'H':
|
|
atom_list_before.append((atom.index, atom.name))
|
|
atom_list_after = []
|
|
for atom in topology_after.atoms():
|
|
if atom.element.symbol != 'H':
|
|
atom_list_after.append((atom.index, atom.name))
|
|
|
|
correspondence_dict = {}
|
|
for i in range(len(atom_list_before)):
|
|
correspondence_dict[atom_list_before[i][0]] = atom_list_after[i][0]
|
|
if atom_list_before[i][1] != atom_list_after[i][1]:
|
|
# shouldn't get here!
|
|
self.assertTrue(0==1)
|
|
|
|
# also check that there is exactly one bond per hydrogen after adding hydrogens
|
|
for key in hydrogen_bonds_after:
|
|
self.assertTrue(hydrogen_bonds_after[key]==1)
|
|
|
|
# check that each heavy atom has the same number of hydrogen bonds
|
|
for key in heavy_atom_bonds_before:
|
|
self.assertTrue(heavy_atom_bonds_before[key]==heavy_atom_bonds_after[correspondence_dict[key]])
|
|
|
|
# end of validate_equivalence
|