Merge master

wrappers/python/simtk/openmm/app/dcdfile.py

@@ -55,12 +55,19 @@ class DCDFile(object):
     def __init__(self, file, topology, dt, firstStep=0, interval=1):
         """Create a DCD file and write out the header.
 
-        Parameters:
-         - file (file) A file to write to
-         - topology (Topology) The Topology defining the molecular system being written
-         - dt (time) The time step used in the trajectory
-         - firstStep (int=0) The index of the first step in the trajectory
-         - interval (int=1) The frequency (measured in time steps) at which states are written to the trajectory
+        Parameters
+        ----------
+        file : file
+            A file to write to
+        topology : Topology
+            The Topology defining the molecular system being written
+        dt : time
+            The time step used in the trajectory
+        firstStep : int=0
+            The index of the first step in the trajectory
+        interval : int=1
+            The frequency (measured in time steps) at which states are written
+            to the trajectory
         """
         self._file = file
         self._topology = topology
@@ -83,14 +90,21 @@ class DCDFile(object):
     def writeModel(self, positions, unitCellDimensions=None, periodicBoxVectors=None):
         """Write out a model to the DCD file.
 
-        The periodic box can be specified either by the unit cell dimensions (for a rectangular box), or the full set of box
-        vectors (for an arbitrary triclinic box).  If neither is specified, the box vectors specified in the Topology will be
-        used.  Regardless of the value specified, no dimensions will be written if the Topology does not represent a periodic system.
-
-        Parameters:
-         - positions (list) The list of atomic positions to write
-         - unitCellDimensions (Vec3=None) The dimensions of the crystallographic unit cell.
-         - periodicBoxVectors (tuple of Vec3=None) The vectors defining the periodic box.
+        The periodic box can be specified either by the unit cell dimensions
+        (for a rectangular box), or the full set of box vectors (for an
+        arbitrary triclinic box).  If neither is specified, the box vectors
+        specified in the Topology will be used. Regardless of the value
+        specified, no dimensions will be written if the Topology does not
+        represent a periodic system.
+
+        Parameters
+        ----------
+        positions : list
+            The list of atomic positions to write
+        unitCellDimensions : Vec3=None
+            The dimensions of the crystallographic unit cell.
+        periodicBoxVectors : tuple of Vec3=None
+            The vectors defining the periodic box.
         """
         if len(list(self._topology.atoms())) != len(positions):
             raise ValueError('The number of positions must match the number of atoms')

wrappers/python/simtk/openmm/app/dcdreporter.py

@@ -45,9 +45,12 @@ class DCDReporter(object):
     def __init__(self, file, reportInterval):
         """Create a DCDReporter.
 
-        Parameters:
-         - file (string) The file to write to
-         - reportInterval (int) The interval (in time steps) at which to write frames
+        Parameters
+        ----------
+        file : string
+            The file to write to
+        reportInterval : int
+            The interval (in time steps) at which to write frames
         """
         self._reportInterval = reportInterval
         self._out = open(file, 'wb')
@@ -56,11 +59,18 @@ class DCDReporter(object):
     def describeNextReport(self, simulation):
         """Get information about the next report this object will generate.
 
-        Parameters:
-         - simulation (Simulation) The Simulation to generate a report for
-        Returns: A five element tuple.  The first element is the number of steps until the
-        next report.  The remaining elements specify whether that report will require
-        positions, velocities, forces, and energies respectively.
+        Parameters
+        ----------
+        simulation : Simulation
+            The Simulation to generate a report for
+
+        Returns
+        -------
+        tuple
+            A five element tuple. The first element is the number of steps
+            until the next report. The remaining elements specify whether
+            that report will require positions, velocities, forces, and
+            energies respectively.
         """
         steps = self._reportInterval - simulation.currentStep%self._reportInterval
         return (steps, True, False, False, False)
@@ -68,10 +78,14 @@ class DCDReporter(object):
     def report(self, simulation, state):
         """Generate a report.
 
-        Parameters:
-         - simulation (Simulation) The Simulation to generate a report for
-         - state (State) The current state of the simulation
+        Parameters
+        ----------
+        simulation : Simulation
+            The Simulation to generate a report for
+        state : State
+            The current state of the simulation
         """
+
         if self._dcd is None:
             self._dcd = DCDFile(self._out, simulation.topology, simulation.integrator.getStepSize(), 0, self._reportInterval)
         a,b,c = state.getPeriodicBoxVectors()

wrappers/python/simtk/openmm/app/desmonddmsfile.py

@@ -46,10 +46,11 @@ class DesmondDMSFile(object):
     def __init__(self, file):
         """Load a DMS file
 
-        Parameters:
-         - file (string) the name of the file to load
+        Parameters
+        ----------
+        file : string
+            the name of the file to load
         """
-
         # sqlite3 is included in the standard lib, but at python
         # compile time, you can disable support (I think), so it's
         # not *guarenteed* to be available. Doing the import here
@@ -157,16 +158,24 @@ class DesmondDMSFile(object):
 
     def createSystem(self, nonbondedMethod=ff.NoCutoff, nonbondedCutoff=1.0*nanometer,
                      ewaldErrorTolerance=0.0005, removeCMMotion=True, hydrogenMass=None):
-        """Construct an OpenMM System representing the topology described by this dms file
+        """Construct an OpenMM System representing the topology described by this
+        DMS file
 
-        Parameters:
-         - nonbondedMethod (object=NoCutoff) The method to use for nonbonded interactions.  Allowed values are
+        Parameters
+        ----------
+        nonbondedMethod : object=NoCutoff
+            The method to use for nonbonded interactions.  Allowed values are
             NoCutoff, CutoffNonPeriodic, CutoffPeriodic, Ewald, or PME.
-         - nonbondedCutoff (distance=1*nanometer) The cutoff distance to use for nonbonded interactions
-         - ewaldErrorTolerance (float=0.0005) The error tolerance to use if nonbondedMethod is Ewald or PME.
-         - removeCMMotion (boolean=True) If true, a CMMotionRemover will be added to the System
-         - hydrogenMass (mass=None) The mass to use for hydrogen atoms bound to heavy atoms.  Any mass added to a hydrogen is
-           subtracted from the heavy atom to keep their total mass the same.
+        nonbondedCutoff : distance=1*nanometer
+            The cutoff distance to use for nonbonded interactions
+        ewaldErrorTolerance : float=0.0005
+            The error tolerance to use if nonbondedMethod is Ewald or PME.
+        removeCMMotion : boolean=True
+            If true, a CMMotionRemover will be added to the System
+        hydrogenMass : mass=None
+            The mass to use for hydrogen atoms bound to heavy atoms.  Any mass
+            added to a hydrogen is subtracted from the heavy atom to keep their
+            total mass the same.
         """
         self._checkForUnsupportedTerms()
         sys = mm.System()

wrappers/python/simtk/openmm/app/element.py

@@ -58,11 +58,16 @@ class Element(object):
     def __init__(self, number, name, symbol, mass):
         """Create a new element
 
-        Parameters:
-        number (int) The atomic number of the element
-        name (string) The name of the element
-        symbol (string) The chemical symbol of the element
-        mass (float) The atomic mass of the element
+        Parameters
+        ----------
+        number : int
+            The atomic number of the element
+        name : string
+            The name of the element
+        symbol : string
+            The chemical symbol of the element
+        mass : float
+            The atomic mass of the element
         """
         ## The atomic number of the element
         self._atomic_number = number
@@ -115,7 +120,7 @@ class Element(object):
 
         Returns
         -------
-        element : Element
+        Element
             The element whose atomic mass is closest to the input mass
         """
         # Assume masses are in daltons if they are not units

wrappers/python/simtk/openmm/app/forcefield.py

@@ -104,8 +104,10 @@ class ForceField(object):
     def __init__(self, *files):
         """Load one or more XML files and create a ForceField object based on them.
 
-        Parameters:
-         - files (list) A list of XML files defining the force field.  Each entry may
+        Parameters
+        ----------
+        files : list
+            A list of XML files defining the force field.  Each entry may
             be an absolute file path, a path relative to the current working
             directory, a path relative to this module's data subdirectory
             (for built in force fields), or an open file-like object with a
@@ -123,12 +125,14 @@ class ForceField(object):
     def loadFile(self, file):
         """Load an XML file and add the definitions from it to this FieldField.
 
-        Parameters:
-         - file (string or file) An XML file containing force field definitions.  It may
-           be either an absolute file path, a path relative to the current working
-           directory, a path relative to this module's data subdirectory
-           (for built in force fields), or an open file-like object with a
-           read() method from which the forcefield XML data can be loaded.
+        Parameters
+        ----------
+        file : string or file
+            An XML file containing force field definitions.  It may be either an
+            absolute file path, a path relative to the current working
+            directory, a path relative to this module's data subdirectory (for
+            built in force fields), or an open file-like object with a read()
+            method from which the forcefield XML data can be loaded.
         """
         try:
             # this handles either filenames or open file-like objects
@@ -270,6 +274,17 @@ class ForceField(object):
             self.impropers = []
             self.atomBonds = []
             self.isAngleConstrained = []
+            self.constraints = {}
+
+        def addConstraint(self, system, atom1, atom2, distance):
+            """Add a constraint to the system, avoiding duplicate constraints."""
+            key = (min(atom1, atom2), max(atom1, atom2))
+            if key in self.constraints:
+                if self.constraints(key) != distance:
+                    raise ValueError('Two constraints were specified between atoms %d and %d with different distances' % (atom1, atom2))
+            else:
+                self.constraints[key] = distance
+                system.addConstraint(atom1, atom2, distance)
 
     class _TemplateData:
         """Inner class used to encapsulate data about a residue template definition."""
@@ -406,20 +421,36 @@ class ForceField(object):
                      constraints=None, rigidWater=True, removeCMMotion=True, hydrogenMass=None, **args):
         """Construct an OpenMM System representing a Topology with this force field.
 
-        Parameters:
-         - topology (Topology) The Topology for which to create a System
-         - nonbondedMethod (object=NoCutoff) The method to use for nonbonded interactions.  Allowed values are
+        Parameters
+        ----------
+        topology : Topology
+            The Topology for which to create a System
+        nonbondedMethod : object=NoCutoff
+            The method to use for nonbonded interactions.  Allowed values are
             NoCutoff, CutoffNonPeriodic, CutoffPeriodic, Ewald, or PME.
-         - nonbondedCutoff (distance=1*nanometer) The cutoff distance to use for nonbonded interactions
-         - constraints (object=None) Specifies which bonds and angles should be implemented with constraints.
+        nonbondedCutoff : distance=1*nanometer
+            The cutoff distance to use for nonbonded interactions
+        constraints : object=None
+            Specifies which bonds and angles should be implemented with constraints.
             Allowed values are None, HBonds, AllBonds, or HAngles.
-         - rigidWater (boolean=True) If true, water molecules will be fully rigid regardless of the value passed for the constraints argument
-         - removeCMMotion (boolean=True) If true, a CMMotionRemover will be added to the System
-         - hydrogenMass (mass=None) The mass to use for hydrogen atoms bound to heavy atoms.  Any mass added to a hydrogen is
-           subtracted from the heavy atom to keep their total mass the same.
-         - args Arbitrary additional keyword arguments may also be specified.  This allows extra parameters to be specified that are specific to
+        rigidWater : boolean=True
+            If true, water molecules will be fully rigid regardless of the value
+            passed for the constraints argument
+        removeCMMotion : boolean=True
+            If true, a CMMotionRemover will be added to the System
+        hydrogenMass : mass=None
+            The mass to use for hydrogen atoms bound to heavy atoms.  Any mass
+            added to a hydrogen is subtracted from the heavy atom to keep
+            their total mass the same.
+        args
+             Arbitrary additional keyword arguments may also be specified.
+             This allows extra parameters to be specified that are specific to
              particular force fields.
-        Returns: the newly created System
+
+        Returns
+        -------
+        system
+            the newly created System
         """
         data = ForceField._SystemData()
         data.atoms = list(topology.atoms())
@@ -647,12 +678,20 @@ def _createResidueSignature(elements):
 def _matchResidue(res, template, bondedToAtom):
     """Determine whether a residue matches a template and return a list of corresponding atoms.
 
-    Parameters:
-     - res (Residue) The residue to check
-     - template (_TemplateData) The template to compare it to
-     - bondedToAtom (list) Enumerates which other atoms each atom is bonded to
-    Returns: a list specifying which atom of the template each atom of the residue corresponds to,
-    or None if it does not match the template
+    Parameters
+    ----------
+    res : Residue
+        The residue to check
+    template : _TemplateData
+        The template to compare it to
+    bondedToAtom : list
+        Enumerates which other atoms each atom is bonded to
+
+    Returns
+    -------
+    list
+        a list specifying which atom of the template each atom of the residue
+        corresponds to, or None if it does not match the template
     """
     atoms = list(res.atoms())
     if len(atoms) != len(template.atoms):
@@ -829,7 +868,7 @@ class HarmonicBondGenerator:
                 if (type1 in types1 and type2 in types2) or (type1 in types2 and type2 in types1):
                     bond.length = self.length[i]
                     if bond.isConstrained:
-                        sys.addConstraint(bond.atom1, bond.atom2, self.length[i])
+                        data.addConstraint(sys, bond.atom1, bond.atom2, self.length[i])
                     elif self.k[i] != 0:
                         force.addBond(bond.atom1, bond.atom2, self.length[i], self.k[i])
                     break
@@ -902,7 +941,7 @@ class HarmonicAngleGenerator:
                             l2 = data.bonds[bond2].length
                             if l1 is not None and l2 is not None:
                                 length = sqrt(l1*l1 + l2*l2 - 2*l1*l2*cos(self.angle[i]))
-                                sys.addConstraint(angle[0], angle[2], length)
+                                data.addConstraint(sys, angle[0], angle[2], length)
                     elif self.k[i] != 0:
                         force.addAngle(angle[0], angle[1], angle[2], self.angle[i], self.k[i])
                     break
@@ -1990,7 +2029,7 @@ class AmoebaBondGenerator:
                 if (type1 in types1 and type2 in types2) or (type1 in types2 and type2 in types1):
                     bond.length = self.length[i]
                     if bond.isConstrained:
-                        sys.addConstraint(bond.atom1, bond.atom2, self.length[i])
+                        data.addConstraint(sys, bond.atom1, bond.atom2, self.length[i])
                     elif self.k[i] != 0:
                         force.addBond(bond.atom1, bond.atom2, self.length[i], self.k[i])
                     break
@@ -2022,7 +2061,7 @@ def addAngleConstraint(angle, idealAngle, data, sys):
             l2 = data.bonds[bond2].length
             if l1 is not None and l2 is not None:
                 length = sqrt(l1*l1 + l2*l2 - 2*l1*l2*cos(idealAngle))
-                sys.addConstraint(angle[0], angle[2], length)
+                data.addConstraint(sys, angle[0], angle[2], length)
                 return
 
 #=============================================================================================

wrappers/python/simtk/openmm/app/gromacsgrofile.py

@@ -114,10 +114,11 @@ class GromacsGroFile(object):
 
         The atom positions can be retrieved by calling getPositions().
 
-        Parameters:
-         - file (string) the name of the file to load
+        Parameters
+        ----------
+        file : string
+            the name of the file to load
         """
-
         xyzs     = []
         elements = [] # The element, most useful for quantum chemistry calculations
         atomname = [] # The atom name, for instance 'HW1'
@@ -183,9 +184,13 @@ class GromacsGroFile(object):
     def getPositions(self, asNumpy=False, frame=0):
         """Get the atomic positions.
 
-        Parameters:
-         - asNumpy (boolean=False) if true, the values are returned as a numpy array instead of a list of Vec3s
-         - frame (int=0) the index of the frame for which to get positions
+        Parameters
+        ----------
+        asNumpy : boolean=False
+            if true, the values are returned as a numpy array instead of a list
+            of Vec3s
+        frame : int=0
+            the index of the frame for which to get positions
         """
         if asNumpy:
             if self._numpyPositions is None:
@@ -198,16 +203,20 @@ class GromacsGroFile(object):
     def getPeriodicBoxVectors(self, frame=0):
         """Get the vectors defining the periodic box.
 
-        Parameters:
-         - frame (int=0) the index of the frame for which to get the box vectors
+        Parameters
+        ----------
+        frame : int=0
+            the index of the frame for which to get the box vectors
         """
         return self._periodicBoxVectors[frame]
 
     def getUnitCellDimensions(self, frame=0):
         """Get the dimensions of the crystallographic unit cell.
 
-        Parameters:
-         - frame (int=0) the index of the frame for which to get the unit cell dimensions
+        Parameters
+        ----------
+        frame : int=0
+            the index of the frame for which to get the unit cell dimensions
         """
         xsize = self._periodicBoxVectors[frame][0][0].value_in_unit(nanometers)
         ysize = self._periodicBoxVectors[frame][1][1].value_in_unit(nanometers)

wrappers/python/simtk/openmm/app/gromacstopfile.py

@@ -433,16 +433,22 @@ class GromacsTopFile(object):
     def __init__(self, file, periodicBoxVectors=None, unitCellDimensions=None, includeDir=None, defines=None):
         """Load a top file.
 
-        Parameters:
-         - file (string) the name of the file to load
-         - periodicBoxVectors (tuple of Vec3=None) the vectors defining the periodic box
-         - unitCellDimensions (Vec3=None) the dimensions of the crystallographic unit cell.  For
+        Parameters
+        ----------
+        file : str
+            the name of the file to load
+        periodicBoxVectors : tuple of Vec3=None
+            the vectors defining the periodic box
+        unitCellDimensions : Vec3=None
+            the dimensions of the crystallographic unit cell.  For
             non-rectangular unit cells, specify periodicBoxVectors instead.
-         - includeDir (string=None) A directory in which to look for other files
-           included from the top file. If not specified, we will attempt to locate a gromacs
-           installation on your system. When gromacs is installed in /usr/local, this will resolve
-           to  /usr/local/gromacs/share/gromacs/top
-         - defines (dict={}) preprocessor definitions that should be predefined when parsing the file
+        includeDir : string=None
+            A directory in which to look for other files included from the
+            top file. If not specified, we will attempt to locate a gromacs
+            installation on your system. When gromacs is installed in
+            /usr/local, this will resolve to /usr/local/gromacs/share/gromacs/top
+        defines : dict={}
+            preprocessor definitions that should be predefined when parsing the file
          """
         if includeDir is None:
             includeDir = _defaultGromacsIncludeDir()
@@ -539,23 +545,43 @@ class GromacsTopFile(object):
 
     def createSystem(self, nonbondedMethod=ff.NoCutoff, nonbondedCutoff=1.0*unit.nanometer,
                      constraints=None, rigidWater=True, implicitSolvent=None, soluteDielectric=1.0, solventDielectric=78.5, ewaldErrorTolerance=0.0005, removeCMMotion=True, hydrogenMass=None):
-        """Construct an OpenMM System representing the topology described by this prmtop file.
+        """Construct an OpenMM System representing the topology described by this
+        prmtop file.
 
-        Parameters:
-         - nonbondedMethod (object=NoCutoff) The method to use for nonbonded interactions.  Allowed values are
+        Parameters
+        ----------
+        nonbondedMethod : object=NoCutoff
+            The method to use for nonbonded interactions.  Allowed values are
             NoCutoff, CutoffNonPeriodic, CutoffPeriodic, Ewald, or PME.
-         - nonbondedCutoff (distance=1*nanometer) The cutoff distance to use for nonbonded interactions
-         - constraints (object=None) Specifies which bonds and angles should be implemented with constraints.
-           Allowed values are None, HBonds, AllBonds, or HAngles.
-         - rigidWater (boolean=True) If true, water molecules will be fully rigid regardless of the value passed for the constraints argument
-         - implicitSolvent (object=None) If not None, the implicit solvent model to use.  The only allowed value is OBC2.
-         - soluteDielectric (float=1.0) The solute dielectric constant to use in the implicit solvent model.
-         - solventDielectric (float=78.5) The solvent dielectric constant to use in the implicit solvent model.
-         - ewaldErrorTolerance (float=0.0005) The error tolerance to use if nonbondedMethod is Ewald or PME.
-         - removeCMMotion (boolean=True) If true, a CMMotionRemover will be added to the System
-         - hydrogenMass (mass=None) The mass to use for hydrogen atoms bound to heavy atoms.  Any mass added to a hydrogen is
-           subtracted from the heavy atom to keep their total mass the same.
-        Returns: the newly created System
+        nonbondedCutoff : distance=1*nanometer
+            The cutoff distance to use for nonbonded interactions
+        constraints : object=None
+            Specifies which bonds and angles should be implemented with
+            constraints. Allowed values are None, HBonds, AllBonds, or HAngles.
+        rigidWater : boolean=True
+            If true, water molecules will be fully rigid regardless of the value
+            passed for the constraints argument
+        implicitSolvent : object=None
+            If not None, the implicit solvent model to use.  The only allowed
+            value is OBC2.
+        soluteDielectric : float=1.0
+            The solute dielectric constant to use in the implicit solvent model.
+        solventDielectric : float=78.5
+            The solvent dielectric constant to use in the implicit solvent
+            model.
+        ewaldErrorTolerance : float=0.0005
+            The error tolerance to use if nonbondedMethod is Ewald or PME.
+        removeCMMotion : boolean=True
+            If true, a CMMotionRemover will be added to the System
+        hydrogenMass : mass=None
+            The mass to use for hydrogen atoms bound to heavy atoms.  Any mass
+            added to a hydrogen is subtracted from the heavy atom to keep their
+            total mass the same.
+
+        Returns
+        -------
+        System
+             the newly created System
         """
         # Create the System.
 

wrappers/python/simtk/openmm/app/internal/charmm/topologyobjects.py

@@ -76,22 +76,33 @@ class AtomType(object):
     new atom types with the "add" constructor to make sure the registry is
     filled with only unique types
 
-    Parameters and Attributes:
-        - name (str) : The name of the atom type
-        - number (int) : The integer index of the atom type
-        - mass (float) : The mass of the atom type
-        - atomic_number (int) : The atomic number of the element of the atom
-                                type
-    Attributes:
-        - name (str) : The name of the atom type
-        - number (int) : The integer index of the atom type
-        - _member_number (int, private) : The order in which this atom type
-                was 'added' this is used to make sure that atom types added
-                last have priority in assignment in the generated hash tables
-        - nbfix (dict) : Dictionary that maps nbfix terms with other atom types.
-                         Dict entries are (rmin, epsilon) -- precombined values
-                         for that particular atom pair
-    Example:
+    Parameters
+    ----------
+    name : str
+        The name of the atom type
+    number : int
+        The integer index of the atom type
+    mass : float
+        The mass of the atom type
+    atomic_number : int
+        The atomic number of the element of the atom type
+
+    Attributes
+    ----------
+    name : str
+        The name of the atom type
+    number : int
+        The integer index of the atom type
+    _member_number : int, private)
+        The order in which this atom type was 'added' this is used to make
+        sure that atom types added last have priority in assignment in the
+        generated hash tables
+    nbfix : dict
+        Dictionary that maps nbfix terms with other atom types. Dict entries
+        are (rmin, epsilon) -- precombined values for that particular atom pair
+
+    Examples
+    --------
     >>> at = AtomType('HA', 1, 1.008, 1)
     >>> at.name, at.number
     ('HA', 1)
@@ -212,34 +223,59 @@ WildCard = WildCard() # Turn it into a singleton
 class Atom(object):
     """ An atom in a structure.
 
-    Parameters:
-        system (str) : Name of the system this atom belongs to
-        name (str): name of the atom
-        type (str or int) : Type of the atom
-        charge (float) : Partial atomic charge (elementary charge units)
-        mass (float) : Atomic mass (amu)
-        props (list) : Other properties from the PSF
-
-    Attributes:
-        - attype (str) : Name of the atom type
-        - system (str) : The system name associated with this atom
-        - name (str) : Name of the atom (str)
-        - charge (float) : Partial atomic charge
-        - mass (float) : Mass of the atom (amu)
-        - idx (int) : index of the atom in the system, starting from 0
-        - props (list) : List of extraneous properties parsed from a PSF
-        - type (AtomType) : If assigned, has additional properties like the
-             non-bonded LJ parameters. If None, it has not yet been assigned
-
-    Possible Attributes (SOA == Set of Atom instances)
-        - bond_partners (SOA) : List of all atoms I am bonded to
-        - angle_partners (SOA) : List of all atoms I am angled to
-        - dihedral_partners (SOA) : List of all atoms I am dihedraled to
-        - bonds (list of Bond's) : All bonds to which I belong
-        - angles (list of Angle's) : All angles to which I belong
-        - dihedrals (list of Dihedral's) : All dihedrals to which I belong
-        - impropers (list of Improper's) : All impropers to which I belong
-        - cmaps (list of Cmap's) : All correction maps to which I belong
+    Parameters
+    ----------
+    system : str
+        Name of the system this atom belongs to
+    name : str
+        name of the atom
+    type : str or int
+        Type of the atom
+    charge : float
+        Partial atomic charge (elementary charge units)
+    mass : float
+        Atomic mass (amu)
+    props : list
+        Other properties from the PSF
+
+    Attributes
+    ----------
+    attype : str
+        Name of the atom type
+    system : str
+        The system name associated with this atom
+    name : str
+        Name of the atom (str)
+    charge : float
+        Partial atomic charge
+    mass : float
+        Mass of the atom (amu)
+    idx : int
+        index of the atom in the system, starting from 0
+    props : list
+        List of extraneous properties parsed from a PSF
+    type : AtomType
+        If assigned, has additional properties like the non-bonded LJ
+        parameters. If None, it has not yet been assigned
+
+    Possible Attributes
+    -------------------
+    bond_partners : set of Atoms
+        List of all atoms I am bonded to
+    angle_partners set of Atoms
+        List of all atoms I am angled to
+    dihedral_partners : et of Atoms
+        List of all atoms I am dihedraled to
+    bonds : list of Bonds
+        All bonds to which I belong
+    angles : list of Angles
+        All angles to which I belong
+    dihedrals : list of Dihedrals
+        All dihedrals to which I belong
+    impropers : list of Impropers
+        All impropers to which I belong
+    cmaps : list of Cmaps
+        All correction maps to which I belong
     """
     def __init__(self, system, name, attype, charge, mass, props=None):
         self.name = name
@@ -450,22 +486,33 @@ class ResidueList(list):
 
     def add_atom(self, system, resnum, resname, name,
                  attype, charge, mass, inscode, props=None):
-        """
-        Adds an atom to the list of residues. If the residue is not the same as
-        the last residue that was created, a new Residue is created and added
-        to this list
-
-        Parameters:
-            - system (str) : The system this atom belongs to
-            - resnum (int) : Residue number
-            - resname (str) : Name of the residue
-            - name (str) : Name of the atom
-            - attype (int or str) : Type of the atom
-            - charge (float) : Partial atomic charge of the atom
-            - mass (float) : Mass (amu) of the atom
-            - inscode (str) : Insertion code, if it is specified
-
-        Returns:
+        """Adds an atom to the list of residues. If the residue is not the same as
+        the last residue that was created, a new Residue is created and added to
+        this list
+
+        Parameters
+        ----------
+        system : str
+            The system this atom belongs to
+        resnum : int
+            Residue number
+        resname : str
+            Name of the residue
+        name : str
+            Name of the atom
+        attype : int or str
+            Type of the atom
+        charge : float
+            Partial atomic charge of the atom
+        mass : float
+            Mass (amu) of the atom
+        inscode : str
+            Insertion code, if it is specified
+        props : list
+            Other properties from the PSF
+
+        Returns
+        -------
             The Atom instance created and added to the list of residues
         """
         lr = self._last_residue
@@ -491,13 +538,16 @@ class ResidueList(list):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class Bond(object):
-    """
-    A bond object that links 2 atoms
-
-    Parameters:
-        - atom1 (Atom) : First atom included in the bond
-        - atom2 (Atom) : Second atom included in the bond
-        - bond_type (BondType) : Type for the bond (None if unknown)
+    """A bond object that links 2 atoms
+
+    Parameters
+    ----------
+    atom1 : Atom
+        First atom included in the bond
+    atom2 : Atom
+        Second atom included in the bond
+    bond_type : BondType
+        Type for the bond (None if unknown)
     """
     def __init__(self, atom1, atom2, bond_type=None):
         self.atom1 = atom1
@@ -519,14 +569,18 @@ class Bond(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class Angle(object):
-    """
-    An angle object that links 3 atoms
-
-    Parameters:
-        - atom1 (Atom) : First atom included in the angle
-        - atom2 (Atom) : Central atom in the valence angle
-        - atom3 (Atom) : Third atom in the valence angle
-        - angle_type (AngleType) : Type for the angle (None if unknown)
+    """An angle object that links 3 atoms
+
+    Parameters
+    ----------
+    atom1 : Atom
+        First atom included in the angle
+    atom2 : Atom
+        Central atom in the valence angle
+    atom3 : Atom
+        Third atom in the valence angle
+    angle_type : AngleType
+        Type for the angle (None if unknown)
     """
     def __init__(self, atom1, atom2, atom3, angle_type=None):
         self.atom1 = atom1
@@ -554,15 +608,17 @@ class Angle(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class UreyBradley(object):
-    """
-    A harmonic restraint between two atoms separated by 2 valence bonds (i.e.,
-    involved in a valence angle with each other
-
-    Parameters:
-        - atom1 (Atom) : The first atom included in the Urey-Bradley term
-        - atom2 (Atom) : The second atom included in the Urey-Bradley term
-        - ub_type (UreyBradleyType) : The type for the Urey-Bradley term (None
-                                      if unknown)
+    """A harmonic restraint between two atoms separated by 2 valence bonds
+    (i.e., involved in a valence angle with each other
+
+    Parameters
+    ----------
+    atom1 : Atom
+        The first atom included in the Urey-Bradley term
+    atom2 : Atom
+        The second atom included in the Urey-Bradley term
+    ub_type : UreyBradleyType
+        The type for the Urey-Bradley term (None if unknown)
     """
     def __init__(self, atom1, atom2, ub_type=None):
         self.atom1 = atom1
@@ -599,15 +655,20 @@ class UreyBradley(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class Dihedral(object):
-    """
-    A torsion angle object that links 4 atoms
-
-    Parameters:
-        - atom1 (Atom) : First atom included in the torsion
-        - atom2 (Atom) : Second atom included in the torsion
-        - atom3 (Atom) : Third atom included in the torsion
-        - atom4 (Atom) : Fourth atom included in the torsion
-        - dihedral_type (DihedralType) : Type for the torsion (None if unknown)
+    """A torsion angle object that links 4 atoms
+
+    Parameters
+    ----------
+    atom1 : Atom
+        First atom included in the torsion
+    atom2 : Atom
+        Second atom included in the torsion
+    atom3 : Atom
+        Third atom included in the torsion
+    atom4 : Atom
+        Fourth atom included in the torsion
+    dihedral_type : DihedralType
+        Type for the torsion (None if unknown)
     """
     def __init__(self, atom1, atom2, atom3, atom4, dihedral_type=None):
         self.atom1 = atom1
@@ -648,15 +709,20 @@ class Dihedral(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class Improper(object):
-    """
-    An improper torsion object. The third atom is bonded to each other atom
-
-    Parameters:
-        - atom1 (Atom) : First atom included in the torsion
-        - atom2 (Atom) : Second atom included in the torsion
-        - atom3 (Atom) : Third atom included in the torsion
-        - atom4 (Atom) : Fourth atom included in the torsion
-        - improper_type (ImproperType) : Type for the improper (None if unknown)
+    """An improper torsion object. The third atom is bonded to each other atom
+
+    Parameters
+    ----------
+    atom1 : Atom
+        First atom included in the torsion
+    atom2 : Atom
+        Second atom included in the torsion
+    atom3 : Atom
+        Third atom included in the torsion
+    atom4 : Atom
+        Fourth atom included in the torsion
+    improper_type : ImproperType
+        Type for the improper (None if unknown)
     """
     def __init__(self, atom1, atom2, atom3, atom4, improper_type=None):
         self.atom1 = atom1
@@ -703,12 +769,14 @@ class Improper(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class AcceptorDonor(object):
-    """
-    Just a holder for donors and acceptors in CHARMM speak
-    
-    Parameters:
-        - atom1 (Atom) : First atom in the donor/acceptor group
-        - atom2 (Atom) : Second atom in the donor/acceptor group
+    """Just a holder for donors and acceptors in CHARMM speak
+
+    Parameters
+    ----------
+    atom1 : Atom
+        First atom in the donor/acceptor group
+    atom2 : Atom
+        Second atom in the donor/acceptor group
     """
     def __init__(self, atom1, atom2):
         self.atom1 = atom1
@@ -724,13 +792,16 @@ class AcceptorDonor(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class Group(object):
-    """
-    An 'interacting' group defined by the PSF.
+    """An 'interacting' group defined by the PSF.
 
-    Parameters:
-        - bs (int) : ??
-        - type (int) : The group type
-        - move (int) : If the group moves ??
+    Parameters
+    ----------
+    bs : int
+        ??
+    type : int
+        The group type
+    move : int
+        If the group moves ??
 
     Disclaimer: I really don't know what these numbers mean. I'm speculating
     based on the source code of 'chamber', and this section is simply ignored
@@ -749,36 +820,61 @@ class Cmap(object):
     consecutive correction maps). "Consecutive torsions" (i.e., those definable
     by 5 atoms) will only be recognized if the two torsions have the same order
 
-    Parameters:
-        - atom1 (Atom) : 1st atom of first dihedral
-        - atom2 (Atom) : 2nd atom of first dihedral
-        - atom3 (Atom) : 3rd atom of first dihedral
-        - atom4 (Atom) : 4th atom of first dihedral
-        - atom5 (Atom) : 1st atom of second dihedral
-        - atom6 (Atom) : 2nd atom of second dihedral
-        - atom7 (Atom) : 3rd atom of second dihedral
-        - atom8 (Atom) : 4th atom of second dihedral
-        - cmap_type (CmapType) : Cmap type for this cmap (None if unknown)
-
-    Attributes:
-        - consecutive (bool) : Are the dihedrals consecutive?
+    Parameters
+    ----------
+    atom1 : Atom
+        1st atom of first dihedral
+    atom2 : Atom
+        2nd atom of first dihedral
+    atom3 : Atom
+        3rd atom of first dihedral
+    atom4 : Atom
+        4th atom of first dihedral
+    atom5 : Atom
+        1st atom of second dihedral
+    atom6 : Atom
+        2nd atom of second dihedral
+    atom7 : Atom
+        3rd atom of second dihedral
+    atom8 : Atom
+        4th atom of second dihedral
+    cmap_type : CmapType
+        Cmap type for this cmap (None if unknown)
+
+    Attributes
+    ----------
+    consecutive : bool
+        Are the dihedrals consecutive?
 
     if consecutive:
-        - atom1 (Atom) : 1st atom of 1st dihedral
-        - atom2 (Atom) : 2nd atom of 1st dihedral && 1st atom of 2nd dihedral
-        - atom3 (Atom) : 3rd atom of 1st dihedral && 2nd atom of 2nd dihedral
-        - atom4 (Atom) : 4th atom of 1st dihedral && 3rd atom of 2nd dihedral
-        - atom5 (Atom) :                             4th atom of 2nd dihedral
+        atom1 : Atom
+            1st atom of 1st dihedral
+        atom2 L Atom
+            2nd atom of 1st dihedral && 1st atom of 2nd dihedral
+        atom3 : Atom
+            3rd atom of 1st dihedral && 2nd atom of 2nd dihedral
+        atom4 : Atom
+            4th atom of 1st dihedral && 3rd atom of 2nd dihedral
+        atom5 : Atom
+            4th atom of 2nd dihedral
 
      if not consecutive:
-        - atom1 (Atom) : 1st atom of first dihedral
-        - atom2 (Atom) : 2nd atom of first dihedral
-        - atom3 (Atom) : 3rd atom of first dihedral
-        - atom4 (Atom) : 4th atom of first dihedral
-        - atom5 (Atom) : 1st atom of second dihedral
-        - atom6 (Atom) : 2nd atom of second dihedral
-        - atom7 (Atom) : 3rd atom of second dihedral
-        - atom8 (Atom) : 4th atom of second dihedral
+         atom1 : Atom
+            1st atom of first dihedral
+         atom2 : Atom
+            2nd atom of first dihedral
+         atom3 : Atom
+            3rd atom of first dihedral
+         atom4 : Atom
+            4th atom of first dihedral
+         atom5 : Atom
+            1st atom of second dihedral
+         atom6 : Atom
+            2nd atom of second dihedral
+         atom7 : Atom
+            3rd atom of second dihedral
+         atom8 : Atom
+            4th atom of second dihedral
     """
     def __init__(self, atom1, atom2, atom3, atom4, atom5, atom6, atom7,
                  atom8, cmap_type=None):
@@ -866,9 +962,12 @@ class BondType(object):
     A bond type with an equilibrium length (Angstroms) and force constant
     (kcal/mol/Angstrom^2)
 
-    Parameters:
-        - k (float) : Force constant (kcal/mol/A^2)
-        - req (float) : Equilibrium distance
+    Parameters
+    ----------
+    k : float
+        : Force constant (kcal/mol/A^2)
+    req : float
+        : Equilibrium distance
     """
     def __init__(self, k, req):
         self.k = k
@@ -880,13 +979,15 @@ class BondType(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class AngleType(object):
-    """
-    An angle type with an equilibrium angle (degrees) and force constant
+    """An angle type with an equilibrium angle (degrees) and force constant
     (kcal/mol/radians^2)
 
-    Parameters:
-        - k (float) : Force constant (kcal/mol/radians^2)
-        - theteq (float) : Equilibrium angle value (degrees)
+    Parameters
+    ----------
+    k : float
+        Force constant (kcal/mol/radians^2)
+    theteq : float
+        Equilibrium angle value (degrees)
     """
     def __init__(self, k, theteq):
         self.k = k
@@ -911,14 +1012,17 @@ NoUreyBradley = UreyBradleyType(None, None)
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class DihedralType(object):
-    """
-    A torsion angle type with a force constant (kcal/mol), periodicity (int),
-    and phase (degrees)
-
-    Parameters:
-        - phi_k (float) : Force constant (kcal/mol)
-        - per (int) : Periodicity
-        - phase (float): Phase of the torsion
+    """A torsion angle type with a force constant (kcal/mol), periodicity
+    (int), and phase (degrees)
+
+    Parameters
+    ----------
+    phi_k : float
+        Force constant (kcal/mol)
+    per : int
+        Periodicity
+    phase : float
+        Phase of the torsion
     """
     def __init__(self, phi_k, per, phase):
         self.phi_k = float(phi_k)
@@ -936,13 +1040,15 @@ class DihedralType(object):
 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 class ImproperType(object):
-    """
-    An improper torsion angle type with a force constant (kcal/mol) and
+    """An improper torsion angle type with a force constant (kcal/mol) and
     equilibrium angle (degrees)
 
-    Parameters:
-        - k (float) : Force constant (kcal/mol)
-        - phieq (int) : Equilibrium angle (degrees)
+    Parameters
+    ----------
+    k : float
+        : Force constant (kcal/mol)
+    phieq : int
+        : Equilibrium angle (degrees)
     """
     def __init__(self, k, phieq):
         self.k = k
@@ -960,10 +1066,13 @@ class CmapType(object):
     """
     Contains a correction map interpolation grid
 
-    Parameters:
-        - resolution (int) : Number of interpolation points for each dihedral
-        - grid (list of floats) : resolution x resolution list of energy values
-                (kcal/mol) for the angles with the 2nd angle changing fastest.
+    Parameters
+    ----------
+    resolution : int
+        Number of interpolation points for each dihedral
+    grid : list of floats
+        resolution x resolution list of energy values (kcal/mol) for the
+        angles with the 2nd angle changing fastest.
 
     The grid object is converted to a _CmapGrid instance which can be treated
     like a normal list, but also has the ability to quickly return a transpose

wrappers/python/simtk/openmm/app/internal/pdbstructure.py

@@ -123,15 +123,18 @@ class PdbStructure(object):
     """
 
 
-    def __init__(self, input_stream, load_all_models = False):
+    def __init__(self, input_stream, load_all_models=False):
         """Create a PDB model from a PDB file stream.
 
-        Parameters:
-         - self (PdbStructure) The new object that is created.
-         - input_stream (stream) An input file stream, probably created with
-             open().
-         - load_all_models (bool) Whether to load every model of an NMR
-             structure or trajectory, or just load the first model, to save memory.
+        Parameters
+        ----------
+        self : PdbStructure
+            The new object that is created.
+        input_stream : stream
+            An input file stream, probably created with open().
+        load_all_models : bool
+            Whether to load every model of an NMR structure or trajectory, or
+            just load the first model, to save memory.
         """
         # initialize models
         self.load_all_models = load_all_models
@@ -269,8 +272,11 @@ class PdbStructure(object):
         Iterate over atomic positions.
 
         Parameters
-         - use_all_models (bool=False) Get positions from all models or just the first one.
-         - include_alt_loc (bool=False) Get all positions for each atom, or just the first one.
+        ----------
+        use_all_models : bool=False
+            Get positions from all models or just the first one.
+        include_alt_loc : bool=False
+            Get all positions for each atom, or just the first one.
         """
         for model in self.iter_models(use_all_models):
             for loc in model.iter_positions(include_alt_loc):

wrappers/python/simtk/openmm/app/pdbfile.py

@@ -64,8 +64,10 @@ class PDBFile(object):
 
         The atom positions and Topology can be retrieved by calling getPositions() and getTopology().
 
-        Parameters:
-         - file (string) the name of the file to load
+        Parameters
+        ----------
+        file : string
+            the name of the file to load
         """
         top = Topology()
         ## The Topology read from the PDB file
@@ -176,9 +178,13 @@ class PDBFile(object):
     def getPositions(self, asNumpy=False, frame=0):
         """Get the atomic positions.
 
-        Parameters:
-         - asNumpy (boolean=False) if true, the values are returned as a numpy array instead of a list of Vec3s
-         - frame (int=0) the index of the frame for which to get positions
+        Parameters
+        ----------
+        asNumpy : boolean=False
+            if true, the values are returned as a numpy array instead of a list
+            of Vec3s
+        frame : int=0
+            the index of the frame for which to get positions
         """
         if asNumpy:
             if self._numpyPositions is None:
@@ -234,13 +240,19 @@ class PDBFile(object):
     def writeFile(topology, positions, file=sys.stdout, keepIds=False):
         """Write a PDB file containing a single model.
 
-        Parameters:
-         - topology (Topology) The Topology defining the model to write
-         - positions (list) The list of atomic positions to write
-         - file (file=stdout) A file to write to
-         - keepIds (bool=False) If True, keep the residue and chain IDs specified in the Topology rather than generating
-           new ones.  Warning: It is up to the caller to make sure these are valid IDs that satisfy the requirements of
-           the PDB format.  Otherwise, the output file will be invalid.
+        Parameters
+        ----------
+        topology : Topology
+            The Topology defining the model to write
+        positions : list
+            The list of atomic positions to write
+        file : file=stdout
+            A file to write to
+        keepIds : bool=False
+            If True, keep the residue and chain IDs specified in the Topology
+            rather than generating new ones.  Warning: It is up to the caller to
+            make sure these are valid IDs that satisfy the requirements of the
+            PDB format.  Otherwise, the output file will be invalid.
         """
         PDBFile.writeHeader(topology, file)
         PDBFile.writeModel(topology, positions, file, keepIds=keepIds)
@@ -250,9 +262,12 @@ class PDBFile(object):
     def writeHeader(topology, file=sys.stdout):
         """Write out the header for a PDB file.
 
-        Parameters:
-         - topology (Topology) The Topology defining the molecular system being written
-         - file (file=stdout) A file to write the file to
+        Parameters
+        ----------
+        topology : Topology
+            The Topology defining the molecular system being written
+        file : file=stdout
+            A file to write the file to
         """
         print("REMARK   1 CREATED WITH OPENMM %s, %s" % (Platform.getOpenMMVersion(), str(date.today())), file=file)
         vectors = topology.getPeriodicBoxVectors()
@@ -266,15 +281,24 @@ class PDBFile(object):
     def writeModel(topology, positions, file=sys.stdout, modelIndex=None, keepIds=False):
         """Write out a model to a PDB file.
 
-        Parameters:
-         - topology (Topology) The Topology defining the model to write
-         - positions (list) The list of atomic positions to write
-         - file (file=stdout) A file to write the model to
-         - modelIndex (int=None) If not None, the model will be surrounded by MODEL/ENDMDL records with this index
-         - keepIds (bool=False) If True, keep the residue and chain IDs specified in the Topology rather than generating
-           new ones.  Warning: It is up to the caller to make sure these are valid IDs that satisfy the requirements of
-           the PDB format.  Otherwise, the output file will be invalid.
+        Parameters
+        ----------
+        topology : Topology
+            The Topology defining the model to write
+        positions : list
+            The list of atomic positions to write
+        file : file=stdout
+            A file to write the model to
+        modelIndex : int=None
+            If not None, the model will be surrounded by MODEL/ENDMDL records
+            with this index
+        keepIds : bool=False
+            If True, keep the residue and chain IDs specified in the Topology
+            rather than generating new ones.  Warning: It is up to the caller to
+            make sure these are valid IDs that satisfy the requirements of the
+            PDB format.  Otherwise, the output file will be invalid.
         """
+
         if len(list(topology.atoms())) != len(positions):
             raise ValueError('The number of positions must match the number of atoms')
         if is_quantity(positions):
@@ -331,9 +355,12 @@ class PDBFile(object):
     def writeFooter(topology, file=sys.stdout):
         """Write out the footer for a PDB file.
 
-        Parameters:
-         - topology (Topology) The Topology defining the molecular system being written
-         - file (file=stdout) A file to write the file to
+        Parameters
+        ----------
+        topology : Topology
+            The Topology defining the molecular system being written
+        file : file=stdout
+            A file to write the file to
         """
         # Identify bonds that should be listed as CONECT records.
 

wrappers/python/simtk/openmm/app/pdbreporter.py

@@ -44,9 +44,12 @@ class PDBReporter(object):
     def __init__(self, file, reportInterval):
         """Create a PDBReporter.
 
-        Parameters:
-         - file (string) The file to write to
-         - reportInterval (int) The interval (in time steps) at which to write frames
+        Parameters
+        ----------
+        file : string
+            The file to write to
+        reportInterval : int
+            The interval (in time steps) at which to write frames
         """
         self._reportInterval = reportInterval
         self._out = open(file, 'w')
@@ -56,11 +59,18 @@ class PDBReporter(object):
     def describeNextReport(self, simulation):
         """Get information about the next report this object will generate.
 
-        Parameters:
-         - simulation (Simulation) The Simulation to generate a report for
-        Returns: A five element tuple.  The first element is the number of steps until the
-        next report.  The remaining elements specify whether that report will require
-        positions, velocities, forces, and energies respectively.
+        Parameters
+        ----------
+        simulation : Simulation
+            The Simulation to generate a report for
+
+        Returns
+        -------
+        tuple
+            A five element tuple. The first element is the number of steps
+            until the next report. The remaining elements specify whether
+            that report will require positions, velocities, forces, and
+            energies respectively.
         """
         steps = self._reportInterval - simulation.currentStep%self._reportInterval
         return (steps, True, False, False, False)
@@ -68,9 +78,12 @@ class PDBReporter(object):
     def report(self, simulation, state):
         """Generate a report.
 
-        Parameters:
-         - simulation (Simulation) The Simulation to generate a report for
-         - state (State) The current state of the simulation
+        Parameters
+        ----------
+        simulation : Simulation
+            The Simulation to generate a report for
+        state : State
+            The current state of the simulation
         """
         if self._nextModel == 0:
             PDBFile.writeHeader(simulation.topology, self._out)
@@ -95,9 +108,12 @@ class PDBxReporter(PDBReporter):
     def report(self, simulation, state):
         """Generate a report.
 
-        Parameters:
-         - simulation (Simulation) The Simulation to generate a report for
-         - state (State) The current state of the simulation
+        Parameters
+        ----------
+        simulation : Simulation
+            The Simulation to generate a report for
+        state : State
+            The current state of the simulation
         """
         if self._nextModel == 0:
             PDBxFile.writeHeader(simulation.topology, self._out)