2 from __future__
import print_function
19 from io
import StringIO
21 from random
import random
23 kB = (1.381 * 6.02214) / 4184.0
28 def __init__(self, cont, md, n_md_steps):
31 self.n_md_steps = n_md_steps
38 for i
in range(self.cont.get_number_of_particles()):
39 p = self.cont.get_particle(i)
41 self.oldcoords.append(d.get_coordinates())
43 def propose_move(self, prob):
44 self.md.optimize(self.n_md_steps)
47 for i
in range(self.cont.get_number_of_particles()):
48 p = self.cont.get_particle(i)
52 d.set_coordinates(self.oldcoords[i])
54 def get_number_of_steps(self):
55 return self.n_md_steps
57 def set_number_of_steps(self, nsteps):
58 self.n_md_steps = nsteps
64 def __init__(self, model):
67 def add_mover(self, mv):
73 def set_return_best(self, thing):
76 def set_move_probability(self, thing):
80 pot = self.m.evaluate(
False)
82 kin = self.mv.md.get_kinetic_energy()
85 def metropolis(self, old, new):
88 print(
": old %f new %f deltaE %f new_epot: %f"
89 % (old, new, deltaE, self.m.evaluate(
False)), end=
' ')
94 return exp(-deltaE / kT) > random()
96 def optimize(self, nsteps):
98 print(
"=== new MC call")
101 for i
in range(nsteps):
102 print(
"MC step %d " % i, end=
' ')
104 self.mv.md.assign_velocities(self.kT / kB)
106 old = self.get_energy()
108 self.mv.propose_move(1)
110 new = self.get_energy()
111 if self.metropolis(old, new):
121 def get_number_of_forward_steps(self):
127 """nonspecific methods used across all shared function objects.
129 - Their name starts with the name of the parent function (e.g.
131 - they don't store anything in the class, but instead
132 return all created objects.
133 Exceptions: the model, which is self._m
134 the statistics class, which is self.stat
135 - they store what they have to store in the model (e.g. restraints)
136 - they don't print out anything except for long routines (e.g. NOE
138 - the prior RestraintSet is added to the model when it is created, so
139 that when it is passed to another function, it is not added twice.
145 def set_checklevel(self, value):
148 def set_loglevel(self, value):
151 def m(self, name, *args, **kw):
152 "wrapper to call methods of m"
153 func = getattr(self._m, name)
154 return func(*args, **kw)
157 "moves to wd and creates model"
163 self, initpdb, top, par, selector, pairscore,
164 ff_temp=300.0, disulfides=
None, representation=
'custom'):
165 """creates a CHARMM protein representation.
166 creates the charmm force field, bonded and nonbonded.
167 - initpdb: initial structure in pdb format
168 - top is a CHARMM top.lib, read if representation=='custom' (default)
169 - par is a CHARMM par.lib
170 - selector is an instance of
171 one of the selectors of IMP.atom, for example
172 IMP.atom.NonWaterNonHydrogenPDBSelector().
173 - pairscore is an instance of a Pair Score to score the interaction
174 between two atoms. usually, it's either
175 LennardJonesDistancePairScore(0,1) or
176 RepulsiveDistancePairScore(0,1)
177 - ff_temp is the temperature at which the force field should be
179 - disulfides: if not None, a list of tuples corresponding to residue
180 numbers that should be cross-linked. Residues should be
181 cysteines, and residue numbering should start at 0.
182 - representation: 'full' : all-atom CHARMM force field
183 'heavy': heavy atom CHARMM forcefield with polar H
184 'calpha': only C alphas, ball and stick model with
185 bondlength 3.78 angstrom, beads at VdW
186 contact, and harmonic restraint between
188 'custom' (default) : read given CHARMM top and par
190 Returns: prot, ff, rsb, rs
192 - ff: the force field
193 - rsb: the RestraintSet on bonded interactions
194 - rs: the RestraintSet on nonbonded interactions. Both are weighted
199 if not prot.get_is_valid(
True):
200 raise ValueError(
"invalid hierarchy!")
201 if representation ==
'custom':
204 elif representation ==
'heavy':
206 elif representation ==
'full':
208 elif representation ==
'calpha':
211 raise NotImplementedError(representation)
212 if representation ==
'calpha':
213 print(
"setting up simplified C alpha force field")
215 for ca
in IMP.atom.get_by_type(prot, IMP.atom.ATOM_TYPE):
220 for chain
in prot.get_children():
221 residues = [(chain.get_child(i), chain.get_child(i + 1))
222 for i
in range(chain.get_number_of_children() - 1)]
223 residues = [(i.get_child(0).get_particle(),
224 j.get_child(0).get_particle())
225 for (i, j)
in residues]
226 pairs.extend(residues)
246 rsb.add_restraint(br)
247 rsb.set_weight(1.0 / (kB * ff_temp))
249 nonbonded_pair_filter.set_bonds(bonds)
252 print(
"setting up CHARMM forcefield")
257 topology = ff.create_topology(prot)
262 topology.apply_default_patches()
265 s = topology.get_segment(0)
266 dis = ff.get_patch(
'DISU')
267 for (i, j)
in disulfides:
270 r0 = s.get_residue(i)
271 r1 = s.get_residue(j)
273 r0.set_patched(
False)
275 r1.set_patched(
False)
277 print(
"added disulfide bridge between cysteines %d and %d"
284 topology.setup_hierarchy(prot)
296 ff.add_well_depths(prot)
297 nonbonded_pair_filter = r.get_pair_filter()
299 atoms = IMP.atom.get_by_type(prot, IMP.atom.ATOM_TYPE)
311 nbl.add_pair_filter(nonbonded_pair_filter)
316 return prot, ff, rsb, rs
319 """sets up a Scale particle to the initial default value. It can
320 optionally be constrained between two positive bounds, or else its
321 range is 0 to infinity.
326 scale.set_lower(lower)
328 scale.set_upper(upper)
332 """given a list of scales, returns a RestraintSet('prior') with weight
333 1.0 that contains a list of vonMisesKappaJeffreysRestraint on each
334 scale. If argument prior_rs is used, add them to that RestraintSet
339 prior_rs.set_weight(1.0)
345 """given a list of scales, returns a RestraintSet('prior') with weight
346 1.0 that contains a list of JeffreysRestraint on each scale.
347 If argument prior_rs is used, add them to that RestraintSet instead.
353 prior_rs.add_restraint(jr)
357 """given a list of scales, returns a RestraintSet('prior') with weight
358 1.0 that contains a list of vonMisesKappaConjugateRestraint on each
359 scale. If argument prior_rs is used, add them to that RestraintSet
362 if not (0 <= R <= c):
363 raise ValueError(
"parameters R and c should satisfy 0 <= R <= c")
367 prior_rs.add_restraint(
372 """scans the prot hierarchy and tries to find atom = (resno, name)
373 assumes that resno follows the same numbering as the sequence.
374 Stores already found atoms for increased speed.
376 if not hasattr(self,
'__memoized'):
377 self.__memoized = {prot: {}}
379 return self.__memoized[prot][atom]
384 residue_index=atom[0],
386 ).get_selected_particles()
388 print(
"found multiple atoms for atom %d %s!" % atom)
392 print(
"atom %d %s not found" % atom)
394 self.__memoized[prot][atom] = p0
399 Sets up a vonMises torsion angle restraint using the given kappa
400 particle as concentration parameter. Returns the restraint.
401 data is a list of observations.
407 Sets up a vonMises torsion angle restraint using the given kappa
408 particle as concentration parameter. Returns the restraint.
409 data is (mean, standard deviation).
411 raise NotImplementedError
415 Sets up a lognormal distance restraint using the given sigma and gamma.
416 Returns the restraint.
417 assumes atoms = (atom1, atom2)
418 where atom1 is (resno, atomname) and resno is the residue sequence
436 """Reads an ambiguous NOE restraint. contributions is a list of
437 (atom1, atom2) pairs, where atom1 is (resno, atomname). Sets up a
438 lognormal distance restraint using the given sigma and gamma.
439 Returns the restraint.
442 pairs = [(self.
find_atom(i, prot).get_particle(),
443 self.
find_atom(j, prot).get_particle())
for (i, j)
in
448 pairs, sigma, gamma, distance ** (-6))
452 self, prot, seqfile, tblfile, name=
'NOE', prior_rs=
None,
453 bounds_sigma=(1.0, 0.1, 100), bounds_gamma=(1.0, 0.1, 100),
454 verbose=
True, sequence_match=(1, 1)):
455 """read TBL file and store NOE restraints, using one sigma and one
456 gamma for the whole dataset. Creates the necessary uninformative
458 - prot: protein hierarchy
459 - seqfile: a file with 3-letter sequence
460 - tblfile: a TBL file with the restraints
461 - name: an optional name for the restraintset
462 - prior_rs: when not None, add new sigma and gamma to this
463 RestraintSet instance.
464 - bounds_sigma or gamma: tuple of (initial value, lower, upper bound)
465 bounds can be -1 to set to default range [0,+inf]
466 - verbose: be verbose (default True)
467 - sequence_match : (noe_start, sequence_start)
468 Returns: data_rs, prior_rs, sigma, gamma
472 print(
"Prior for the NOE Scales")
480 seqfile, first_residue_number=sequence_match[1])
481 tblr = IMP.isd.TBLReader.TBLReader(sequence,
482 sequence_match=sequence_match)
483 restraints = tblr.read_distances(tblfile,
'NOE')[
'NOE']
484 for i, restraint
in enumerate(restraints):
485 if verbose
and i % 100 == 0:
486 print(
"\r%d" % i, end=
' ')
491 if len(restraint[0]) > 1:
494 restraint[1], sigma, gamma)
497 restraint[1], sigma, gamma)
500 print(
"\r%d NOE restraints read" % i)
503 return rs, prior_rs, sigma, gamma
506 verbose=
True, sequence_match=(1, 1)):
507 """read TBL file and store NOE restraints, using the marginal of the
508 lognormal with one sigma and one gamma, for the whole dataset.
509 - prot: protein hierarchy
510 - seqfile: a file with 3-letter sequence
511 - tblfile: a TBL file with the restraints
512 - name: an optional name for the restraintset
513 - verbose: be verbose (default True)
514 - sequence_match : (noe_start, sequence_start)
521 seqfile, first_residue_number=sequence_match[1])
522 tblr = IMP.isd.TBLReader.TBLReader(sequence,
523 sequence_match=sequence_match)
524 restraints = tblr.read_distances(tblfile,
'NOE')[
'NOE']
526 for i, restraint
in enumerate(restraints):
527 if verbose
and i % 100 == 0:
528 print(
"\r%d" % i, end=
' ')
534 pairs = [(self.
find_atom(i, prot).get_particle(),
535 self.
find_atom(j, prot).get_particle())
for (i, j)
in
538 ln.add_contribution(pairs, restraint[4])
541 print(
"\r%d NOE contributions added" % (len(restraints)))
546 """read TBL file and store lognormal restraints, using the marginal
547 of the lognormal with one sigma and gamma=1, for the whole dataset.
548 - prot: protein hierarchy
549 - seqfile: a file with 3-letter sequence
550 - tblfile: a TBL file with the restraints
551 - name: an optional name for the restraintset
552 - verbose: be verbose (default True)
559 tblr = IMP.isd.TBLReader.TBLReader(sequence)
560 restraints = tblr.read_distances(tblfile,
'HBond')[
'HBond']
562 for i, restraint
in enumerate(restraints):
563 if verbose
and i % 100 == 0:
564 print(
"\r%d" % i, end=
' ')
570 pairs = [(self.
find_atom(i, prot).get_particle(),
571 self.
find_atom(j, prot).get_particle())
for (i, j)
in
574 ln.add_contribution(pairs, restraint[4])
577 print(
"\r%d Hbond contributions added" % (len(restraints)))
581 sequence_match=(1, 1), name=
'TALOS', prior_rs=
None,
582 bounds_kappa=(1.0, 0.1, 10), verbose=
True,
583 prior=
'jeffreys', keep_all=
False):
584 """read TALOS dihedral angle data, and create restraints for phi/psi
585 torsion angles, along with the prior for kappa, which is a scale for
586 the whole dataset, compare to 1/sigma**2 in the NOE case.
587 - prot: protein hierarchy
588 - seqfile: a file with 3-letter sequence
589 - talos_data: either a file (pred.tab), or a folder (pred/) in which
590 all files in the form res???.tab can be found. If
591 possible, try to provide the folder, as statistics are
592 more accurate in that case.
593 - fulldata : either True or False, whether the data is the full TALOS
594 output (predAll.tab or pred/ folder), or just the averages
596 - sequence_match : (talos_no, sequence_no) to adjust for different
598 - name: an optional name for the restraintset
599 - prior_rs: when not None, add new kappa(s) to this RestraintSet
601 - bounds_kappa: tuple of (initial value, lower, upper bound)
602 bounds can be -1 to set to default range [0,+inf]
603 - verbose: be verbose (default True)
604 - prior: either 'jeffreys' or a tuple (R,c), which signifies to use the
605 conjugate prior of the von Mises restraint, with parameters R
606 and c. Good values are R=0 and c=10. Default: jeffreys prior.
607 - keep_all: in case of a folder for 'talos_data', whether to keep
608 candidates marked as 'outliers' by TALOS, or to include
610 Returns: data_rs, prior_rs, kappa
615 print(
"Prior for von Mises Kappa")
620 print(
"reading data")
623 seqfile, first_residue_no=sequence_match[1])
626 sequence,
True, keep_all, sequence_match=sequence_match)
627 if os.path.isdir(talos_data):
629 for i, res
in enumerate(glob(os.path.join(talos_data,
631 if verbose
and i % 100:
632 print(
"\r%d" % i, end=
' ')
637 talosr.read(talos_data)
641 sequence,
False, keep_all, sequence_match=sequence_match)
642 talosr.read(talos_data)
644 data = talosr.get_data()
646 print(
"\rread dihedral data for %d residues" % len(data))
647 print(
"creating restraints")
649 for resno, datum
in data.items():
650 phidata = datum[
'phi']
651 psidata = datum[
'psi']
661 avgR.append(r.get_R0())
666 avgR.append(r.get_R0())
672 avgR.append(r.get_R0())
677 avgR.append(r.get_R0())
679 print(
"%s Restraints created. Average R0: %f"
680 % (len(avgR), sum(avgR) / float(len(avgR))))
681 return rs, prior_rs, kappa
684 self, prot, profilefile, name=
'SAXS',
685 ff_type=IMP.saxs.HEAVY_ATOMS):
686 """read experimental SAXS profile and apply restraint the standard
688 Returns: a restraintset and the experimental profile
692 particles = IMP.atom.get_by_type(prot, IMP.atom.ATOM_TYPE)
694 rs.add_restraint(saxs_restraint)
695 return rs, saxs_profile
697 def _setup_md(self, prot, temperature=300.0, thermostat='berendsen',
698 coupling=500, md_restraints=
None, timestep=1.0,
699 recenter=1000, momentum=1000):
700 """setup molecular dynamics
701 - temperature: target temperature
702 - thermostat: one of 'NVE', rescale_velocities',
703 'berendsen', 'langevin'
704 - coupling: coupling constant (tau (fs) for berendsen,
705 gamma (/fs) for langevin)
706 - md_restraints: if not None, specify the terms of the energy to be
707 used during the md steps via a list of restraints.
708 - timestep: in femtoseconds.
709 - recenter: recenter the molecule every so many steps (Langevin only)
710 - momentum: remove angular momentum every so many steps
712 Returns: an instance of md and an instance of an OptimizerState (the
713 thermostat), or None if NVE.
717 md.assign_velocities(temperature)
718 md.set_time_step(timestep)
719 if thermostat ==
'NVE':
721 elif thermostat ==
'rescale_velocities':
724 md.add_optimizer_state(os)
725 elif thermostat ==
'berendsen':
728 md.add_optimizer_state(os)
731 md.add_optimizer_state(mom)
732 elif thermostat ==
'langevin':
735 md.add_optimizer_state(os)
740 raise NotImplementedError(thermostat)
743 md.set_restraints(md_restraints)
747 def _setup_normal_mover(self, particle, floatkey, stepsize):
748 """setup NormalMover to move particle's floatkey attribute
749 by a gaussian with standard deviation 'stepsize'
750 Returns: mover instance.
756 def _setup_md_mover(self, md, particles, temperature, n_md_steps=10):
757 """setup MDMover using md and particles.
759 - particles: particles to move, usually the leaves of the protein
761 - n_md_steps: number of md steps to perform on each move
762 Returns: mover instance.
766 return IMP.atom.MDMover(cont, md, temperature, n_md_steps)
768 def _setup_mc(self, mover, temperature=300.0, mc_restraints=None):
769 """setup monte carlo using a certain mover.
770 - mover: mover to use, NormalMover or MDMover usually.
771 - temperature: target temperature.
772 - mc_restraints: if not None, list of restraints for the metropolis
774 Returns: mc instance.
780 mc.set_kt(kB * temperature)
782 mc.set_return_best(
False)
785 mc.set_restraints(mc_restraints)
789 self, prot, temperature=300.0, gamma=0.01, n_md_steps=10,
790 md_restraints=
None, mc_restraints=
None, timestep=1.0,
791 sd_threshold=0.0, sd_stepsize=0.01, sd_maxsteps=100):
792 """setup hybrid monte-carlo on protein. Uses basin hopping with
793 steepest descent minimization.
794 - prot: protein hierarchy.
795 - temperature: target temperature.
796 - gamma: coupling constant for langevin (/fs)
797 - n_md_steps: number of md steps per mc step
798 - md_restraints: if not None, specify the terms of the energy to be
799 used during the md steps.
800 - mc_restraints: if not None, use these energy terms for the metropolis
802 - timestep: time step for md, in femtoseconds.
803 - sd_threshold: stop steepest descent after energy difference drops
805 - sd_stepsize: stepsize to use for the steepest descent, in angstrom.
806 - sd_maxsteps: maximum number of steps for steepest descent
807 Returns: hmc, mdmover, md and OptimizerState (thermostat)
809 raise NotImplementedError
810 md, os = self._setup_md(prot, temperature=temperature,
811 thermostat=
'langevin', coupling=gamma,
812 md_restraints=md_restraints, timestep=timestep)
813 particles = IMP.atom.get_by_type(prot, IMP.atom.ATOM_TYPE)
814 mdmover = self._setup_md_mover(md, particles, temperature, n_md_steps)
815 hmc = self._setup_mc(mdmover, temperature, mc_restraints)
817 sd.set_threshold(sd_threshold)
818 sd.set_step_size(sd_stepsize)
819 hmc.set_local_optimizer(sd)
820 hmc.set_local_steps(sd_maxsteps)
821 hmc.set_use_basin_hopping(
True)
822 return hmc, mdmover, md, os
825 self, prot, temperature=300.0, n_md_steps=100, md_restraints=
None,
826 mc_restraints=
None, timestep=1.0):
827 """setup hybrid monte-carlo on protein. Uses NVE MD and tries the full
828 - prot: protein hierarchy.
829 - temperature: target temperature.
830 - coupling: coupling constant (tau (fs) for berendsen,
831 gamma (/fs) for langevin)
832 - n_md_steps: number of md steps per mc step
833 - md_restraints: if not None, specify the terms of the energy to be
834 used during the md steps.
835 - mc_restraints: if not None, use these energy terms for the metropolis
837 - timestep: time step for md, in femtoseconds.
838 - sd_threshold: stop steepest descent after energy difference drops
840 - sd_stepsize: stepsize to use for the steepest descent, in angstrom.
841 - sd_maxsteps: maximum number of steps for steepest descent
842 Returns: hmc, mdmover and md
844 prot = self._p[
'prot']
845 md, os = self._setup_md(prot, temperature=temperature,
846 thermostat=
'NVE', coupling=
None, timestep=1.0,
847 md_restraints=md_restraints)
848 particles = IMP.atom.get_by_type(prot, IMP.atom.ATOM_TYPE)
851 mdmover = PyMDMover(cont, md, n_md_steps)
855 mc.add_mover(mdmover)
857 mc.set_kt(kB * temperature)
859 mc.set_return_best(
False)
861 mc.set_move_probability(1.0)
862 return mc, mdmover, md
865 mc_restraints=
None, nm_stepsize=0.1):
866 """sets up monte carlo on nuisance, at a certain target temperature,
867 optionally using a certain set of restraints only.
868 - nuis: nuisance particle
869 - temperature: target temperature
870 - mc_restraints: optional set of restraints from which the energy
871 should be drawn instead of the energy of the complete system.
872 - floatkey: the floatkey to move.
873 - nm_stepsize: the stepsize of the normal mover
874 Returns: mc instance, nm instance.
876 nm = self._setup_normal_mover(nuis, nuis.get_nuisance_key(),
878 mc = self._setup_mc(nm, temperature, mc_restraints)
881 def _mc_and_update_nm(self, nsteps, mc, nm, stats_key,
882 adjust_stepsize=
True):
883 """run mc using a normal mover on a single particle,
884 update stepsize and store nsteps, acceptance and stepsize in the
885 statistics instance self.stat by using the key stats_key.
889 naccept = mc.get_number_of_forward_steps()
891 self.stat.increment_counter(stats_key, nsteps)
893 accept = float(naccept) / nsteps
894 self.stat.update(stats_key,
'acceptance', accept)
895 stepsize = nm.get_sigma()
896 self.stat.update(stats_key,
'stepsize', stepsize)
899 if 0.4 < accept < 0.6:
905 nm.set_sigma(stepsize * 2 * accept)
907 def _hmc_and_update_md(self, nsteps, hmc, mv, stats_key,
908 adjust_stepsize=
True):
909 """run hmc, update stepsize and print statistics. Updates number of MD
910 steps to reach a target acceptance between 0.4 and 0.6, sends
911 statistics to self.stat. MD steps are always at least 10 and at
915 naccept = hmc.get_number_of_forward_steps()
916 self.stat.increment_counter(stats_key, nsteps)
917 accept = float(naccept) / nsteps
918 self.stat.update(stats_key,
'acceptance', accept)
919 mdsteps = mv.get_number_of_steps()
920 self.stat.update(stats_key,
'n_md_steps', mdsteps)
922 if 0.4 < accept < 0.6:
924 mdsteps = int(mdsteps * 2 ** (accept - 0.5))
929 mv.set_nsteps(mdsteps)
932 """returns a string corresponding to the pdb structure of hierarchy
937 return output.getvalue()
939 def get_netcdf(self, prot):
940 raise NotImplementedError
943 temperature=300.0, prot_coordinates=
None):
944 """updates statistics for md simulation: target temp, kinetic energy,
945 kinetic temperature, writes coordinates and increments counter.
946 - md_key: stats md key
947 - nsteps: number of steps performed.
948 - md_instance: instance of the MolecularDynamics class.
949 - temperature: target temperature
950 - prot_coordinates: protein coordinates to be passed to the stats
951 class, (should be a string)
953 self.stat.update(md_key,
'target_temp', temperature)
954 kinetic = md_instance.get_kinetic_energy()
955 self.stat.update(md_key,
'E_kinetic', kinetic)
956 self.stat.update(md_key,
'instant_temp',
957 md_instance.get_kinetic_temperature(kinetic))
958 self.stat.update_coordinates(md_key,
'protein', prot_coordinates)
959 self.stat.increment_counter(md_key, nsteps)
962 """shortcut for a frequent series of operations on MC simulations'
963 statistics. Creates an entry for acceptance, stepsize and one
964 coordinate set printed in the statistics file.
967 mc_key = stat.add_category(name=name)
969 stat.add_entry(mc_key, entry=Entry(
'temperature',
'%10G',
None))
970 stat.add_entry(mc_key, entry=Entry(
'acceptance',
'%10G',
None))
971 stat.add_entry(mc_key, entry=Entry(
'stepsize',
'%10G',
None))
973 stat.add_entry(mc_key, entry=Entry(coord,
'%10G',
None))
975 stat.add_entry(mc_key, name=
'counter')
979 """shortcut for a frequent series of operations on MD simulations'
980 statistics. Creates an entry for target temp, instantaneous temp,
981 kinetic energy, and one set of coordinates called 'protein' by
985 md_key = stat.add_category(name=name)
987 stat.add_entry(md_key, entry=Entry(
'target_temp',
'%10G',
None))
988 stat.add_entry(md_key, entry=Entry(
'instant_temp',
'%10G',
None))
989 stat.add_entry(md_key, entry=Entry(
'E_kinetic',
'%10G',
None))
991 stat.add_coordinates(md_key, coord)
993 stat.add_entry(md_key, name=
'counter')
997 """shortcut for a frequent series of operations on HMC simulations'
998 statistics. Adds acceptance, number of MD steps and a trajectory for
1002 hmc_key = stat.add_category(name=name)
1004 stat.add_entry(hmc_key, entry=Entry(
'temperature',
'%10G',
None))
1005 stat.add_entry(hmc_key, entry=Entry(
'acceptance',
'%10G',
None))
1006 stat.add_entry(hmc_key, entry=Entry(
'n_md_steps',
'%10G',
None))
1007 stat.add_entry(hmc_key, entry=Entry(
'E_kinetic',
'%10G',
None))
1009 stat.add_coordinates(hmc_key, coord)
1011 stat.add_entry(hmc_key, name=
'counter')
1015 """rescale the velocities of a bunch of particles having vx vy and vz
1021 p.set_value(k, p.get_value(k) * factor)
Applies a SingletonScore to each Singleton in a list.
def rescale_velocities
rescale the velocities of a bunch of particles having vx vy and vz floatkeys
CHARMMParameters * get_heavy_atom_CHARMM_parameters()
def init_model_ambiguous_NOE_restraint
Reads an ambiguous NOE restraint.
Maintains temperature during molecular dynamics.
Enforce CHARMM stereochemistry on the given Hierarchy.
Atoms get_phi_dihedral_atoms(Residue rd)
Return the atoms comprising the phi dihedral.
def do_md_protein_statistics
updates statistics for md simulation: target temp, kinetic energy, kinetic temperature, writes coordinates and increments counter.
def init_model_charmm_protein_and_ff
creates a CHARMM protein representation.
def find_atom
scans the prot hierarchy and tries to find atom = (resno, name) assumes that resno follows the same n...
def init_model_NOEs
read TBL file and store NOE restraints, using one sigma and one gamma for the whole dataset...
Various classes to hold sets of particles.
def init_simulation_setup_nuisance_mc
sets up monte carlo on nuisance, at a certain target temperature, optionally using a certain set of r...
A decorator for a particle which has bonds.
def init_simulation_setup_protein_hmc_nve
setup hybrid monte-carlo on protein.
Calculate score based on fit to SAXS profile.
A simple steepest descent optimizer.
void write_pdb(const Selection &mhd, TextOutput out, unsigned int model=1)
def init_model_TALOS
read TALOS dihedral angle data, and create restraints for phi/psi torsion angles, along with the prio...
Ambiguous NOE distance restraint between a number of pairs of particles.
def get_pdb
returns a string corresponding to the pdb structure of hierarchy prot.
def init_model_base
moves to wd and creates model
def init_model_NOEs_marginal
read TBL file and store NOE restraints, using the marginal of the lognormal with one sigma and one ga...
Return all close unordered pairs of particles taken from the SingletonContainer.
Classes to handle ISD statistics files.
def init_model_NOE_restraint
Sets up a lognormal distance restraint using the given sigma and gamma.
void read_pdb(TextInput input, int model, Hierarchy h)
CHARMM force field parameters.
Object used to hold a set of restraints.
Bond create_custom_bond(Bonded a, Bonded b, Float length, Float stiffness=-1)
Connect the two wrapped particles by a custom bond.
Class for storing model, its restraints, constraints, and particles.
Removes rigid translation and rotation from the particles.
def init_model_vonMises_restraint_full
Sets up a vonMises torsion angle restraint using the given kappa particle as concentration parameter...
Store a list of ParticleIndexPairs.
Conjugate prior for the concentration parameter of a von Mises distribution.
Maintains temperature during molecular dynamics by velocity scaling.
ParticleIndexPairs get_indexes(const ParticlePairsTemp &ps)
Get the indexes from a list of particle pairs.
def init_model_jeffreys_kappa
given a list of scales, returns a RestraintSet('prior') with weight 1.0 that contains a list of vonMi...
Simple molecular dynamics simulator.
Store a list of ParticleIndexes.
Atoms get_psi_dihedral_atoms(Residue rd)
Return the atoms comprising the psi dihedral.
def init_stats_add_md_category
shortcut for a frequent series of operations on MD simulations' statistics.
def init_model_HBonds_marginal
read TBL file and store lognormal restraints, using the marginal of the lognormal with one sigma and ...
Apply an NOE distance restraint between two particles.
Base class for all optimizers.
static Bonded setup_particle(Model *m, ParticleIndex pi)
Jeffreys prior for the concentration parameter of a von Mises distribution.
def init_stats_add_mc_category
shortcut for a frequent series of operations on MC simulations' statistics.
def init_simulation_setup_protein_hmc_hopper
setup hybrid monte-carlo on protein.
A decorator for a particle with x,y,z coordinates.
static Scale setup_particle(Model *m, ParticleIndex pi)
phi/psi dihedral restraint between four particles, using data from TALOS.
Score the bond based on a UnaryFunction,.
def read_sequence_file
read sequence of ONE chain, 1-letter or 3-letter, returns dict of no:3-letter code.
reads a TALOS file, or a TALOS folder, and stores the data
Modify a set of continuous variables using a normal distribution.
nonspecific methods used across all shared function objects.
void set_log_level(LogLevel l)
Set the current global log level.
A decorator for a residue.
Apply a lognormal distance restraint between two particles.
Basic functionality that is expected to be used by a wide variety of IMP users.
def init_model_standard_SAXS_restraint
read experimental SAXS profile and apply restraint the standard way (like foxs) Returns: a restraints...
def init_model_setup_scale
sets up a Scale particle to the initial default value.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
def init_model_jeffreys
given a list of scales, returns a RestraintSet('prior') with weight 1.0 that contains a list of Jeffr...
Residue get_residue(Atom d, bool nothrow=false)
Return the Residue containing this atom.
A filter that excludes bonds, angles and dihedrals.
Class to handle individual particles of a Model object.
def init_model_vonMises_restraint_mean
Sets up a vonMises torsion angle restraint using the given kappa particle as concentration parameter...
def init_stats_add_hmc_category
shortcut for a frequent series of operations on HMC simulations' statistics.
def m
wrapper to call methods of m
Apply an NOE distance restraint between two particles.
Functionality for loading, creating, manipulating and scoring atomic structures.
CHARMMParameters * get_all_atom_CHARMM_parameters()
Hierarchies get_leaves(const Selection &h)
Classes to handle TALOS files or folders.
Select hierarchy particles identified by the biological name.
Applies a PairScore to each Pair in a list.
Support for small angle X-ray scattering (SAXS) data.
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
def init_model_conjugate_kappa
given a list of scales, returns a RestraintSet('prior') with weight 1.0 that contains a list of vonMi...
Inferential scoring building on methods developed as part of the Inferential Structure Determination ...
Classes to handle TBL files.
Harmonic function (symmetric about the mean)
Maintains temperature during molecular dynamics.
A decorator for a particle with x,y,z coordinates and a radius.