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]