def test_run_point_mutation_propose():
"""
Propose a random mutation in insulin
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
max_point_mutants = 1
chain_id = 'A'
system_generator = create_simple_protein_system_generator()
system = system_generator.create_system(modeller.topology)
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
max_point_mutants=max_point_mutants)
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
def test_limiting_allowed_residues():
"""
Test example system with certain mutations allowed to mutate
"""
import perses.rjmc.topology_proposal as topology_proposal
failed_mutants = 0
pdbid = "1G3F"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
chain_id = 'B'
to_delete = list()
for chain in modeller.topology.chains():
if chain.id != chain_id:
to_delete.append(chain)
modeller.delete(to_delete)
modeller.addHydrogens()
ff_filename = "amber99sbildn.xml"
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
system_generator = topology_proposal.SystemGenerator([ff_filename])
max_point_mutants = 1
residues_allowed_to_mutate = ['903','904','905']
pl_top_library = topology_proposal.PointMutationEngine(modeller.topology, system_generator, chain_id, max_point_mutants=max_point_mutants, residues_allowed_to_mutate=residues_allowed_to_mutate)
pl_top_proposal = pl_top_library.propose(system, modeller.topology)
def test_propose_self():
"""
Propose a mutation to remain at WT in insulin
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
system_generator = create_simple_protein_system_generator()
system = system_generator.create_system(modeller.topology)
chain_id = 'A'
for chain in modeller.topology.chains():
if chain.id == chain_id:
residues = chain._residues
mutant_res = np.random.choice(residues[1:-1])
allowed_mutations = [(mutant_res.id, mutant_res.name)]
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
allowed_mutations=allowed_mutations)
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
assert pm_top_proposal.old_topology == pm_top_proposal.new_topology
assert pm_top_proposal.old_system == pm_top_proposal.new_system
assert pm_top_proposal.old_chemical_state_key == pm_top_proposal.new_chemical_state_key
def test_run_point_mutation_propose():
"""
Propose a random mutation in insulin
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
max_point_mutants = 1
chain_id = 'A'
# Pull the allowable mutatable residues..
_chain = [
chain for chain in modeller.topology.chains() if chain.id == chain_id
][0]
residue_ids = [
residue.id for residue in _chain.residues() if residue.name != 'CYS'
][1:-1]
system_generator = create_simple_protein_system_generator()
system = system_generator.create_system(modeller.topology)
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
max_point_mutants=max_point_mutants,
residues_allowed_to_mutate=residue_ids)
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
def test_run_point_mutation_propose():
"""
Propose a random mutation in insulin
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
ff_filename = "amber99sbildn.xml"
max_point_mutants = 1
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = 'A'
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
max_point_mutants=max_point_mutants)
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
def test_propose_self():
"""
Propose a mutation to remain at WT in insulin
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
ff_filename = "amber99sbildn.xml"
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = 'A'
for chain in modeller.topology.chains():
if chain.id == chain_id:
residues = chain._residues
mutant_res = np.random.choice(residues)
allowed_mutations = [[(mutant_res.id,mutant_res.name)]]
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(modeller.topology, system_generator, chain_id, allowed_mutations=allowed_mutations, verbose=True)
print('Self mutation:')
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
assert pm_top_proposal.old_topology == pm_top_proposal.new_topology
assert pm_top_proposal.old_system == pm_top_proposal.new_system
assert pm_top_proposal.old_chemical_state_key == pm_top_proposal.new_chemical_state_key
def test_mutate_quick():
"""
Abbreviated version of test_mutate_all for travis.
"""
import perses.rjmc.topology_proposal as topology_proposal
import perses.rjmc.geometry as geometry
from perses.tests.utils import compute_potential_components
from openmmtools import testsystems as ts
geometry_engine = geometry.FFAllAngleGeometryEngine()
aminos = ['ALA','VAL','GLY','PHE','PRO','TRP']
for aa in aminos:
topology, positions = _get_capped_amino_acid(amino_acid=aa)
modeller = app.Modeller(topology, positions)
ff_filename = "amber99sbildn.xml"
max_point_mutants = 1
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = '1'
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(modeller.topology, system_generator, chain_id, max_point_mutants=max_point_mutants)
current_system = system
current_topology = modeller.topology
current_positions = modeller.positions
minimize_integrator = openmm.VerletIntegrator(1.0*unit.femtosecond)
platform = openmm.Platform.getPlatformByName("Reference")
minimize_context = openmm.Context(current_system, minimize_integrator, platform)
minimize_context.setPositions(current_positions)
initial_state = minimize_context.getState(getEnergy=True)
initial_potential = initial_state.getPotentialEnergy()
openmm.LocalEnergyMinimizer.minimize(minimize_context)
final_state = minimize_context.getState(getEnergy=True, getPositions=True)
final_potential = final_state.getPotentialEnergy()
current_positions = final_state.getPositions()
print("Minimized initial structure from %s to %s" % (str(initial_potential), str(final_potential)))
for k, proposed_amino in enumerate(aminos):
pm_top_engine._allowed_mutations = [[('2',proposed_amino)]]
pm_top_proposal = pm_top_engine.propose(current_system, current_topology)
new_positions, logp = geometry_engine.propose(pm_top_proposal, current_positions, beta)
new_system = pm_top_proposal.new_system
if np.isnan(logp):
raise Exception("NaN in the logp")
integrator = openmm.VerletIntegrator(1*unit.femtoseconds)
platform = openmm.Platform.getPlatformByName("Reference")
context = openmm.Context(new_system, integrator, platform)
context.setPositions(new_positions)
state = context.getState(getEnergy=True)
print(compute_potential_components(context))
potential = state.getPotentialEnergy()
potential_without_units = potential / potential.unit
print(str(potential))
if np.isnan(potential_without_units):
raise Exception("Energy after proposal is NaN")
def test_alanine_dipeptide_map():
pdb_filename = resource_filename(
'openmmtools', 'data/alanine-dipeptide-gbsa/alanine-dipeptide.pdb')
from simtk.openmm.app import PDBFile
pdbfile = PDBFile(pdb_filename)
import perses.rjmc.topology_proposal as topology_proposal
modeller = app.Modeller(pdbfile.topology, pdbfile.positions)
ff_filename = "amber99sbildn.xml"
allowed_mutations = [[('2', 'PHE')]]
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = ' '
metadata = dict()
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
proposal_metadata=metadata,
allowed_mutations=allowed_mutations,
always_change=True)
proposal = pm_top_engine.propose(system, modeller.topology)
new_topology = proposal.new_topology
new_system = proposal.new_system
old_topology = proposal.old_topology
old_system = proposal.old_system
atom_map = proposal.old_to_new_atom_map
for k, atom in enumerate(old_topology.atoms()):
atom_idx = atom.index
if atom_idx in atom_map.keys():
atom2_idx = atom_map[atom_idx]
for l, atom2 in enumerate(new_topology.atoms()):
if atom2.index == atom2_idx:
new_atom = atom2
break
old_name = atom.name
new_name = new_atom.name
print('\n%s to %s' % (str(atom.residue), str(new_atom.residue)))
print('old_atom.index vs index in topology: %s %s' % (atom_idx, k))
print('new_atom.index vs index in topology: %s %s' %
(atom2_idx, l))
print('Who was matched: old %s to new %s' % (old_name, new_name))
if atom2_idx != l:
mass_by_map = system.getParticleMass(atom2_idx)
mass_by_sys = system.getParticleMass(l)
print('Should have matched %s actually got %s' %
(mass_by_map, mass_by_sys))
def test_always_change():
"""
Test 'always_change' argument in topology proposal
Allowing one residue to mutate, must change to a different residue each
of 50 iterations
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "1G3F"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
chain_id = 'B'
to_delete = list()
for chain in modeller.topology.chains():
if chain.id != chain_id:
to_delete.append(chain)
modeller.delete(to_delete)
modeller.addHydrogens()
ff_filename = "amber99sbildn.xml"
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
system_generator = topology_proposal.SystemGenerator([ff_filename])
max_point_mutants = 1
residues_allowed_to_mutate = ['903']
for residue in modeller.topology.residues():
if residue.id in residues_allowed_to_mutate:
print('Old residue: %s' % residue.name)
old_res_name = residue.name
pl_top_library = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
max_point_mutants=max_point_mutants,
residues_allowed_to_mutate=residues_allowed_to_mutate,
always_change=True)
topology = modeller.topology
for i in range(50):
pl_top_proposal = pl_top_library.propose(system, topology)
for residue in pl_top_proposal.new_topology.residues():
if residue.id in residues_allowed_to_mutate:
print('Iter %s New residue: %s' % (i, residue.name))
new_res_name = residue.name
assert (old_res_name != new_res_name)
old_res_name = new_res_name
topology = pl_top_proposal.new_topology
system = pl_top_proposal.new_system
def test_specify_allowed_mutants():
"""
Make sure proposals can be made using optional argument allowed_mutations
This test has three possible insulin systems: wild type, Q5E, and Q5N/Y14F
"""
chain_id = 'A'
allowed_mutations = [('5', 'GLU'), ('5', 'ASN'), ('14', 'PHE')]
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
system_generator = create_simple_protein_system_generator()
system = system_generator.create_system(modeller.topology)
chain_id = 'A'
for chain in modeller.topology.chains():
if chain.id == chain_id:
residues = chain._residues
mutant_res = np.random.choice(residues[1:-1])
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
allowed_mutations=allowed_mutations)
ntrials = 10
for trian in range(ntrials):
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
# Check to make sure no out-of-bounds atoms are present in new_to_old_atom_map
natoms_old = pm_top_proposal.n_atoms_old
natoms_new = pm_top_proposal.n_atoms_new
if not set(pm_top_proposal.new_to_old_atom_map.values()).issubset(
range(natoms_old)):
msg = "Some old atoms in TopologyProposal.new_to_old_atom_map are not in span of old atoms (1..%d):\n" % natoms_old
msg += str(pm_top_proposal.new_to_old_atom_map)
raise Exception(msg)
if not set(pm_top_proposal.new_to_old_atom_map.keys()).issubset(
range(natoms_new)):
msg = "Some new atoms in TopologyProposal.new_to_old_atom_map are not in span of old atoms (1..%d):\n" % natoms_new
msg += str(pm_top_proposal.new_to_old_atom_map)
raise Exception(msg)
def create_insulin_topology_engine(chain_id = 'A', allowed_mutations = None, pdbid = "2HIU"):
import perses.rjmc.topology_proposal as topology_proposal
from openmmforcefields.generators import SystemGenerator
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
system_generator = create_simple_protein_system_generator()
system = system_generator.create_system(modeller.topology)
pm_top_engine = topology_proposal.PointMutationEngine(modeller.topology, system_generator, chain_id, allowed_mutations=allowed_mutations)
return pm_top_engine, system, topology, modeller.positions
def test_specify_allowed_mutants():
"""
Make sure proposals can be made using optional argument allowed_mutations
This test has three possible insulin systems: wild type, Q5E, and Q5N/Y14F
"""
import perses.rjmc.topology_proposal as topology_proposal
pdbid = "2HIU"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
ff_filename = "amber99sbildn.xml"
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = 'A'
allowed_mutations = [[('5', 'GLU')], [('5', 'ASN'), ('14', 'PHE')]]
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
allowed_mutations=allowed_mutations)
ntrials = 10
for trian in range(ntrials):
pm_top_proposal = pm_top_engine.propose(system, modeller.topology)
# Check to make sure no out-of-bounds atoms are present in new_to_old_atom_map
natoms_old = pm_top_proposal.old_system.getNumParticles()
natoms_new = pm_top_proposal.new_system.getNumParticles()
if not set(pm_top_proposal.new_to_old_atom_map.values()).issubset(
range(natoms_old)):
msg = "Some old atoms in TopologyProposal.new_to_old_atom_map are not in span of old atoms (1..%d):\n" % natoms_old
msg += str(pm_top_proposal.new_to_old_atom_map)
raise Exception(msg)
if not set(pm_top_proposal.new_to_old_atom_map.keys()).issubset(
range(natoms_new)):
msg = "Some new atoms in TopologyProposal.new_to_old_atom_map are not in span of old atoms (1..%d):\n" % natoms_new
msg += str(pm_top_proposal.new_to_old_atom_map)
raise Exception(msg)
def test_mutate_from_every_amino_to_every_other():
"""
Make sure mutations are successful between every possible pair of before-and-after residues
Mutate Ecoli F-ATPase alpha subunit to all 20 amino acids (test going FROM all possibilities)
Mutate each residue to all 19 alternatives
"""
import perses.rjmc.topology_proposal as topology_proposal
aminos = [
'ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLY', 'HIS', 'ILE',
'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL'
]
failed_mutants = 0
pdbid = "2A7U"
topology, positions = load_pdbid_to_openmm(pdbid)
modeller = app.Modeller(topology, positions)
for chain in modeller.topology.chains():
pass
modeller.delete([chain])
ff_filename = "amber99sbildn.xml"
max_point_mutants = 1
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = 'A'
metadata = dict()
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(
modeller.topology,
system_generator,
chain_id,
proposal_metadata=metadata,
max_point_mutants=max_point_mutants,
always_change=True)
current_system = system
current_topology = modeller.topology
current_positions = modeller.positions
pm_top_engine._allowed_mutations = list()
for k, proposed_amino in enumerate(aminos):
pm_top_engine._allowed_mutations.append((str(k + 2), proposed_amino))
pm_top_proposal = pm_top_engine.propose(current_system, current_topology)
current_system = pm_top_proposal.new_system
current_topology = pm_top_proposal.new_topology
for chain in current_topology.chains():
if chain.id == chain_id:
# num_residues : int
num_residues = len(chain._residues)
break
new_sequence = list()
for residue in current_topology.residues():
if residue.index == 0:
continue
if residue.index == (num_residues - 1):
continue
if residue.name in ['HID', 'HIE']:
residue.name = 'HIS'
new_sequence.append(residue.name)
for i in range(len(aminos)):
assert new_sequence[i] == aminos[i]
pm_top_engine = topology_proposal.PointMutationEngine(
current_topology,
system_generator,
chain_id,
proposal_metadata=metadata,
max_point_mutants=max_point_mutants)
from perses.rjmc.topology_proposal import append_topology
old_topology = app.Topology()
append_topology(old_topology, current_topology)
new_topology = app.Topology()
append_topology(new_topology, current_topology)
old_chemical_state_key = pm_top_engine.compute_state_key(old_topology)
for chain in new_topology.chains():
if chain.id == chain_id:
# num_residues : int
num_residues = len(chain._residues)
break
for proposed_location in range(1, num_residues - 1):
print('Making mutations at residue %s' % proposed_location)
original_residue_name = chain._residues[proposed_location].name
matching_amino_found = 0
for proposed_amino in aminos:
pm_top_engine._allowed_mutations = [(str(proposed_location + 1),
proposed_amino)]
new_topology = app.Topology()
append_topology(new_topology, current_topology)
old_system = current_system
old_topology_natoms = sum([1 for atom in old_topology.atoms()])
old_system_natoms = old_system.getNumParticles()
if old_topology_natoms != old_system_natoms:
msg = 'PolymerProposalEngine: old_topology has %d atoms, while old_system has %d atoms' % (
old_topology_natoms, old_system_natoms)
raise Exception(msg)
metadata = dict()
for atom in new_topology.atoms():
atom.old_index = atom.index
index_to_new_residues, metadata = pm_top_engine._choose_mutant(
new_topology, metadata)
if len(index_to_new_residues) == 0:
matching_amino_found += 1
continue
print('Mutating %s to %s' %
(original_residue_name, proposed_amino))
residue_map = pm_top_engine._generate_residue_map(
new_topology, index_to_new_residues)
for res_pair in residue_map:
residue = res_pair[0]
name = res_pair[1]
assert residue.index in index_to_new_residues.keys()
assert index_to_new_residues[residue.index] == name
assert residue.name + '-' + str(
residue.id) + '-' + name in metadata['mutations']
new_topology, missing_atoms = pm_top_engine._delete_excess_atoms(
new_topology, residue_map)
new_topology = pm_top_engine._add_new_atoms(
new_topology, missing_atoms, residue_map)
for res_pair in residue_map:
residue = res_pair[0]
name = res_pair[1]
assert residue.name == name
atom_map = pm_top_engine._construct_atom_map(
residue_map, old_topology, index_to_new_residues, new_topology)
templates = pm_top_engine._ff.getMatchingTemplates(new_topology)
assert [
templates[index].name == residue.name
for index, (residue, name) in enumerate(residue_map)
]
new_chemical_state_key = pm_top_engine.compute_state_key(
new_topology)
new_system = pm_top_engine._system_generator.build_system(
new_topology)
pm_top_proposal = topology_proposal.TopologyProposal(
new_topology=new_topology,
new_system=new_system,
old_topology=old_topology,
old_system=old_system,
old_chemical_state_key=old_chemical_state_key,
new_chemical_state_key=new_chemical_state_key,
logp_proposal=0.0,
new_to_old_atom_map=atom_map)
assert matching_amino_found == 1
def test_mutate_from_all_to_all():
"""
Make sure mutations are successful between every possible pair of before-and-after residues
Mutate Ecoli F-ATPase alpha subunit to all 20 amino acids (test going FROM all possibilities)
Mutate each residue to all 19 alternatives
"""
import perses.rjmc.topology_proposal as topology_proposal
import perses.rjmc.geometry as geometry
from perses.tests.utils import compute_potential_components
from openmmtools import testsystems as ts
geometry_engine = geometry.FFAllAngleGeometryEngine()
aminos = ['ALA','ARG','ASN','ASP','CYS','GLN','GLU','GLY','HIS','ILE','LEU','LYS','MET','PHE','PRO','SER','THR','TRP','TYR','VAL']
for aa in aminos:
topology, positions = _get_capped_amino_acid(amino_acid=aa)
modeller = app.Modeller(topology, positions)
ff_filename = "amber99sbildn.xml"
max_point_mutants = 1
ff = app.ForceField(ff_filename)
system = ff.createSystem(modeller.topology)
chain_id = '1'
system_generator = topology_proposal.SystemGenerator([ff_filename])
pm_top_engine = topology_proposal.PointMutationEngine(modeller.topology, system_generator, chain_id, max_point_mutants=max_point_mutants)
current_system = system
current_topology = modeller.topology
current_positions = modeller.positions
minimize_integrator = openmm.VerletIntegrator(1.0*unit.femtosecond)
platform = openmm.Platform.getPlatformByName("Reference")
minimize_context = openmm.Context(current_system, minimize_integrator, platform)
minimize_context.setPositions(current_positions)
initial_state = minimize_context.getState(getEnergy=True)
initial_potential = initial_state.getPotentialEnergy()
openmm.LocalEnergyMinimizer.minimize(minimize_context)
final_state = minimize_context.getState(getEnergy=True, getPositions=True)
final_potential = final_state.getPotentialEnergy()
current_positions = final_state.getPositions()
print("Minimized initial structure from %s to %s" % (str(initial_potential), str(final_potential)))
for k, proposed_amino in enumerate(aminos):
pm_top_engine._allowed_mutations = [[('2',proposed_amino)]]
pm_top_proposal = pm_top_engine.propose(current_system, current_topology)
new_positions, logp = geometry_engine.propose(pm_top_proposal, current_positions, beta)
new_system = pm_top_proposal.new_system
if np.isnan(logp):
raise Exception("NaN in the logp")
integrator = openmm.VerletIntegrator(1*unit.femtoseconds)
platform = openmm.Platform.getPlatformByName("Reference")
context = openmm.Context(new_system, integrator, platform)
context.setPositions(new_positions)
state = context.getState(getEnergy=True)
print(compute_potential_components(context))
potential = state.getPotentialEnergy()
potential_without_units = potential / potential.unit
print(str(potential))
if np.isnan(potential_without_units):
raise Exception("Energy after proposal is NaN")
