11 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
as _swig_python_version_info
19 import builtins
as __builtin__
25 strthis =
"proxy of " + self.this.__repr__()
26 except __builtin__.Exception:
28 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
31 def _swig_setattr_nondynamic_instance_variable(set):
32 def set_instance_attr(self, name, value):
34 set(self, name, value)
35 elif name ==
"thisown":
37 elif hasattr(self, name)
and isinstance(getattr(type(self), name), property):
38 set(self, name, value)
40 raise AttributeError(
"You cannot add instance attributes to %s" % self)
41 return set_instance_attr
44 def _swig_setattr_nondynamic_class_variable(set):
45 def set_class_attr(cls, name, value):
46 if hasattr(cls, name)
and not isinstance(getattr(cls, name), property):
49 raise AttributeError(
"You cannot add class attributes to %s" % cls)
53 def _swig_add_metaclass(metaclass):
54 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
56 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
60 class _SwigNonDynamicMeta(type):
61 """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
62 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
67 class IMP_MODELLER_SwigPyIterator(object):
68 r"""Proxy of C++ swig::IMP_MODELLER_SwigPyIterator class."""
70 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
73 raise AttributeError(
"No constructor defined - class is abstract")
75 __swig_destroy__ = _IMP_modeller.delete_IMP_MODELLER_SwigPyIterator
78 r"""value(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
79 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_value(self)
82 r"""incr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator"""
83 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_incr(self, n)
86 r"""decr(IMP_MODELLER_SwigPyIterator self, size_t n=1) -> IMP_MODELLER_SwigPyIterator"""
87 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_decr(self, n)
89 def distance(self, x):
90 r"""distance(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t"""
91 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_distance(self, x)
94 r"""equal(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
95 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_equal(self, x)
98 r"""copy(IMP_MODELLER_SwigPyIterator self) -> IMP_MODELLER_SwigPyIterator"""
99 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_copy(self)
102 r"""next(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
103 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_next(self)
106 r"""__next__(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
107 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___next__(self)
110 r"""previous(IMP_MODELLER_SwigPyIterator self) -> PyObject *"""
111 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_previous(self)
113 def advance(self, n):
114 r"""advance(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
115 return _IMP_modeller.IMP_MODELLER_SwigPyIterator_advance(self, n)
118 r"""__eq__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
119 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___eq__(self, x)
122 r"""__ne__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> bool"""
123 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___ne__(self, x)
125 def __iadd__(self, n):
126 r"""__iadd__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
127 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___iadd__(self, n)
129 def __isub__(self, n):
130 r"""__isub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
131 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___isub__(self, n)
133 def __add__(self, n):
134 r"""__add__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator"""
135 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___add__(self, n)
137 def __sub__(self, *args):
139 __sub__(IMP_MODELLER_SwigPyIterator self, ptrdiff_t n) -> IMP_MODELLER_SwigPyIterator
140 __sub__(IMP_MODELLER_SwigPyIterator self, IMP_MODELLER_SwigPyIterator x) -> ptrdiff_t
142 return _IMP_modeller.IMP_MODELLER_SwigPyIterator___sub__(self, *args)
147 _IMP_modeller.IMP_MODELLER_SwigPyIterator_swigregister(IMP_MODELLER_SwigPyIterator)
154 IMP_DEBUG = _IMP_modeller.IMP_DEBUG
156 IMP_RELEASE = _IMP_modeller.IMP_RELEASE
158 IMP_SILENT = _IMP_modeller.IMP_SILENT
160 IMP_PROGRESS = _IMP_modeller.IMP_PROGRESS
162 IMP_TERSE = _IMP_modeller.IMP_TERSE
164 IMP_VERBOSE = _IMP_modeller.IMP_VERBOSE
166 IMP_MEMORY = _IMP_modeller.IMP_MEMORY
168 IMP_NONE = _IMP_modeller.IMP_NONE
170 IMP_USAGE = _IMP_modeller.IMP_USAGE
172 IMP_INTERNAL = _IMP_modeller.IMP_INTERNAL
174 IMP_KERNEL_HAS_LOG4CXX = _IMP_modeller.IMP_KERNEL_HAS_LOG4CXX
176 IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_modeller.IMP_COMPILER_HAS_CEREAL_RAW_POINTER
178 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_modeller.IMP_COMPILER_HAS_DEBUG_VECTOR
180 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_modeller.IMP_COMPILER_HAS_RANDOM_SHUFFLE
182 IMP_COMPILER_HAS_THREE_WAY = _IMP_modeller.IMP_COMPILER_HAS_THREE_WAY
184 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_KERNEL_HAS_BOOST_RANDOM
186 IMP_KERNEL_HAS_NUMPY = _IMP_modeller.IMP_KERNEL_HAS_NUMPY
188 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_modeller.IMP_KERNEL_HAS_GPERFTOOLS
190 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
192 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_modeller.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
194 IMPKERNEL_SHOW_WARNINGS = _IMP_modeller.IMPKERNEL_SHOW_WARNINGS
198 class _DirectorObjects(object):
199 """@internal Simple class to keep references to director objects
200 to prevent premature deletion."""
203 def register(self, obj):
204 """Take a reference to a director object; will only work for
205 refcounted C++ classes"""
206 if hasattr(obj,
'get_ref_count'):
207 self._objects.append(obj)
209 """Only drop our reference and allow cleanup by Python if no other
210 Python references exist (we hold 3 references: one in self._objects,
211 one in x, and one in the argument list for getrefcount) *and* no
212 other C++ references exist (the Python object always holds one)"""
213 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
214 or x.get_ref_count() > 1]
218 def get_object_count(self):
219 """Get number of director objects (useful for testing only)"""
220 return len(self._objects)
221 _director_objects = _DirectorObjects()
223 class _ostream(object):
224 r"""Proxy of C++ std::ostream class."""
226 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
228 def __init__(self, *args, **kwargs):
229 raise AttributeError(
"No constructor defined")
230 __repr__ = _swig_repr
232 def write(self, osa_buf):
233 r"""write(_ostream self, char const * osa_buf)"""
234 return _IMP_modeller._ostream_write(self, osa_buf)
237 _IMP_modeller._ostream_swigregister(_ostream)
238 IMP_C_OPEN_BINARY = _IMP_modeller.IMP_C_OPEN_BINARY
241 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_FILESYSTEM
243 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CGAL_HAS_BOOST_RANDOM
247 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CGAL_HAS_BOOST_SYSTEM
249 IMP_CGAL_HAS_NUMPY = _IMP_modeller.IMP_CGAL_HAS_NUMPY
251 IMPCGAL_SHOW_WARNINGS = _IMP_modeller.IMPCGAL_SHOW_WARNINGS
254 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_IMP_CGAL
256 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
258 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
260 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_RANDOM
262 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_ALGEBRA_HAS_BOOST_SYSTEM
264 IMP_ALGEBRA_HAS_CGAL = _IMP_modeller.IMP_ALGEBRA_HAS_CGAL
266 IMP_ALGEBRA_HAS_NUMPY = _IMP_modeller.IMP_ALGEBRA_HAS_NUMPY
268 IMP_ALGEBRA_HAS_ANN = _IMP_modeller.IMP_ALGEBRA_HAS_ANN
270 IMPALGEBRA_SHOW_WARNINGS = _IMP_modeller.IMPALGEBRA_SHOW_WARNINGS
273 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_IMP_CGAL
275 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
277 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
279 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_RANDOM
281 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_DISPLAY_HAS_BOOST_SYSTEM
283 IMP_DISPLAY_HAS_CGAL = _IMP_modeller.IMP_DISPLAY_HAS_CGAL
285 IMP_DISPLAY_HAS_NUMPY = _IMP_modeller.IMP_DISPLAY_HAS_NUMPY
287 IMPDISPLAY_SHOW_WARNINGS = _IMP_modeller.IMPDISPLAY_SHOW_WARNINGS
290 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
292 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
294 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
296 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
298 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
300 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_CGAL
302 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_HDF5
304 IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_modeller.IMP_SCORE_FUNCTOR_HAS_NUMPY
306 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_modeller.IMPSCOREFUNCTOR_SHOW_WARNINGS
309 IMP_CORE_HAS_IMP_CGAL = _IMP_modeller.IMP_CORE_HAS_IMP_CGAL
311 IMP_CORE_HAS_IMP_KERNEL = _IMP_modeller.IMP_CORE_HAS_IMP_KERNEL
313 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_FILESYSTEM
315 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
317 IMP_CORE_HAS_BOOST_RANDOM = _IMP_modeller.IMP_CORE_HAS_BOOST_RANDOM
319 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_CORE_HAS_BOOST_SYSTEM
321 IMP_CORE_HAS_CGAL = _IMP_modeller.IMP_CORE_HAS_CGAL
323 IMP_CORE_HAS_HDF5 = _IMP_modeller.IMP_CORE_HAS_HDF5
325 IMP_CORE_HAS_NUMPY = _IMP_modeller.IMP_CORE_HAS_NUMPY
327 IMPCORE_SHOW_WARNINGS = _IMP_modeller.IMPCORE_SHOW_WARNINGS
330 IMP_MODELLER_HAS_IMP_ALGEBRA = _IMP_modeller.IMP_MODELLER_HAS_IMP_ALGEBRA
332 IMP_MODELLER_HAS_IMP_CGAL = _IMP_modeller.IMP_MODELLER_HAS_IMP_CGAL
334 IMP_MODELLER_HAS_IMP_DISPLAY = _IMP_modeller.IMP_MODELLER_HAS_IMP_DISPLAY
336 IMP_MODELLER_HAS_IMP_KERNEL = _IMP_modeller.IMP_MODELLER_HAS_IMP_KERNEL
338 IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR = _IMP_modeller.IMP_MODELLER_HAS_IMP_SCORE_FUNCTOR
340 IMP_MODELLER_HAS_BOOST_FILESYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_FILESYSTEM
342 IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS = _IMP_modeller.IMP_MODELLER_HAS_BOOST_PROGRAMOPTIONS
344 IMP_MODELLER_HAS_BOOST_RANDOM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_RANDOM
346 IMP_MODELLER_HAS_BOOST_SYSTEM = _IMP_modeller.IMP_MODELLER_HAS_BOOST_SYSTEM
348 IMP_MODELLER_HAS_CGAL = _IMP_modeller.IMP_MODELLER_HAS_CGAL
350 IMP_MODELLER_HAS_HDF5 = _IMP_modeller.IMP_MODELLER_HAS_HDF5
352 IMP_MODELLER_HAS_NUMPY = _IMP_modeller.IMP_MODELLER_HAS_NUMPY
354 IMP_MODELLER_HAS_PYTHON_IHM = _IMP_modeller.IMP_MODELLER_HAS_PYTHON_IHM
356 IMPMODELLER_SHOW_WARNINGS = _IMP_modeller.IMPMODELLER_SHOW_WARNINGS
365 import modeller.scripts
366 import modeller.optimizers
370 if not hasattr(modeller.terms,
'EnergyTerm'):
371 modeller.terms.EnergyTerm = modeller.terms.energy_term
372 modeller.Selection = modeller.selection
375 class _TempDir(object):
376 """Make a temporary directory that is deleted when the object is."""
379 self.tmpdir = tempfile.mkdtemp()
382 shutil.rmtree(self.tmpdir, ignore_errors=
True)
386 """A Modeller restraint which evaluates an IMP scoring function.
387 This can be used to incorporate IMP Restraints into an existing
388 comparative modeling pipeline, or to use Modeller optimizers or
392 _physical_type = modeller.physical.absposition
394 def __init__(self, particles, scoring_function=None):
396 @param particles A list of the IMP atoms (as Particle objects),
397 same order as the Modeller atoms.
398 @param scoring_function An IMP::ScoringFunction object that will
399 be incorporated into the Modeller score (molpdf).
400 @note since Modeller, unlike IMP, is sensitive to the ordering
401 of atoms, it usually makes sense to create the model in
402 Modeller and then use ModelLoader to load it into IMP,
403 since that will preserve the Modeller atom ordering in IMP.
405 modeller.terms.EnergyTerm.__init__(self)
406 self._particles = particles
408 self._sf = scoring_function
410 self._sf = particles[0].get_model()
412 def eval(self, mdl, deriv, indats):
413 atoms = self.indices_to_atoms(mdl, indats)
414 _copy_modeller_coords_to_imp(atoms, self._particles)
415 if len(self._particles) == 0:
418 score = self._sf.evaluate(deriv)
420 dvx = [0.] * len(indats)
421 dvy = [0.] * len(indats)
422 dvz = [0.] * len(indats)
423 _get_imp_derivs(self._particles, dvx, dvy, dvz)
424 return (score, dvx, dvy, dvz)
430 """An IMP restraint using all defined Modeller restraints.
431 This is useful if you want to use Modeller restraints with an IMP
432 optimizer, or in combination with IMP restraints.
434 @note Currently only the coordinates of the atoms are translated
435 between Modeller and IMP; thus, a Modeller restraint which
436 uses any other attribute (e.g. charge) will not react if
437 this attribute is changed by IMP.
440 def __init__(self, model, modeller_model, particles):
442 @param model The IMP Model object.
443 @param modeller_model The Modeller model object.
444 @param particles A list of the IMP atoms (as Particle objects),
445 in the same order as the Modeller atoms.
446 @note since Modeller, unlike IMP, is sensitive to the ordering
447 of atoms, it usually makes sense to create the model in
448 Modeller and then use ModelLoader to load it into IMP,
449 since that will preserve the Modeller atom ordering in IMP.
452 if hasattr(x,
'get_particle'):
453 return x.get_particle()
456 IMP.Restraint.__init__(self, model,
"ModellerRestraints %1%")
457 self._modeller_model = modeller_model
458 self._particles = [get_particle(x)
for x
in particles]
461 atoms = self._modeller_model.atoms
462 sel = modeller.Selection(self._modeller_model)
463 _copy_imp_coords_to_modeller(self._particles, atoms)
464 energies = sel.energy()
466 _add_modeller_derivs_to_imp(atoms, self._particles, accum)
472 def do_show(self, fh):
473 fh.write(
"ModellerRestraints")
475 return self._particles
478 def _copy_imp_coords_to_modeller(particles, atoms):
479 """Copy atom coordinates from IMP to Modeller"""
483 for (num, at)
in enumerate(atoms):
484 at.x = particles[num].get_value(xkey)
485 at.y = particles[num].get_value(ykey)
486 at.z = particles[num].get_value(zkey)
489 def _copy_modeller_coords_to_imp(atoms, particles):
490 """Copy atom coordinates from Modeller to IMP"""
494 for (num, at)
in enumerate(atoms):
495 particles[num].set_value(xkey, at.x)
496 particles[num].set_value(ykey, at.y)
497 particles[num].set_value(zkey, at.z)
500 def _add_modeller_derivs_to_imp(atoms, particles, accum):
501 """Add atom derivatives from Modeller to IMP"""
502 for (num, at)
in enumerate(atoms):
504 xyz.add_to_derivative(0, at.dvx, accum)
505 xyz.add_to_derivative(1, at.dvy, accum)
506 xyz.add_to_derivative(2, at.dvz, accum)
509 def _get_imp_derivs(particles, dvx, dvy, dvz):
510 """Move atom derivatives from IMP to Modeller"""
514 for idx
in range(0, len(dvx)):
515 dvx[idx] = particles[idx].get_derivative(xkey)
516 dvy[idx] = particles[idx].get_derivative(ykey)
517 dvz[idx] = particles[idx].get_derivative(zkey)
521 def _HarmonicLowerBoundGenerator(parameters, modalities):
522 (mean, stdev) = parameters
526 def _HarmonicUpperBoundGenerator(parameters, modalities):
527 (mean, stdev) = parameters
531 def _HarmonicGenerator(parameters, modalities):
532 (mean, stdev) = parameters
536 def _CosineGenerator(parameters, modalities):
537 (phase, force_constant) = parameters
538 (periodicity,) = modalities
541 def _LinearGenerator(parameters, modalities):
542 (scale,) = parameters
545 def _SplineGenerator(parameters, modalities):
546 (open, low, high, delta, lowderiv, highderiv) = parameters[:6]
548 for v
in parameters[6:]:
556 _unary_func_generators = {
557 1: _HarmonicLowerBoundGenerator,
558 2: _HarmonicUpperBoundGenerator,
559 3: _HarmonicGenerator,
562 10: _SplineGenerator,
566 def _DistanceRestraintGenerator(form, modalities, atoms, parameters):
567 unary_func_gen = _unary_func_generators[form]
569 unary_func_gen(parameters, modalities),
572 def _AngleRestraintGenerator(form, modalities, atoms, parameters):
573 unary_func_gen = _unary_func_generators[form]
575 unary_func_gen(parameters, modalities),
576 atoms[0], atoms[1], atoms[2])
578 def _MultiBinormalGenerator(form, modalities, atoms, parameters):
579 nterms = modalities[0]
580 if len(parameters) != nterms * 6:
581 raise ValueError(
"Incorrect number of parameters (%d) for multiple "
582 "binormal restraint - expecting %d (%d terms * 6)" \
583 % (len(parameters), nterms * 6, nterms))
585 atoms[:4], atoms[4:8])
586 for i
in range(nterms):
588 t.set_weight(parameters[i])
589 t.set_means((parameters[nterms + i * 2],
590 parameters[nterms + i * 2 + 1]))
591 t.set_standard_deviations((parameters[nterms * 3 + i * 2],
592 parameters[nterms * 3 + i * 2 + 1]))
593 t.set_correlation(parameters[nterms * 5 + i])
597 def _DihedralRestraintGenerator(form, modalities, atoms, parameters):
599 return _MultiBinormalGenerator(form, modalities, atoms, parameters)
600 unary_func_gen = _unary_func_generators[form]
602 unary_func_gen(parameters, modalities),
603 atoms[0], atoms[1], atoms[2], atoms[3])
605 def _get_protein_atom_particles(protein):
606 """Given a protein particle, get the flattened list of all child atoms"""
608 for ichain
in range(protein.get_number_of_children()):
609 chain = protein.get_child(ichain)
610 for ires
in range(chain.get_number_of_children()):
611 residue = chain.get_child(ires)
612 for iatom
in range(residue.get_number_of_children()):
613 atom = residue.get_child(iatom)
614 atom_particles.append(atom.get_particle())
615 return atom_particles
617 def _load_restraints_line(line, atom_particles):
618 """Parse a single Modeller restraints file line and return the
619 corresponding IMP restraint."""
622 if typ ==
'MODELLER5':
625 raise NotImplementedError(
"Only 'R' lines currently read from " + \
626 "Modeller restraints files")
627 form = int(spl.pop(0))
628 modalities = [int(spl.pop(0))]
629 features = [int(spl.pop(0))]
632 natoms = [int(spl.pop(0))]
633 nparam = int(spl.pop(0))
634 nfeat = int(spl.pop(0))
635 for i
in range(nfeat - 1):
636 modalities.append(int(spl.pop(0)))
637 features.append(int(spl.pop(0)))
638 natoms.append(int(spl.pop(0)))
639 atoms = [int(spl.pop(0))
for x
in range(natoms[0])]
640 for i
in range(len(atoms)):
641 atoms[i] = atom_particles[atoms[i] - 1]
642 parameters = [float(spl.pop(0))
for x
in range(nparam)]
643 restraint_generators = {
644 1 : _DistanceRestraintGenerator,
645 2 : _AngleRestraintGenerator,
646 3 : _DihedralRestraintGenerator,
647 4 : _DihedralRestraintGenerator,
649 restraint_gen = restraint_generators[features[0]]
650 return restraint_gen(form, modalities, atoms, parameters)
653 def _load_entire_restraints_file(filename, protein):
654 """Yield a set of IMP restraints from a Modeller restraints file."""
655 atoms = _get_protein_atom_particles(protein)
656 with open(filename,
'r') as fh:
659 rsr = _load_restraints_line(line, atoms)
662 except Exception
as err:
663 print(
"Cannot read restraints file line:\n" + line)
667 def _copy_residue(r, model):
668 """Copy residue information from modeller to imp"""
673 p.set_name(str(
"residue "+r.num));
677 def _copy_atom(a, model):
678 """Copy atom information from modeller"""
684 if hasattr(a,
'charge'):
686 if hasattr(a,
'type'):
688 ap.set_input_index(a.index)
691 def _copy_chain(c, model):
692 """Copy chain information from modeller"""
699 def _get_forcefield(submodel):
711 """Add radii to the hierarchy using the Modeller radius library, radii.lib.
712 Each radius is scaled by the given scale (Modeller usually scales radii
713 by a factor of 0.82). submodel specifies the topology submodel, which is
714 the column in radii.lib to use."""
718 with open(filename)
as fh:
720 if line.startswith(
'#'):
continue
723 radii[spl[0]] = float(spl[submodel])
724 atoms = IMP.atom.get_by_type(hierarchy, IMP.atom.ATOM_TYPE)
729 radius = radii[ct] * scale
737 """Read a Modeller model into IMP. After creating this object, the atoms
738 in the Modeller model can be loaded into IMP using the load_atoms()
739 method, then optionally any Modeller static restraints can be read in
740 with load_static_restraints() or load_static_restraints_file().
742 This class can also be used to read Modeller alignment structures;
743 however, only load_atoms() will be useful in such a case (since
744 alignment structures don't have restraints or other information).
750 @param modeller_model The Modeller model or alignment structure
753 self._modeller_model = modeller_model
756 """Construct an IMP::atom::Hierarchy that contains the same atoms as
757 the Modeller model or alignment structure.
759 IMP atoms created from a Modeller model will be given charges and
760 CHARMM types, extracted from the model. Alignment structures don't
761 contain this information, so the IMP atoms won't either.
763 @param model The IMP::Model object in which the hierarchy will be
764 created. The highest level hierarchy node is a PROTEIN.
765 @return the newly-created root IMP::atom::Hierarchy.
770 for chain
in self._modeller_model.chains:
775 for residue
in chain.residues:
776 rp = _copy_residue(residue, model)
779 for atom
in residue.atoms:
780 ap = _copy_atom(atom, model)
783 self._atoms[atom.index] = ap
785 self._modeller_hierarchy = hpp
788 def _get_nonbonded_list(self, atoms, pair_filter, edat, distance):
793 if pair_filter
is None:
795 if edat.excl_local[0]:
796 pair_filter.set_bonds(list(self.
load_bonds()))
797 if edat.excl_local[1]:
799 if edat.excl_local[2]:
801 nbl.add_pair_filter(pair_filter)
805 """Load the Modeller bond topology into the IMP model. Each bond is
806 represented in IMP as an IMP::atom::Bond, with no defined length
807 or stiffness. These bonds are primarily useful as input to
808 IMP::atom::StereochemistryPairFilter, to exclude bond interactions
809 from the nonbonded list. Typically the contribution to the scoring
810 function from the bonds is included in the Modeller static restraints
811 (use load_static_restraints() or load_static_restraints_file() to
812 load these). If you want to regenerate the stereochemistry in IMP,
813 do not use these functions (as then stereochemistry scoring terms
814 and exclusions would be double-counted) and instead use the
815 IMP::atom::CHARMMTopology class.
817 You must call load_atoms() prior to using this function.
818 @see load_angles(), load_dihedrals(), load_impropers()
819 @return A generator listing all of the bonds.
821 if not hasattr(self,
'_modeller_hierarchy'):
822 raise ValueError(
"Call load_atoms() first.")
823 for (maa, mab)
in self._modeller_model.bonds:
824 pa = self._atoms[maa.index]
825 pb = self._atoms[mab.index]
835 IMP.atom.Bond.SINGLE).get_particle()
838 """Load the Modeller angle topology into the IMP model.
839 See load_bonds() for more details."""
840 return self._internal_load_angles(self._modeller_model.angles,
844 """Load the Modeller dihedral topology into the IMP model.
845 See load_bonds() for more details."""
846 return self._internal_load_angles(self._modeller_model.dihedrals,
850 """Load the Modeller improper topology into the IMP model.
851 See load_bonds() for more details."""
852 return self._internal_load_angles(self._modeller_model.impropers,
855 def _internal_load_angles(self, angles, angle_class):
856 if not hasattr(self,
'_modeller_hierarchy'):
857 raise ValueError(
"Call load_atoms() first.")
858 for modeller_atoms
in angles:
859 imp_particles = [self._atoms[x.index]
for x
in modeller_atoms]
861 a = angle_class.setup_particle(p,
863 yield a.get_particle()
866 """Convert a Modeller static restraints file into equivalent
867 IMP::Restraints. load_atoms() must have been called first to read
868 in the atoms that the restraints will act upon.
869 @param filename Name of the Modeller restraints file. The restraints
870 in this file are assumed to act upon the model read in by
871 load_atoms(); no checking is done to enforce this.
872 @return A Python generator of the newly-created IMP::Restraint
875 if not hasattr(self,
'_modeller_hierarchy'):
876 raise ValueError(
"Call load_atoms() first.")
877 return _load_entire_restraints_file(filename, self._modeller_hierarchy)
881 """Convert the current set of Modeller static restraints into equivalent
882 IMP::Restraints. load_atoms() must have been called first to read
883 in the atoms that the restraints will act upon.
884 @return A Python generator of the newly-created IMP::Restraint
887 class _RestraintGenerator(object):
888 """Simple generator wrapper"""
891 def __iter__(self, *args, **keys):
893 def close(self, *args, **keys):
894 return self._gen.close(*args, **keys)
896 return next(self._gen)
898 def send(self, *args, **keys):
899 return self._gen.send(*args, **keys)
900 def throw(self, *args, **keys):
901 return self._gen.throw(*args, **keys)
904 rsrfile = os.path.join(t.tmpdir,
'restraints.rsr')
905 self._modeller_model.restraints.write(file=rsrfile)
908 wrap = _RestraintGenerator(gen)
914 """Convert Modeller dynamic restraints into IMP::Restraint objects.
916 For each currently active Modeller dynamic restraint
917 (e.g. soft-sphere, electrostatics) an equivalent IMP::Restraint
919 load_atoms() must have been called first to read
920 in the atoms that the restraints will act upon.
922 If pair_filter is given, it is an IMP::PairFilter object to exclude
923 pairs from the nonbonded lists used by the dynamic restraints.
924 Otherwise, an IMP::atom::StereochemistryPairFilter object is created
925 to exclude Modeller bonds, angles and dihedrals, as specified by
926 edat.excl_local. (Note that this calls load_bonds(), load_angles()
927 and load_dihedrals(), so will create duplicate lists of bonds if
928 those methods are called manually as well.)
930 @note Currently only soft-sphere, electrostatic and Lennard-Jones
931 restraints are loaded.
932 @return A Python generator of the newly-created IMP::Restraint
935 if not hasattr(self,
'_modeller_hierarchy'):
936 raise ValueError(
"Call load_atoms() first.")
937 edat = self._modeller_model.env.edat
938 libs = self._modeller_model.env.libs
940 m = atoms[0].get_model()
943 if edat.dynamic_sphere:
946 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, 0.)
949 libs.topology.submodel, edat.radii_factor)
956 if edat.dynamic_lennard
or edat.dynamic_coulomb:
958 d = max(edat.contact_shell - 3.0, 0.0)
959 nbl = self._get_nonbonded_list(atoms, pair_filter, edat, d)
960 ff = _get_forcefield(libs.topology.submodel)
961 ff.add_radii(self._modeller_hierarchy)
963 if edat.dynamic_lennard:
964 ff.add_well_depths(self._modeller_hierarchy)
966 edat.lennard_jones_switch[1])
970 if edat.dynamic_coulomb:
972 edat.coulomb_switch[1])
974 ps.set_relative_dielectric(edat.relative_dielectric)
980 r"""get_module_version() -> std::string const"""
981 return _IMP_modeller.get_module_version()
984 r"""get_example_path(std::string fname) -> std::string"""
985 return _IMP_modeller.get_example_path(fname)
988 r"""get_data_path(std::string fname) -> std::string"""
989 return _IMP_modeller.get_data_path(fname)
991 from .
import _version_check
static CHARMMAtom setup_particle(Model *m, ParticleIndex pi, String charmm_type)
Create a decorator with the passed CHARMM type.
static Charged setup_particle(Model *m, ParticleIndex pi, Float charge)
Lower bound harmonic function (non-zero when feature < mean)
def load_static_restraints
Convert the current set of Modeller static restraints into equivalent IMP::Restraints.
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
def load_bonds
Load the Modeller bond topology into the IMP model.
A Modeller restraint which evaluates an IMP scoring function.
Coulomb (electrostatic) score between a pair of particles.
static Atom setup_particle(Model *m, ParticleIndex pi, Atom other)
Various classes to hold sets of particles.
Upper bound harmonic function (non-zero when feature > mean)
static XYZR setup_particle(Model *m, ParticleIndex pi)
A decorator for a particle which has bonds.
def load_impropers
Load the Modeller improper topology into the IMP model.
Make CGAL functionality available to IMP.
virtual double unprotected_evaluate(DerivativeAccumulator *da) const
Return the unweighted score for the restraint.
std::string get_module_version()
Return the version of this module, as a string.
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
Dihedral restraint between four particles.
def load_static_restraints_file
Convert a Modeller static restraints file into equivalent IMP::Restraints.
A score on the distance between the surfaces of two spheres.
Return all close unordered pairs of particles taken from the SingletonContainer.
static Residue setup_particle(Model *m, ParticleIndex pi, ResidueType t, int index, int insertion_code)
A single binormal term in a MultipleBinormalRestraint.
def load_dynamic_restraints
Convert Modeller dynamic restraints into IMP::Restraint objects.
Distance restraint between two particles.
static XYZ setup_particle(Model *m, ParticleIndex pi)
Composable functors to implement scores via compile-time composition.
An IMP restraint using all defined Modeller restraints.
static bool get_is_setup(const IMP::ParticleAdaptor &p)
CHARMM force field parameters.
Bond create_bond(Bonded a, Bonded b, Bond o)
Connect the two wrapped particles by a custom bond.
def load_dihedrals
Load the Modeller dihedral topology into the IMP model.
static Float get_k_from_standard_deviation(Float sd, Float t=297.15)
Return the k to use for a given Gaussian standard deviation.
Angle restraint between three particles.
static Hierarchy setup_particle(Model *m, ParticleIndex pi, ParticleIndexesAdaptor children=ParticleIndexesAdaptor())
Create a Hierarchy of level t by adding the needed attributes.
ParticleIndexPairs get_indexes(const ParticlePairsTemp &ps)
Get the indexes from a list of particle pairs.
Lennard-Jones score between a pair of particles.
A particle that describes an angle between three particles.
The standard decorator for manipulating molecular structures.
Store a list of ParticleIndexes.
static Bonded setup_particle(Model *m, ParticleIndex pi)
def load_atoms
Construct an IMP::atom::Hierarchy that contains the same atoms as the Modeller model or alignment str...
Version and module information for Objects.
A decorator for a particle with x,y,z coordinates.
Modeller-style multiple binormal (phi/psi) restraint.
def add_soft_sphere_radii
Add radii to the hierarchy using the Modeller radius library, radii.lib.
A particle that describes a dihedral angle between four particles.
def load_angles
Load the Modeller angle topology into the IMP model.
Basic functionality that is expected to be used by a wide variety of IMP users.
General purpose algebraic and geometric methods that are expected to be used by a wide variety of IMP...
static bool get_is_setup(const IMP::ParticleAdaptor &p)
virtual VersionInfo get_version_info() const
Get information about the module and version of the object.
A filter that excludes bonds, angles and dihedrals.
Read a Modeller model into IMP.
Class to handle individual particles of a Model object.
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
Smooth interaction scores by switching the derivatives (force switch).
Output IMP model data in various file formats.
Functionality for loading, creating, manipulating and scoring atomic structures.
static Chain setup_particle(Model *m, ParticleIndex pi, std::string id)
Hierarchies get_leaves(const Selection &h)
Applies a PairScore to each Pair in a list.
virtual ModelObjectsTemp do_get_inputs() const =0
Closed cubic spline function.
A decorator for an atom that has a defined CHARMM type.
A restraint is a term in an IMP ScoringFunction.
Harmonic function (symmetric about the mean)
A decorator for a particle with x,y,z coordinates and a radius.