DuMMForceFieldSubsystem Class Reference
[Molecular Mechanics in Molmodel]

This is a concrete subsystem that provides basic molecular mechanics functionality for coarse-grained molecules built in the SimTK framework. More...

#include <DuMMForceFieldSubsystem.h>

Inheritance diagram for DuMMForceFieldSubsystem:
ForceSubsystem Subsystem Amber99ForceSubsystem

List of all members.

Public Types

enum  VdwMixingRule {
  WaldmanHagler = 1, HalgrenHHG = 2, Jorgensen = 3, LorentzBerthelot = 4,
  Kong = 5
}
 

These are the van der Waals mixing rules supported by DuMM.

More...

Public Member Functions

 DuMMForceFieldSubsystem ()
 DuMMForceFieldSubsystem (MolecularMechanicsSystem &)
Runtime methods

Methods in this group are used to obtain state-dependent information about this molecular system at run time.



const Vec3 & getAtomLocationInGround (const State &state, DuMM::AtomIndex atomIx)
 Obtain the current location of a particular atom in the Ground frame.
const Vec3 & getAtomVelocityInGround (const State &state, DuMM::AtomIndex atomIx)
 Obtain the current velocity of a particular atom in the Ground frame.
const Vec3 & getAtomBodyStationInGround (const State &state, DuMM::AtomIndex atomIx)
 Obtain the station vector of an atom measured from its body's origin, but re-expressed in the Ground frame.
Define particular molecules

Methods in this group are used to define the atoms and bonds in the particular set of molecules being simulated.



DuMM::AtomIndex addAtom (DuMM::ChargedAtomTypeIndex chargedAtomTypeIx)
 Add a new atom to the model.
DuMM::BondIndex addBond (DuMM::AtomIndex atom1Ix, DuMM::AtomIndex atom2Ix)
 Declare that there is a covalent bond between two atoms.
DuMM::AtomIndex getBondAtom (DuMM::BondIndex bond, int which) const
 For a given 1-2 bond, return the atoms which are connected by that bond.
int getNumAtoms () const
 How many atoms are currently in the model?
int getNumBonds () const
 How many 1-2 bonds are currently in the model?
Real getAtomMass (DuMM::AtomIndex atomIx) const
 Obtain the mass in Daltons (g/mol) of the atom indicated by the given AtomIndex.
int getAtomElement (DuMM::AtomIndex atomIx) const
 Obtain the element (by atomic number) of the atom indicated by the given AtomIndex.
Real getAtomRadius (DuMM::AtomIndex atomIx) const
 Obtain the van der Waals radius of the atom indicated by the given AtomIndex.
MobilizedBodyIndex getAtomBody (DuMM::AtomIndex atomIx) const
 Obtain the Simbody MobilizedBodyIndex of the rigid body on which a particular atom has been fixed.
Vec3 getAtomStationOnBody (DuMM::AtomIndex atomIx) const
 Obtain the station at which a particular atom is fixed on its body.
Vec3 getAtomStationInCluster (DuMM::AtomIndex atomIx, DuMM::ClusterIndex clusterIx) const
 Obtain the station at which a particular atom is fixed within a particular Cluster (an atom can be in more than one Cluster).
Vec3 getElementDefaultColor (int atomicNumber) const
 For display purposes, return the RGB value of a suggested color for an element given by atomic number.
Vec3 getAtomDefaultColor (DuMM::AtomIndex atomIx) const
 For display purposes, return the RGB value of a suggested color with which to display a particular atom.
Define clusters and bodies

Methods in this group control the grouping of atoms into rigid clusters and the placement of such clusters onto the rigid bodies of the underlying multibody system.

Note: we use the term "station" to refer to a fixed location with respect to a cluster or body frame, that is, a point "stationary" on that cluster or body.



DuMM::ClusterIndex createCluster (const char *clusterName)
 Create an empty Cluster (rigid group of atoms).
void placeAtomInCluster (DuMM::AtomIndex atomIx, DuMM::ClusterIndex clusterIx, const Vec3 &station)
 Place an existing atom at a particular station in the local frame of a Cluster.
void placeClusterInCluster (DuMM::ClusterIndex childClusterIndex, DuMM::ClusterIndex parentClusterIndex, const Transform &X_PC)
 Place a Cluster (the child) in another Cluster (the parent).
MassProperties calcClusterMassProperties (DuMM::ClusterIndex clusterIx, const Transform &X_BC=Transform()) const
 Calcuate the composite mass properties of a Cluster, either in its own reference frame C or in reference frame B with the Cluster placed relative to B using the indicated Transform X_BC.
void attachClusterToBody (DuMM::ClusterIndex clusterIx, MobilizedBodyIndex body, const Transform &X_BC=Transform())
 Place a Cluster's local frame C at a particular location and orientation with respect to a MobilizedBody's frame B.
void attachAtomToBody (DuMM::AtomIndex atomIx, MobilizedBodyIndex body, const Vec3 &station=Vec3(0))
 Place an individual atom at a particular station on a body without an intervening cluster.
MobilizedBodyIndex getClusterBody (DuMM::ClusterIndex clusterIx) const
 Find the MobilizedBody on which a Cluster has been fixed in place.
Transform getClusterPlacementOnBody (DuMM::ClusterIndex clusterIx) const
 Find where on its body a Cluster has been placed by returning the transform X_BC giving the orientation and position of Cluster frame C in body frame B.
Transform getClusterPlacementInCluster (DuMM::ClusterIndex childClusterIndex, DuMM::ClusterIndex parentClusterIndex) const
 Find where on parent cluster P a child cluster C has been placed, by returning the transform X_PC.
Define atom categories

An AtomClass is used to collect together a set of properties which are expected to be shared by many individual atoms.

The properties are: the element (as atomic number), expected valence, and van der Waals parameters. Charge is not included in AtomClass but in a second more detailed classification level called ChargedAtomType.

This fails if the atom class already exists. Van der waals radius is given as Rmin, the radius at which the energy well minimum is seen (actually it is 1/2 the distance between atom centers for a pair of atoms of this class). This is *not* Sigma, which we define as the radius (half distance) at which the energy crosses zero, that is, a little closer together than when the energy well is at maximum depth. CAUTION: it is also common in force fields that these terms are given by diameter rather than radius -- be sure you know what convention was use in your source so that you can convert to radius here. To convert for LJ: Rmin = 2^(1/6) * Sigma. The radius is in nm, the well depth in kJ/mol.



void defineAtomClass (DuMM::AtomClassIndex atomClassIx, const char *atomClassName, int elementNumber, int expectedValence, Real vdwRadiusInNm, Real vdwWellDepthInKJ)
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
void defineAtomClass_KA (DuMM::AtomClassIndex atomClassIx, const char *atomClassName, int element, int valence, Real vdwRadiusInAng, Real vdwWellDepthInKcal)
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
void defineAtomClass_KA (int atomClassIx, const char *atomClassName, int element, int valence, Real vdwRadiusInAng, Real vdwWellDepthInKcal)
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
bool hasAtomClass (DuMM::AtomClassIndex) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
bool hasAtomClass (const String &atomClassName) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
DuMM::AtomClassIndex getAtomClassIndex (const String &atomClassName) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
DuMM::AtomClassIndex getNextUnusedAtomClassIndex () const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
DuMM::AtomClassIndex getAtomClassIndex (DuMM::AtomIndex atomIx) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
Real getVdwRadius (DuMM::AtomClassIndex atomClassIx) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
Real getVdwWellDepth (DuMM::AtomClassIndex atomClassIx) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
void defineChargedAtomType (DuMM::ChargedAtomTypeIndex atomTypeIx, const char *atomTypeName, DuMM::AtomClassIndex atomClassIx, Real partialChargeInE)
 PartialCharge in units of e (charge on a proton); same in MD & KA.
void defineChargedAtomType_KA (DuMM::ChargedAtomTypeIndex atomTypeIx, const char *atomTypeName, DuMM::AtomClassIndex atomClassIx, Real partialChargeInE)
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
void defineChargedAtomType_KA (int atomTypeIx, const char *atomTypeName, int atomClassIx, Real partialChargeInE)
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
bool hasChargedAtomType (DuMM::ChargedAtomTypeIndex) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
bool hasChargedAtomType (const String &chargedTypeName) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
DuMM::ChargedAtomTypeIndex getChargedAtomTypeIndex (const String &chargedTypeName) const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
DuMM::ChargedAtomTypeIndex getNextUnusedChargedAtomTypeIndex () const
 Same routine as defineAtomClass() but in Kcal/Angstrom (KA) unit system, i.e., radius (still not sigma) is in Angstroms, and well depth in kcal/mol.
Control force field nonbonded behavior in special circumstances

These methods permit setting overall force field behavior in special circumstances, including van der Waals mixing behavior for dissimilar atom pairs and scaling of non-bonded terms for closely-bonded atoms.



const char * getVdwMixingRuleName (VdwMixingRule) const
 Obtain a human-readable name for one of our van der Waals mixing rules.
void setVdwMixingRule (VdwMixingRule)
 Set the van der Waals mixing rule -- our default is Waldman-Hagler.
VdwMixingRule getVdwMixingRule () const
 Get the van der Waals mixing rule currently in effect.
void setVdw12ScaleFactor (Real)
 default 0
void setVdw13ScaleFactor (Real)
 default 0
void setVdw14ScaleFactor (Real)
 default 1
void setVdw15ScaleFactor (Real)
 default 1
void setCoulomb12ScaleFactor (Real)
 default 0
void setCoulomb13ScaleFactor (Real)
 default 0
void setCoulomb14ScaleFactor (Real)
 default 1
void setCoulomb15ScaleFactor (Real)
 default 1
Tinker biotypes and pre-defined force field parameter sets

DuMM understands Tinker-format parameter files that can be used to load in a whole force field description.

This requires assigning Tinker Biotypes to the atoms in the molecule.



void loadAmber99Parameters ()
 Use Amber99 force field parameters.
void populateFromTinkerParameterFile (std::istream &)
 Load force field parameters from a TINKER format force field parameter file.
void setBiotypeChargedAtomType (DuMM::ChargedAtomTypeIndex chargedAtomTypeIndex, BiotypeIndex biotypeIx)
 Associate a Tinker Biotype with a ChargedAtomType in this subsystem.
DuMM::ChargedAtomTypeIndex getBiotypeChargedAtomType (BiotypeIndex biotypeIx) const
 Get charged atom type index in this force field associated with a particular Biotype.
std::ostream & generateBiotypeChargedAtomTypeSelfCode (std::ostream &os) const
 Generate C++ code from the current contents of this DuMM force field object.
Bond stretch terms

Bond stretch parameters (between 2 atom classes).

You can use the standard, built-in functional form (a harmonic) or define your own.



void defineBondStretch (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, Real stiffnessInKJperNmSq, Real nominalLengthInNm)
 Define a harmonic bond stretch term between two atom classes using the built-in functional form.
void defineBondStretch_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, Real stiffnessInKcalPerAngSq, Real nominalLengthInAng)
 Same as defineBondStretch() except that for convenience this takes stiffness in (kcal/mol)/A^2, and nominal length is in A (angstroms).
void defineBondStretch_KA (int class1, int class2, Real stiffnessInKcalPerAngSq, Real nominalLengthInAng)
 Same as defineBondStretch_KA() but takes integer class arguments for backwards compatibility.
void defineCustomBondStretch (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::CustomBondStretch *bondStretchTerm)
 Define a custom bond stretch term to be applied to the indicated pair of atom classes whenever they are found in a 1-2 bond.
Bond bending terms

Bond bending parameters (for 3 atom classes bonded 1-2-3).

You can use the standard, built-in functional form (a harmonic based on the 1-2-3 angle) or define your own.



void defineBondBend (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, Real stiffnessInKJPerRadSq, Real nominalAngleInDeg)
 Define a harmonic bond bending term applying to a triple of atom classes using the built-in functional form.
void defineBondBend_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, Real stiffnessInKcalPerRadSq, Real nominalAngleInDeg)
 Same as defineBondBend() except that for convenience this takes stiffness in (kcal/mol)/rad^2 (nominal angle is still in degrees).
void defineBondBend_KA (int class1, int class2, int class3, Real stiffnessInKcalPerRadSq, Real nominalAngleInDeg)
 Same as defineBondBend_KA() but takes integer class arguments for backwards compatibility.
void defineCustomBondBend (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::CustomBondBend *bondBendTerm)
 Define a custom bond bend term to be applied to the indicated triple of atom classes whenever they are found in a 1-2-3 bonded sequence.
Bond torsion terms

Bond torsion (dihedral) parameters (for 4 atom classes bonded 1-2-3-4).

You can use the standard, built-in functional form (a combination of sinusoids) or define your own. Bond torsion terms produce energy and a scalar torque that are dependent only on the rotation angle about the 2-3 bond in the specified atom class sequence.

Theory

Label the four bonded atoms r-x-y-s. Rotation occurs about the axis v=y-x, that is, a vector from x to y. We define a torsion angle theta using the "polymer convention" rather than the IUPAC one which is 180 degrees different. Ours is like this: 

             r                         r      s
   theta=0    \             theta=180   \    / 
               x--y                      x--y
                   \
                    s

The sign convention is the same for IUPAC and polymer: A positive angle is defined by considering r-x fixed in space. Then using the right hand rule around v (that is, thumb points from x to y) a positive rotation rotates y->s in the direction of your fingers.

We use a periodic energy function like this: 

       E(theta) = sum E_n(1 + cos(n*theta - theta0_n))

where n is the periodicity, E_n is the amplitude (kJ/mol) for term n, and theta0_n is the phase offset for term n. The torque term (applied about the v axis) is then 

       T(theta) = -[sum -n*E_n*sin(n*theta - theta0_n)]

Note that in the functional forms above the amplitude paramter E_n could be considered a "half amplitude" since the total excursion of the energy and torque functions is 2*E_n. When entering this parameter, be sure you understand whether the data you have represents the (half) amplitude as above (most common) or the full excursion range of the function, in which case you should provide only 1/2 the excursion as the value for DuMM's amplitude parameter.

For a custom torsion bond, DuMM will provide the angle theta to the user-written energy and torque routines, expecting a scalar value E(theta) and T(theta) back as above. However, the functional form is specified by the user in that case, and it is the user's responsibility to ensure that the returned torque is the negative gradient of the energy with respect to the angle parameter theta.

In either case, DuMM takes care of translating the returned scalar torque into an appropriate mobility torque when possible, or an appropriate set of forces on each of the atoms r-x-y-s such that the desired pure torque is realized as the resultant of the forces.



void defineBondTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity, Real ampInKJ, Real phaseInDegrees)
 Define bond torsion terms applying to a quadruple of atom classes using the built-in functional form, a combination of sinusoids with different periods (see full discussion in the group header for bond torsion terms).
void defineBondTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKJ, Real phase1InDegrees, int periodicity2, Real amp2InKJ, Real phase2InDegrees)
 Same as defineBondTorsion() but permits two torsion terms (with different periods) to be specified simultaneously.
void defineBondTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKJ, Real phase1InDegrees, int periodicity2, Real amp2InKJ, Real phase2InDegrees, int periodicity3, Real amp3InKJ, Real phase3InDegrees)
 Same as defineBondTorsion() but permits three torsion terms (with different periods) to be specified simultaneously.
void defineBondTorsion_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees)
 Same as defineBondTorsion() but permits takes the amplitude in kcal/mol (but note that this is converted immediately to our MD unit system of kJ/mol).
void defineBondTorsion_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees, int periodicity2, Real amp2InKcal, Real phase2InDegrees)
 Same as defineBondTorsion_KA() but permits two torsion terms (with different periods) to be specified simultaneously.
void defineBondTorsion_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees, int periodicity2, Real amp2InKcal, Real phase2InDegrees, int periodicity3, Real amp3InKcal, Real phase3InDegrees)
 Same as defineBondTorsion_KA() but permits three torsion terms (with different periods) to be specified simultaneously.
void defineBondTorsion_KA (int class1, int class2, int class3, int class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees)
 Same as defineBondTorsion_KA() but takes integer class arguments for backwards compatibility.
void defineBondTorsion_KA (int class1, int class2, int class3, int class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees, int periodicity2, Real amp2InKcal, Real phase2InDegrees)
 Same as defineBondTorsion_KA() but takes integer class arguments for backwards compatibility.
void defineBondTorsion_KA (int class1, int class2, int class3, int class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees, int periodicity2, Real amp2InKcal, Real phase2InDegrees, int periodicity3, Real amp3InKcal, Real phase3InDegrees)
 Same as defineBondTorsion_KA() but takes integer class arguments for backwards compatibility.
void defineCustomBondTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, DuMM::CustomBondTorsion *bondTorsionTerm)
 Define a custom bond torsion term to be applied to the indicated quadruple of atom classes whenever they are found in a 1-2-3-4 bonded sequence.
Amber-style improper torsions

As with normal torsions, (see defineBondTorsion()), only one term may have a given periodicity.

The amplitudes are in kJ/mol. The third atom is the central one to which the other three are bonded; this is not the same in reverse order.



void defineAmberImproperTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity, Real ampInKJ, Real phaseInDegrees)
 Provide one torsion term in MD units, using kilojoules for amplitude.
void defineAmberImproperTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKJ, Real phase1InDegrees, int periodicity2, Real amp2InKJ, Real phase2InDegrees)
 Provide two torsion terms in MD units, using kilojoules/mole for amplitude.
void defineAmberImproperTorsion (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKJ, Real phase1InDegrees, int periodicity2, Real amp2InKJ, Real phase2InDegrees, int periodicity3, Real amp3InKJ, Real phase3InDegrees)
 Provide three torsion terms in MD units, using kilojoules/mole for amplitude.
void defineAmberImproperTorsion_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees)
 Provide one torsion term in KA units, using kilocalories/mole for amplitude.
void defineAmberImproperTorsion_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees, int periodicity2, Real amp2InKcal, Real phase2InDegrees)
 Provide two torsion terms in KA units, using kilocalories/mole for amplitude.
void defineAmberImproperTorsion_KA (DuMM::AtomClassIndex class1, DuMM::AtomClassIndex class2, DuMM::AtomClassIndex class3, DuMM::AtomClassIndex class4, int periodicity1, Real amp1InKcal, Real phase1InDegrees, int periodicity2, Real amp2InKcal, Real phase2InDegrees, int periodicity3, Real amp3InKcal, Real phase3InDegrees)
 Provide three torsion terms in KA units, using kilocalories/mole for amplitude.
GBSA implicit solvation

These methods are used to set GBSA terms.



void setSolventDielectric (Real)
void setSoluteDielectric (Real)
Real getSolventDielectric () const
Real getSoluteDielectric () const
void setGbsaIncludeAceApproximation (bool)
void setGbsaIncludeAceApproximationOn ()
void setGbsaIncludeAceApproximationOff ()
Global scale factors

These non-physical parameters can be used to weaken or disable (or magnify) individual force field terms.

These are always 1 for correct implementation of any force field; other values are primarily useful for testing the effects of individual terms on results or performance. Set to 0 to disable the corresponding term altogether.



void setVdwGlobalScaleFactor (Real)
 scale all van der Waals terms
void setCoulombGlobalScaleFactor (Real)
 scale all Coulomb terms
void setGbsaGlobalScaleFactor (Real)
 scale all GBSA terms
void setBondStretchGlobalScaleFactor (Real)
 scale all built-in bond stretch terms
void setBondBendGlobalScaleFactor (Real)
 scale all built-in bond bending terms
void setBondTorsionGlobalScaleFactor (Real)
 scale all built-in bond torsion terms
void setAmberImproperTorsionGlobalScaleFactor (Real)
 scale all improper torsion terms
void setCustomBondStretchGlobalScaleFactor (Real)
 scale all custom bond stretch terms
void setCustomBondBendGlobalScaleFactor (Real)
 scale all custom bond bending terms
void setCustomBondTorsionGlobalScaleFactor (Real)
 scale all custom bond torsion terms
Real getVdwGlobalScaleFactor () const
 get current scale factor for van der Waals terms
Real getCoulombGlobalScaleFactor () const
 get current scale factor for Coulomb terms
Real getGbsaGlobalScaleFactor () const
 get current scale factor for GBSA terms
Real getBondStretchGlobalScaleFactor () const
 get current scale factor for built-in bond stretch terms
Real getBondBendGlobalScaleFactor () const
 get current scale factor for built-in bond bending terms
Real getBondTorsionGlobalScaleFactor () const
 get current scale factor for built-in bond torsion terms
Real getAmberImproperTorsionGlobalScaleFactor () const
 get current scale factor for improper torsion terms
Real getCustomBondStretchGlobalScaleFactor () const
 get current scale factor for custom bond stretch terms
Real getCustomBondBendGlobalScaleFactor () const
 get current scale factor for custom bond bending terms
Real getCustomBondTorsionGlobalScaleFactor () const
 get current scale factor for custom bond torsion terms
void setAllGlobalScaleFactors (Real s)
 Set all the global scale factors to the same value.
Computational options

These methods control how DuMM performs its computations.



void setUseMultithreadedComputation (bool)
 Enable or disable multithreaded computation (enabled by default).
bool getUseMultithreadedComputation () const
 Is multithreaded computation enabled?
void setUseOpenMMAcceleration (bool)
 This determines whether we use OpenMM GPU acceleration if it is available.
bool getUseOpenMMAcceleration () const
 Return the current setting of the flag set by setUseOpenMMAcceleration().
void setTraceOpenMM (bool)
 For debugging, you can ask DuMM to dump some information to std::clog about its attempts to use OpenMM.
void setAllowOpenMMReference (bool)
 This allows us to use OpenMM even if only the Reference platform is available.
bool getAllowOpenMMReference () const
 Return the current setting of the flag set by setAllowOpenMMReference().
bool isUsingOpenMM () const
 Return true if DuMM is currently using OpenMM for its computations.
std::string getOpenMMPlatformInUse () const
 Return the OpenMM Platform currently in use, or the empty string if we're not using OpenMM.
Bookkeeping, debugging, and internal-use-only methods

Hopefully you won't need these.



long long getForceEvaluationCount () const
 How many times has the forcefield been evaluated?
void dump () const
 Produce an ugly but comprehensive dump of the contents of DuMM's internal data structures, sent to std::cout (stdout).
void dumpCForceFieldParameters (std::ostream &os, const String &methodName="loadParameters") const
 Generate C++ code to reproduce forceField parameters presently in memory.
void loadTestMoleculeParameters ()
 Load test parameters.
int getNAtoms () const
 OBSOLETE; TODO: remove in SimTK 2.0.
int getNBonds () const
 OBSOLETE; TODO: remove in SimTK 2.0.

Protected Member Functions

 SimTK_PIMPL_DOWNCAST (DuMMForceFieldSubsystem, ForceSubsystem)
 SimTK_PIMPL_DOWNCAST (DuMMForceFieldSubsystem, Subsystem)
void defineIncompleteAtomClass (DuMM::AtomClassIndex classIx, const char *name, int elementNumber, int valence)
void defineIncompleteAtomClass_KA (DuMM::AtomClassIndex classIx, const char *name, int elementNumber, int valence)
void setAtomClassVdwParameters (DuMM::AtomClassIndex atomClassIx, Real vdwRadiusInNm, Real vdwWellDepthInKJPerMol)
void setAtomClassVdwParameters_KA (DuMM::AtomClassIndex atomClassIx, Real radiusInAng, Real wellDepthInKcal)
bool isValidAtomClass (DuMM::AtomClassIndex) const
void defineIncompleteChargedAtomType (DuMM::ChargedAtomTypeIndex typeIx, const char *name, DuMM::AtomClassIndex classIx)
void defineIncompleteChargedAtomType_KA (DuMM::ChargedAtomTypeIndex typeIx, const char *name, DuMM::AtomClassIndex classIx)
void setChargedAtomTypeCharge (DuMM::ChargedAtomTypeIndex, Real charge)
void setChargedAtomTypeCharge_KA (DuMM::ChargedAtomTypeIndex chargedAtomTypeIx, Real charge)

Friends

class MolecularMechanicsSystem

Detailed Description

This is a concrete subsystem that provides basic molecular mechanics functionality for coarse-grained molecules built in the SimTK framework.

UNITS: This subsystem requires that the system be modeled in "MD units" of nanometers, daltons (g/mol), and picoseconds, yielding consistent energy units of kJ/mol==(Da-nm^2/ps^2), and force in kJ/mol-nm. Charge is in proton charge units e, and angles are in radians. For convenience, we allow the force field to be defined in "KA" units, that is, angstroms instead of nanometers, and energy in kcal rather than kJ, and we also allow angles to be supplied in degrees. However, these are immediately converted to the MD units described above.

Member Enumeration Documentation

enum VdwMixingRule

These are the van der Waals mixing rules supported by DuMM.

Enumerator:
WaldmanHagler 

Our default, Waldman & Hagler, J.Comp.Chem. 14(9) 1993.

HalgrenHHG 

MMFF, AMOEBA.

Jorgensen 

OPLS.

LorentzBerthelot 

AMBER, CHARMM.

Kong 

Kong, J.Chem.Phys. 59(5) 1973.

The documentation for this class was generated from the following file:
Generated on Wed Dec 30 11:05:12 2009 for SimTKcore by  doxygen 1.6.1