def _makeUniverse(self):
from MMTK.Proteins import Protein, PeptideChain
from MMTK.ForceFields import CalphaForceField
self.universe = self.raw_trajectory.universe
self.proteins = self.universe.objectList(Protein)
universe_calpha = MMTK.InfiniteUniverse(CalphaForceField(2.5))
calpha_map = {}
for protein in self.proteins:
chains_calpha = []
for chain in protein:
chains_calpha.append(
PeptideChain(chain.sequence(), model='calpha'))
protein_calpha = Protein(chains_calpha)
universe_calpha.addObject(protein_calpha)
for i in range(len(protein)):
chain = protein[i]
chain_calpha = protein_calpha[i]
for j in range(len(chain)):
calpha_map[chain[j].peptide.C_alpha] = \
chain_calpha[j].peptide.C_alpha
chain_calpha[j].peptide.C_alpha.setMass(1.)
conf = self.raw_trajectory[0]
for atom, calpha in calpha_map.items():
calpha.setPosition(conf[atom])
self.universe_calpha = universe_calpha
universe_calpha.configuration()
self.map = universe_calpha.numberOfAtoms() * [None]
for atom, calpha in calpha_map.items():
self.map[calpha.index] = atom.index
def run(pdb1, pdb2, trajectory, nsteps, delpdb=0):
universe = TransitionPathUniverse(CalphaForceField(2.5))
universe.protein = Protein(pdb1, model='calpha')
conf1 = copy(universe.configuration())
struct2 = PDBConfiguration(pdb2).peptide_chains
for i in range(len(universe.protein)):
struct2[i].applyTo(universe.protein[i])
if delpdb:
os.unlink(pdb1)
os.unlink(pdb2)
tr, rms = universe.findTransformation(conf1)
universe.applyTransformation(tr)
conf2 = copy(universe.configuration())
universe.setBoundingBox(conf1, conf2)
path = TransitionPath(universe, conf1, conf2, step_length=0.05, nmodes=50)
path.refine(nsteps)
path.writeBestToTrajectory(trajectory,
("Transition path after %d steps, " % nsteps) +
("energy %d," % path.best_penalty))
def normalmodes_mmtk(selection,
cutoff=12.0,
ff='Deformation',
first=7,
last=10,
prefix='mmtk',
states=7,
factor=-1,
quiet=1):
'''
DESCRIPTION
Fast normal modes for large proteins using an elastic network model (CA only)
Based on:
http://dirac.cnrs-orleans.fr/MMTK/using-mmtk/mmtk-example-scripts/normal-modes/
'''
try:
import MMTK
except ImportError:
print('Failed to import MMTK, please add to PYTHONPATH')
raise CmdException
selection = selector.process(selection)
cutoff = float(cutoff)
first, last = int(first), int(last)
states, factor, quiet = int(states), float(factor), int(quiet)
from math import log
from chempy import cpv
from MMTK import InfiniteUniverse
from MMTK.PDB import PDBConfiguration
from MMTK.Proteins import Protein
from MMTK.NormalModes import NormalModes
from MMTK.ForceFields import DeformationForceField, CalphaForceField
from MMTK.FourierBasis import FourierBasis, estimateCutoff
from MMTK.NormalModes import NormalModes, SubspaceNormalModes
model = 'calpha'
ff = ff.lower()
if 'deformationforcefield'.startswith(ff):
forcefield = DeformationForceField(cutoff=cutoff / 10.)
elif 'calphaforcefield'.startswith(ff):
forcefield = CalphaForceField(cutoff=cutoff / 10.)
elif 'amber94forcefield'.startswith(ff):
from MMTK.ForceFields import Amber94ForceField
forcefield = Amber94ForceField()
model = 'all'
else:
raise NotImplementedError('unknown ff = ' + str(ff))
if not quiet:
print(' Forcefield:', forcefield.__class__.__name__)
if model == 'calpha':
selection = '(%s) and polymer and name CA' % (selection)
f = StringIO(cmd.get_pdbstr(selection))
conf = PDBConfiguration(f)
items = conf.createPeptideChains(model)
universe = InfiniteUniverse(forcefield)
universe.protein = Protein(*items)
nbasis = max(10, universe.numberOfAtoms() / 5)
cutoff, nbasis = estimateCutoff(universe, nbasis)
if not quiet:
print(" Calculating %d low-frequency modes." % nbasis)
if cutoff is None:
modes = NormalModes(universe)
else:
subspace = FourierBasis(universe, cutoff)
modes = SubspaceNormalModes(universe, subspace)
natoms = modes.array.shape[1]
frequencies = modes.frequencies
if factor < 0:
factor = log(natoms)
if not quiet:
print(' set factor to %.2f' % (factor))
if True: # cmd.count_atoms(selection) != natoms:
import tempfile, os
from MMTK import DCD
filename = tempfile.mktemp(suffix='.pdb')
sequence = DCD.writePDB(universe, None, filename)
z = [a.index for a in sequence]
selection = cmd.get_unused_name('_')
cmd.load(filename, selection, zoom=0)
os.remove(filename)
if cmd.count_atoms(selection) != natoms:
print('hmm... still wrong number of atoms')
def eigenfacs_iter(mode):
x = modes[mode - 1].array
return iter(x.take(z, 0))
for mode in range(first, min(last, len(modes)) + 1):
name = prefix + '%d' % mode
cmd.delete(name)
if not quiet:
print(' normalmodes: object "%s" for mode %d with freq. %.6f' % \
(name, mode, frequencies[mode-1]))
for state in range(1, states + 1):
cmd.create(name, selection, 1, state, zoom=0)
cmd.alter_state(
state,
name,
'(x,y,z) = cpv.add([x,y,z], cpv.scale(next(myit), myfac))',
space={
'cpv': cpv,
'myit': eigenfacs_iter(mode),
'next': next,
'myfac':
1e2 * factor * ((state - 1.0) / (states - 1.0) - 0.5)
})
cmd.delete(selection)
if model == 'calpha':
cmd.set('ribbon_trace_atoms', 1, prefix + '*')
cmd.show_as('ribbon', prefix + '*')
else:
cmd.show_as('lines', prefix + '*')
# Only arrow data is stored for later extraction
def Arrow(self, point1, point2, radius, **attributes):
self.arrows.append((point1, point2))
def Material(self, **attributes):
return None
def DiffuseMaterial(self, color):
return None
def EmissiveMaterial(self, color):
return None
# Create the system
universe = InfiniteUniverse(CalphaForceField())
universe.protein = Protein('insulin', model='calpha')
# Calculate the normal modes
modes = NormalModes(universe)
# Generate the vector field for the first non-zero mode
vector_field = AtomicVectorField(universe, 0.5, modes[6])
# Generate the graphics data
graphics = DummyGraphics()
vector_field.graphicsObjects(graphics_module=graphics)
# Print the arrow coordinates
for point1, point2 in graphics.arrows:
print(f"{point1} {point2}")
from MMTK import InfiniteUniverse
from MMTK.PDB import PDBConfiguration
from MMTK.Proteins import Protein
from MMTK.NormalModes import NormalModes
from MMTK.ForceFields import DeformationForceField, CalphaForceField
from MMTK.FourierBasis import FourierBasis, estimateCutoff
from MMTK.NormalModes import NormalModes, SubspaceNormalModes
model = 'calpha'
ff = ff.lower()
if 'deformationforcefield'.startswith(ff):
forcefield = DeformationForceField(cutoff=cutoff / 10.)
elif 'calphaforcefield'.startswith(ff):
forcefield = CalphaForceField(cutoff=cutoff / 10.)
elif 'amber94forcefield'.startswith(ff):
from MMTK.ForceFields import Amber94ForceField
forcefield = Amber94ForceField()
model = 'all'
else:
raise NotImplementedError('unknown ff = ' + str(ff))
if not quiet:
print(' Forcefield:', forcefield.__class__.__name__)
if model == 'calpha':
selection = '(%s) and polymer and name CA' % (selection)
f = StringIO(cmd.get_pdbstr(selection))
conf = PDBConfiguration(f)
items = conf.createPeptideChains(model)
def fit(pdb_file, map_file, energy_cutoff, label, trajectory_freq):
dmap = load(map_file)
universe = InfiniteUniverse(CalphaForceField(2.5))
universe.protein = Protein(pdb_file, model='calpha')
set_distances(universe.protein)
modes = calc_modes(universe, 3 * universe.numberOfAtoms())
for nmodes in range(6, len(modes)):
if modes[nmodes].frequency > energy_cutoff * modes[6].frequency:
break
if trajectory_freq > 0:
trajectory_filename = 'fit_%s_m%d.nc' % (label, nmodes)
print "Fit trajectory:", trajectory_filename
trajectory = Trajectory(
universe, trajectory_filename, 'w',
'Density fit %s using %d modes' % (label, nmodes))
actions = [
TrajectoryOutput(trajectory, ["configuration", "fit_error"], 0,
None, 1)
]
snapshot = SnapshotGenerator(universe, actions=actions)
snapshot.available_data.append('fit_error')
amplitude = 0.1
i = 0
fit = []
windex = 0
protocol_filename = 'fit_%s_m%d_fiterror.txt' % (label, nmodes)
print "Fit error protocol file:", protocol_filename
protocol = file(protocol_filename, 'w')
nmc = 2 * nmodes
modes = calc_modes(universe, nmc)
windows = N.arange(10.) * modes[nmodes].frequency / 10.
while 1:
f, gradient = dmap.fitWithGradient(universe)
fit.append(f)
print >> protocol, i, fit[-1]
protocol.flush()
if len(fit) > 1 and fit[-1] > fit[-2]:
amplitude /= 2.
random_width = gradient.norm()*(random/100.) \
/ N.sqrt(universe.numberOfAtoms())
random_vector = randomParticleVector(universe, random_width)
gradient = gradient + random_vector
displacement = ParticleVector(universe)
for n in range(nmodes):
m = modes[n]
if n < 6:
weight = 5. * weight_function(modes[6], windows[windex])
else:
weight = weight_function(m, windows[windex])
displacement = displacement + \
weight*m.massWeightedDotProduct(gradient)*m
displacement = displacement * amplitude / displacement.norm()
universe.setConfiguration(universe.configuration() + displacement)
fix_structure(universe.protein)
if trajectory_freq > 0 and i % trajectory_freq == 0:
snapshot(data={'fit_error': fit[-1]})
i = i + 1
if i % 20 == 0:
modes = calc_modes(universe, nmc)
if i % 10 == 0 and i > 50:
convergence = (fit[-1] - fit[-11]) / (fit[30] - fit[20])
if convergence < 0.05:
break
if convergence < 0.2:
windex = min(windex + 1, len(windows) - 1)
if convergence < 0.1:
amplitude = 0.5 * amplitude
protocol.close()
if trajectory_freq > 0:
trajectory.close()
pdb_out = 'fit_%s_m%d.pdb' % (label, nmodes)
print "Writing final structure to", pdb_out
universe.writeToFile(pdb_out)
# a simplified protein model which consists only of the C_alpha atoms.
# The ensemble is written to a trajectory file.
#
from MMTK import *
from MMTK.Proteins import Protein
from MMTK.ForceFields import CalphaForceField
from MMTK.NormalModes import NormalModes
from MMTK.Random import gaussian
from MMTK.Trajectory import Trajectory, SnapshotGenerator, TrajectoryOutput
# Construct the system. The scaling factor of 0.1 for the CalphaForceField
# was determined empirically for a C-phycocyanin dimer at 300 K; its value
# is expected to depend at least on the protein and the temperature,
# but the order of magnitude should be right for mid-sized proteins.
universe = InfiniteUniverse(CalphaForceField(2.5, 0.1))
universe.protein = Protein('insulin.pdb', model='calpha')
# Set all masses to the same value, since we don't want
# mass-weighted sampling.
for atom in universe.atomList():
atom.setMass(1.)
# Calculate normal modes. Note that the normal modes are automatically
# scaled to their vibrational amplitudes at a given temperature.
modes = NormalModes(universe, 300. * Units.K)
# Create trajectory
trajectory = Trajectory(universe, "insulin_backbone.nc", "w",
"Monte-Carlo sampling for insulin backbone")
def setUp(self):
self.universe = InfiniteUniverse(CalphaForceField())
protein = Protein('insulin_calpha')
self.universe.addObject(protein)
self.subset1 = protein[0]
self.subset2 = protein[1]
