Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_DlsMat
_generic_N_Vector
_generic_N_Vector_Ops
_N_VectorContent_Parallel
_N_VectorContent_Serial
_SpgmrMemRec
AbstractValueAbstract base class representing an arbitrary value of self-describing type
AcetylResidueWidely used acetyl protein N-terminal end cap
Actinium
AdenineBase
Adenylate
Alanine
AlcoholOHGroupAlcoholOHGroup is OH group for attachment to aliphatic carbon
AliphaticCarbonAliphaticCarbon is a tetrahedral sp3 carbon atom for bonding to four other things
AliphaticHydrogenAliphaticHydrogen is a hydrogen atom for bonding to AliphaticCarbon atoms (see below)
Aluminum
Amber99ForceSubsystemThis class is just a DuMMForceFieldSubsystem for which the constructor pre-loads the definitions of the Amber99 force field
Americium
AminoAcidResidueAmino acid residue building block for protein polypeptide chain molecules
AnalyticBrickThis is a rectangular solid
AnalyticCircleAn analytic circle has only a radius
AnalyticCurve
AnalyticCylinderThe coordinate frame of the central cross section is the same as for a circle; that is, x and z are radial and y points along the cylinder's axis
AnalyticGeometryThis abstract class represents a piece of high-quality geometry that can be used for valid physical simulation
AnalyticLineAn analytic line has only a length
AnalyticSphere
AnalyticSurface
AnalyticVolume
Antimony
APIArgcheckFailedThis is for reporting problems detected by checking the caller's supplied arguments to a SimTK API method
Arginine
ArgonThe noble gas argon, which does not bond with other atoms
Argon
AromaticSixMemberedCHGroupTwo atom C-H group in six membered aromatic rings
Array< T >Container class like std::vector<T> but with hidden implementation
ArrayBase< T >
ArrayHelperNon-templatized helper class for ArrayBase<T>
ArrayView< T >This class is a duplicate of Array and can be cast to an Array with no harm
Arsenic
Asparagine
Aspartate
AssertThis is for reporting internally-detected bugs only, not problems induced by confused users (that is, it is for confused developers instead)
Astatine
Atom
AtomBonding
AtomicIntegerThis class functions exactly like an int, except that the following operators are atomic: ++, --, +=, -=, *=, /=, =, &=, |=, ^=, <<=, and >>=
AtomInfo
AtomsByBody
AtomSubsystem
BallThree constraint equations
BallThree mobilities -- unrestricted orientation modeled with a quaternion which is never singular
Barium
Base
BendStretchTwo mobilities: The z axis of the parent's F frame is used for rotation (and that is always aligned with the M frame z axis)
Berkelium
Beryllium
BetaBranchedAminoAcidResidue
BetaUnbranchedAminoAcidResidue
BiopolymerThe base class for DNA, RNA, and Protein molecules
BiopolymerResidue
Biotype
Bismuth
BivalentAtomBase class for atoms having exactly two covalent bonds
Body
Bohrium
Bond
Boron
Bromine
CacheEntryOutOfDate
Cadmium
Calcium
CalciumIonCa2+ calcium ion with +2 charge
Californium
Cant
Carbon
CarboxylateGroupCaboxylateGroup is COO- for attachment to tetrahedral carbon
CauseThese are all the possible causes for events
Cerium
Cesium
CesiumIonCs+ cesium ion with +1 charge
ChlorideIonCl- chloride ion with -1 charge
Chlorine
Chromium
Clonable
CNT< K >Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them
CNT< complex< R > >Specializations of CNT for numeric types
CNT< conjugate< R > >
CNT< double >
CNT< float >
CNT< long double >
Cobalt
CollisionDetectionAlgorithmA CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them
CompoundThe base class for atoms, molecules, and chemical groups
CompoundModelerTurns a compound into a multibody system
CompoundSystemDerived class of MolecularMechanicsSystem that knows how to model molmodel Compounds
Concretize< T >Wrap a pointer to an abstract base class in a way that makes it behave like a concrete class (sometimes called a "ClonePtr")
conjugate< R >SimTK::conjugate<R> should be instantiated only for float, double, long double
conjugate< double >
conjugate< float >
conjugate< long double >
ConstantThis is a Function_ subclass which simply returns a fixed value, independent of its arguments
Constant_< T >This creates a Measure whose value is a Topology-stage constant of any type T
ConstantAngleOne constraint equation
ConstantForceA constant force applied to a body station
ConstantOrientationThree constraint equations
ConstantSpeedOne non-holonomic constraint equation
ConstantTorqueA constant torque to a body
ConstraintThis is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation
ContactA Contact contains information about two bodies that are in contact with each other
ContactGeometryA ContactGeometry object describes the physical shape of a body
ContactGeometryImpl
ContactImplThis is the internal implementation class for Contact
ConvergedFailed
CoordinateAxis
CoordinateCouplerThis is a subclass of Constraint::Custom which uses a Function object to define a holonomic (position) constraint
Copper
CPodesThis is a straightforward translation of the Sundials CPODES C interface into C++
CPodesIntegratorThis is an Integrator based on the CPODES library
CPodesSystemThis abstract class defines the system to be integrated with SimTK CPodes
Curium
CustomThe handle class Constraint::Custom (dataless) and its companion class Constraint::Custom::Implementation can be used together to define new Constraint types with arbitrary properties
CustomThis class can be used to define new forces
CustomThe handle class MobilizedBody::Custom (dataless) and its companion class MobilizedBody::Custom::Implementation can be used together to define new MobilizedBody types with arbitrary properties
CustomBondBendAbstract base class for custom bond bend functions, that is, functional forms that apply an angle-based torque between the two lines formed by a 1-2-3 triple of bonded atoms
CustomBondStretchAbstract base class for custom bond stretch terms, that is, functional forms that apply a distance-based force along a 1-2 bond between a pair of atoms
CustomBondTorsionAbstract base class for custom torsion functions, that is, functional forms that apply a dihedral-angle based torque about the middle bond of a 1-2-3-4 quadruple of bonded atoms
CVadjCheckPointRec
CylinderTwo mobilities -- rotation and translation along the common z axis of the inboard and outboard mobilizer frames
Cysteine
Cytidylate
CytosineBase
Darmstadtium
DeadMatrixView_< ELT >This is a MatrixView_ with the additional property that we are about to delete it
DecorationSubsystemThis is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem
DecorativeBrickThis defines a rectangular solid centered at the origin and aligned with the local frame axes
DecorativeCircleThis defines a circle in the x-y plane, centered at the origin
DecorativeCylinderThis defines a cylinder centered on the origin and aligned in the y direction
DecorativeEllipsoidThis defines an ellipsoidal solid centered at the origin and aligned with the local frame axes
DecorativeFrameThis defines geometry to represent a coordinate frame
DecorativeGeometryThis is an abstract handle class using the PIMPL design pattern to hide the private implementation
DecorativeGeometryImplementationUse this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above
DecorativeLineA line between two points
DecorativeMeshThis defines a polygonal mesh
DecorativeSphereThis defines a sphere centered at the origin
DecorativeTextThis defines a text label with its base at the origin
DeepCopy
DefaultSystemSubsystemThis is a concrete Subsystem that is part of every System
Deuterium
DiagonalView
DifferentiatorGiven a function f(y), where f, y or both can be vectors, calculate the derivative (gradient, Jacobian) df/dy
Dubnium
DuMMForceFieldSubsystemThis is a concrete subsystem that provides basic molecular mechanics functionality for coarse-grained molecules built in the SimTK framework
DuplicatePdbResidue
Dysprosium
Edge
EigenClass to compute Eigen values and Eigen vectors of a matrix
Einsteinium
ElasticFoundationForceThis class implements an elastic foundation or "bed of springs" contact model
Element
EllipsoidThree mobilities -- coordinated rotation and translation along the surface of an ellipsoid fixed to the parent (inboard) body
EltResult< P >
EltResult< P >
EltResult< P >
EltResult< P >
EltResult< P >
EltResult< P >
EltResult< P >
Enumeration< T >This class defines an enumerated type
EnumerationSet< T >This class provides an efficient implementation of a set for storing values of an enumerated type defined with Enumeration
EnumerationSetRepThis class is the internal implementation of EnumerationSet
Erbium
ErrorCheckThis is for reporting errors occurring during execution of SimTK core methods, beyond those caused by mere improper API arguments, which should be reported with APIArgcheck instead
EthaneThe small hydrocarbon ethane, C2H6, which has a single torsion degree of freedom
Europium
EventAn Event is "something that happens" during a Study that is advancing through time
EventHandlerAn EventHandler is an object that defines an event that can occur within a system
EventReporterAn EventReporter is an object that defines an event that can occur within a system
EventTriggerInfoThis class is used to communicate between the System and an Integrator regarding the properties of a particular event trigger function
ExplicitEulerIntegratorThis is an Integrator based on the explicit Euler algorithm
Face
FactorAbstract class for performing matrix factorizations
FactorLUClass for performing LU matrix factorizations
FactorQTZClass to perform a QTZ (linear least squares) factorization
FactorSVDClass to compute a singular value decomposition of a matrix
Fermium
FivePrimeRnaHydroxylGroupPhosphate group at 5' end (beginning) of RNA
FivePrimeRnaPhosphateGroupPhosphate group at 5' end (beginning) of RNA
Fluorine
ForceA Force object applies forces to the bodies in a system
ForceAndEnergy
ForceSubsystemThis is logically an abstract class, more specialized than "Subsystem" but not yet concrete
Francium
FreeUnrestricted motion for a rigid body (six mobilities)
FreeLineFive mobilities, representing unrestricted motion for a body which is inertialess along its own z axis
FunctionThis abstract class defines a function to be differentiated (repeatedly) by a Differentiator object
Function_< T >This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments
FunctionBasedThis is a subclass of MobilizedBody::Custom which uses a set of Function objects to define the behavior of the MobilizedBody
Gadolinium
Gallium
GaussianThis is a subclass of Random that generates numbers according to a Gaussian distribution with a specified mean and standard deviation
GCVSPLUtilThis class provides entry points for using the GCVSPL algorithm in terms of SimTK data types
GeneralContactSubsystemThis class performs collision detection for use in contact modeling
GeneralForceSubsystemThis is a concrete subsystem which can apply arbitrary forces to a MultibodySystem
Germanium
GimbalThree mobilities -- unrestricted orientation modeled as a 1-2-3 body-fixed Euler angle sequence
GlobalDamperA general energy "drain" on the system
Glutamate
Glutamine
Glycine
Gold
GradientFunctionDerive a concrete class from this one if you have a scalar function of multiple variables that you want to differentiate
GrinPointer< PointeeType >
Ground
GroundThis is a special type of "mobilized" body used as a placeholder for Ground in the 0th slot for a MatterSubsystem's mobilized bodies
GuanineBase
Guanylate
GutsThis is the declaration for the Study::Guts class, the abstract object to which a Study handle points
GutsThe abstract parent of all Subsystem "Guts" implementation classes
GutsThis is the declaration for the System::Guts class, the abstract object to which a System handle points
GutsPublic declaration of internals for ForceSubsystem extension
Hafnium
HalfSpaceThis ContactGeometry subclass represents an object that occupies the entire half-space x>0
HalfSpaceImpl
HalfSpaceSphereThis algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Sphere
HalfSpaceTriangleMeshThis algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::TriangleMesh
Hassium
Helium
HermitianThis is the default commitment for a Hermitian (*not* symmetric) matrix
Histidine
HNAminoAcidResidueAminoAcidResidue differs from HNAminoAcidResidue in lacking "HN" proton, so Proline can be derived
Holmium
HuntCrossleyContactThis is a concrete subsystem that handles simple, frictionless contact situations with a model due to Hunt & Crossley: K
HuntCrossleyForceThis class models the forces generated by simple point contacts, such as between two spheres, or a sphere and a half space
Hydrogen
IllegalLapackArg
ImplementationThe abstract parent of all Measure_ Implementation classes
ImplementationThis is the base Implementation class for all Measures whose value type is known
Implementation
Implementation
Implementation
Implementation
Implementation
Implementation
IncompatibleValues
IncorrectArrayLength
IndexOutOfRange
Indium
InertiaThe physical meaning of an inertia is the distribution of a rigid body's mass about a *particular* point
Integrate_< T >
IntegratorAn Integrator is an object that can simulate the behavior of a System through time
InverseRotation----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information
InverseTransformTransform from frame B to frame F, but with the internal representation inverted
Iodine
Iridium
Iron
Isoleucine
iteratorThis class provides an interface for iterating over the set of all possible enumerated values
iteratorThis class provides an interface for iterating over the content of an EnumerationSet
JacobianFunctionDerive a concrete class from this one if you have a set of functions (i.e., a vector-valued function) of multiple variables that you want to differentiate
Kabsch78
Krypton
Lanthanum
Lapack
LapackFullPredefined MatrixCharacter for an ordinary Lapack-style full matrix of a particular dimension m x n (nrows X ncols)
Lawrencium
Lead
Leucine
LigandDroplet
Linear
LinearThis is a Function_ subclass whose output value is a linear function of its arguments: f(x, y,
LinearBushingThis force element represents a bushing acting to connect a frame F fixed on one body (B1) to a frame M fixed on a second body (B2), by a massless, compliant element with linear stiffness and damping properties
LineOrientationTwo mobilities, representing unrestricted orientation for a body which is inertialess along its own z axis
List< T >Container class with hidden implementation
ListBase< T >
ListBase< T * >
ListView< T >ListView is a 'dummy' class which is completely interchangeable with List
Lithium
LithiumIonLi+ lithium ion with +1 charge
LocalEnergyMinimizerThis class performs local potential energy minimization of a MultibodySystem
Lutetium
Lysine
Magnesium
MagnesiumIonMg2+ magnesium ion with +2 charge
Manganese
Mask
MaskUse this class to represent sets of acceptable values for each of the storage attributes (packing, position, order, diagonal)
Mask
MaskUse this class to represent a set of acceptable Condition values
MaskThis class collects masks of each characteristic type for representing sets of accceptable characteristics
MassCenterMotionRemoverThis is an event handler that can remove from a molecular system any unwanted "rigid body" motion of the sytem as a whole
Massless
MassPropertiesThis class contains the mass, center of mass, and inertia of a rigid body B
Mat< M, N, ELT, CS, RS >CS is total spacing between columns in memory (default M) RS is total spacing between rows in memory (default 1)
Matrix_< ELT >This is the Matrix class intended to appear in user code
MatrixBase< ELT >Variable-size 2d matrix of Composite Numerical Type (ELT) elements
MatrixCharacterA MatrixCharacter is a set containing a value for each of the matrix characteristics except element type, which is part of the templatized declaration of a Matrix, Vector, or RowVector handle
MatrixCommitmentA MatrixCommitment provides a set of acceptable matrix characteristics
MatrixConditionMatrix "condition" is a statement about the numerical characteristics of a Matrix
MatrixHelper< S >Here we define class MatrixHelper<S>, the scalar-type templatized helper class for the more general, composite numerical type-templatized class MatrixBase<ELT>
MatrixOutlineMatrix "outline" refers to the characteristic relationship between the number of rows and columns of a matrix, without necessarily specifying the absolute dimensions
MatrixStorageMatrix "storage" refers to the physical layout of data in the computer’s memory
MatrixStructureMatrix "structure" refers to an inherent mathematical (or at least algorithmic) characteristic of the matrix rather than a storage strategy
MatrixView_< ELT >This class is identical to a Matrix_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them
MeasureThis is the base class for all Measure handle classes
Measure_< T >This is the base handle class for all Measures whose value type is known
Meitnerium
Mendelevium
Mercury
MethaneThe simplest hydrocarbon methane, CH4
Methionine
MethyleneGroupMethyleneGroup is -CH2- group for bonding to aliphatic carbon and a second something
MethylGroupMethylGroup is CH3 for attaching to aliphatic carbon
Minimum_< T >This Measure tracks the minimum value attained by its source operand since the last initialize() call
MobilityConstantForceA constant (scalar) "force" f applied to a mobility
MobilityLinearDamperA linear damper on a mobility coordinate
MobilityLinearSpringA linear spring along or around a mobility coordinate
MobilizedBodyThis is the base class for all MobilizedBody classes, just a handle for the underlying hidden implementation
MolecularMechanicsSystemThis is a particular kind of MultibodySystem, one intended for use in molecular mechanics (MM)
MoleculeBase class for complete covalently connected molecules
Molybdenum
MultibodyDynamicsStudy
MultibodySystemThe job of the MultibodySystem class is to coordinate the activities of various subsystems which can be part of a multibody system
N_Vector_Ops_SimTK
N_Vector_SimTK
N_VectorContent_SimTK
Narrowest< R1, R2 >This class is specialized for all 36 combinations of standard types (that is, real and complex types in each of three precisions) and has typedefs "Type" which is the appropriate "narrowed" type for use when R1 & R2 appear in an operation together where the result must be of the narrower precision, and "Precision" which is the expected precision of the result (float, double, long double)
Narrowest< complex< R1 >, complex< R2 > >
Narrowest< complex< R1 >, R2 >
Narrowest< double, double >
Narrowest< double, float >
Narrowest< double, long double >
Narrowest< float, double >
Narrowest< float, float >
Narrowest< float, long double >
Narrowest< long double, double >
Narrowest< long double, float >
Narrowest< long double, long double >
Narrowest< R1, complex< R2 > >
negator< NUMBER >Negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically to N, but behaves as though multiplied by -1, though at zero cost
Neodymium
Neon
Neptunium
Nickel
Niobium
Nitrogen
NMethylAmideResidueNeutral C-terminal protein cap
Nobelium
NoseHooverThermostat
NoSlip1DOne non-holonomic constraint equation
NotPositiveDefinite
NTraits< N >
NTraits< complex< R > >Partial specialization for complex numbers -- underlying real R is still a template parameter
NTraits< conjugate< R > >
OBBTreeNodeThis class represents a node in the Oriented Bounding Box Tree for a TriangleMesh
OBBTreeNodeImpl
ObservedPointFitterThis class attempts to find the configuration of an internal coordinate model which best fits a set of observed data
OperationNotAllowedOnNonconstReadOnlyView
OperationNotAllowedOnOwner
OperationNotAllowedOnView
OptimizerAPI for SimTK Simmath's optimizers
OptimizerFailed
OptimizerSystemAbstract class which defines an objective/cost function which is optimized by and Optimizer object
OrientedBoundingBoxThis class represents a rectangular box with arbitrary position and orientation
Osmium
Oxygen
P12
PairIterator
Palladium
Parallel2DExecutorThis class is used for performing multithreaded computations over two dimensional ranges
ParallelExecutorThis class is used for performing multithreaded computations
PathnameThis class encapsulates the handling of file and directory pathnames in a platform-independent manner
PdbAtomOne atom, which may have more than one location, in the case of static or dynamic disorder in an X-ray structure
PdbAtomLocationLocation information for a PdbAtom, corresponding to one altLoc for a PdbAtom
PdbChainOne molecule in a PDB structure
PdbModelPDB structure containing one or more molecules (chains), corresponding to one member of an NMR ensemble of alternate structures, or to one frame of a molecular dynamics simulation
PDBReaderThis class parses PDB files, then constructs Systems and States based on them for use in Simbody
PdbResidueOne residue in a protein or nucleic acid, or a single molecule in the case of non-polymer structures
PdbResidueIdComposite key for residue within a chain, composed of residue number and insertion code
PdbStructureComplete PDB file, possibly including multiple MODELS, in the case of NMR structures or molecular dynamics trajectories
PeriodicEventHandlerPeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals
PeriodicEventReporterPeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals
PeriodicPdbWriterWrites atomic coordinates in PDB format to a file stream at specified intervals during a simulation
PeriodicVmdReporterWrites atomic coordinates in PDB format to a file stream at specified intervals during a simulation
Phenylalanine
PhiMatrix
PhiMatrixTranspose
Phosphorus
PIMPLHandle< HANDLE, IMPL, PTR >This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes
PIMPLImplementation< HANDLE, IMPL >This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles)
PinOne mobility -- rotation about the common z axis of the inboard and outboard mobilizer frames
PlanarThree mobilities -- z rotation and x,y translation
Platinum
PluginThis is the base class for representing a runtime-linked dynamic library, also known as a "plugin", in a platform-independent manner
Plutonium
PointContactThis subclass of Contact represents a symmetric contact centered at a single point, such as between two spheres or a sphere and a half space
PointContactImplThis is the internal implementation class for PointContact
PointInPlaneOne constraint equation
PointOnLineTwo constraint equations
Polonium
PolygonalMeshThis class provides a description of a mesh made of polygonal faces
PolynomialThis is a Function_ subclass whose output value is a polynomial of its argument: f(x) = ax^n+bx^(n-1)+
PolynomialRootFinderThis class provides static methods for finding the roots of polynomials
Potassium
PotassiumIonK+ potassium ion with +1 charge
Praseodymium
PrescribedMotionThis is a subclass of Constraint::Custom which uses a Function to prescribe the behavior of a single generalized coordinate as a function of time
PrimaryAmineGroupPrimaryAmineGroup is NH3+ for attachment to tetrahedral carbon
ProjectOptions
Proline
Promethium
Protactinium
Protein
PseudorotationMobilizer
PurineBaseCore
PyrimidineBaseCore
QuadrivalentAtomBase class for atoms having exactly four covalent bonds
QuaternionA Quaternion is a Vec4 with the following behavior:

  • its length is always 1 (or else it is all NaN)
  • it is equivalent to an angle/axis rotation for angle a, axis unit vector v, as: q = [ cos(a/2) sin(a/2)*v ] A quaternion is in "canonical form" when its first element is nonnegative
Radium
Radon
RandomThis class defines the interface for pseudo-random number generators
RealizeCheckFailed
RealizeTopologyMustBeCalledFirst
ResidueInfo
Result< P >
Result< P >
Result< P >
Result< P >
Result< P >
Result< P >
Result< P >
Result< P >
Rhenium
Rhodium
RibonucleosideResidue
RibonucleotideResidue
RiboseCore
RiboseNu3Mobilizer
Rigid
RigidUnit
RNA
RnaPhosphodiesterLinkage
RodOne constraint equation
Roentgenium
RotationMat33 that guarantees that the matrix is a legitimate 3x3 array associated with the relative orientation of two right-handed, orthogonal, unit vector bases
Row< N, ELT, STRIDE >Generic Row
RowVectorThis is the default commitment for a row vector
RowVectorPredefined MatrixCharacter for an ordinary row vector of a particular size
RowVector_< ELT >RowVectors are much less common than Vectors
RowVectorBase< ELT >This is a dataless rehash of the MatrixBase class to specialize it for RowVectors
RowVectorView_< ELT >This class is identical to a RowVector_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them
RTraits< R >RTraits is a helper class for NTraits
RTraits< double >
RTraits< float >
RTraits< long double >
Rubidium
RubidiumIonRb+ rubidium ion with +1 charge
RungeKuttaFeldbergIntegrator
RungeKuttaMersonIntegrator
Ruthenium
Rutherfordium
Samarium
SampleAndHold_< T >This is a Measure operator which, upon occurrence of a designated event, samples its source Measure and then holds its value in a discrete state variable until the next occurrence of the event
ScalarFunctionDerive a concrete class from this one if you have a scalar function of a single scalar variable that you want to differentiate
Scandium
ScheduledEventHandlerScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance
ScheduledEventReporterScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance
ScrewOne mobility -- coordinated rotation and translation along the common z axis of the inboard and outboard mobilizer frames
Seaborgium
Selenium
Serine
SetHandle
ShallowCopy
Silicon
Silver
SimbodyMatterSubsystemThe Simbody low-level multibody tree interface
SimbodyMatterSubtreeA SimbodyMatterSubtree is a view of a connected subgraph of the tree of mobilized bodies in a SimbodyMatterSubsystem
SimbodyMatterSubtreeResults
SimTK_double_complex
SimTK_float_complex
SingleAtomBase class for single-atom Compound building blocks
SingularMatrix
Sinusoid_< T >This measure produces a sinusoidal function of time: m(t) = a*sin(w*t+p) where a=amplitude in arbitrary units, w=frequency in rad/s, p=phase in rad
SinusoidFunctionImplements a simple functional relationship, y = amplitude * sin(x - phase)
SizeOutOfRange
SizeWasNegative
SkewHermitianThis is the default commitment for a skew Hermitian (*not* skew symmetric) matrix
SkewSymmetricThis is the default commitment for skew symmetric (*not* skew Hermitian) matrix
SliderOne mobility -- translation along the common x axis of the inboard and outboard mobilizer frames
Sodium
SodiumIonNa+ sodium ion with +1 charge
SpbcgMemRec
SpeedCouplerThis is a subclass of Constraint::Custom which uses a Function object to define a nonholonomic (velocity) constraint
SphereThis ContactGeometry subclass represents a sphere centered at the origin
SphereImpl
SphereSphereThis algorithm detects contacts between two ContactGeometry::Sphere objects
SphereTriangleMeshThis algorithm detects contacts between a ContactGeometry::Sphere and a ContactGeometry::TriangleMesh
SphericalCoordsThree mobilities -- body fixed 3-2 (z-y) rotation followed by translation along body z or body x
Spline_< T >This class implements a non-uniform B-spline curve
SplineFitter< T >Given a set of data points, this class creates a Spline_ which interpolates or approximates them
SplineFitterImpl
SplineImpl
SptfqmrMemRec
StableArray< T >StableArray<T> is like std::vector<T> but more stable in two ways:

  • the addresses of the inserted items never change, even if the array has to be resized, and
  • the index of an inserted item never changes either
StageThis class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic
StageIsWrong
StageOutOfRange
StageTooHigh
StageTooLow
StateThis is the handle class for the hidden State implementation
StringSimTK::String is just an std::string with some additional methods defined
Strontium
Study
SubMat< MM, NN >
Substitute< P >
Substitute< P >
Substitute< P >
Substitute< P >
Substitute< P >
Substitute< P >
Substitute< P >
Substitute< P >
SubsystemThe abstract parent of all Subsystems
SubtestInternal utility class for generating test messages for subtests
Sulfur
SymMat< M, ELT, RS >RS is total spacing between rows in memory (default 1)
SymmetricThis is the default commitment for a symmetric (*not* Hermitian) matrix
SystemThe handle class which serves as the abstract parent of all Systems
Tantalum
TaskConcrete subclasses of this abstract class represent tasks that can be executed by a Parallel2DExecutor
TaskConcrete subclasses of this abstract class represent tasks that can be executed by a ParallelExecutor
Technetium
Tellurium
Terbium
TestThis is the main class to support testing
TextDataEventReporterThis is an EventReporter which prints out numeric data at regular intervals in tabular form
Thallium
ThermostatThis is a feedback-controlled force that uses Nose'-Hoover chains to maintain a particular temperature Tb, as though the system were immersed in an infinite heat bath at that temperature
Thorium
ThreadLocal< T >This class represents a "thread local" variable: one which has a different value on each thread
ThreePrimeRnaHydroxylGroupPhosphate group at 3' end (beginning) of RNA
ThreePrimeRnaPhosphateGroupPhosphate group at 3' end (end) of RNA
Threonine
Thulium
TimeStepperThis class uses an Integrator to advance a System through time
Tin
Titanium
TransformThis class represents the rotate-and-shift transform which gives the location and orientation of a new frame F in a base (reference) frame B
TransformAndResidual
TranslationThree translational mobilities
TransposeView
TriangleMeshThis ContactGeometry subclass represents an arbitrary shape described by a mesh of triangular faces
TriangleMeshContactThis subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh
TriangleMeshContactImplThis is the internal implementation class for TriangleMeshContact
TriangleMeshImpl
TriangleMeshTriangleMeshThis algorithm detects contacts between two ContactGeometry::TriangleMesh objects
TriangularThis is the default commitment for a triangular matrix
TriggeredEventHandlerTriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system
TriggeredEventReporterTriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system
TrivalentAtomBase class for atoms having exactly three covalent bonds
Tryptophan
Tungsten
TwoNMethylGuanidineGroup
TwoNMethylGuanineBaseGroup
TwoNMethylGuanylate
TwoPointConstantForceA constant force f (a signed scalar) which acts along the line between two points, specified as a station on each of two bodies
TwoPointLinearDamperA force which resists changes in the distance between two points, acting along the line between those points
TwoPointLinearSpringA linear spring between two points, specified as a station on each of two bodies
Tyrosine
UndefinedAminoAcidResidue
UndefinedPdbChainId
UniformThis is a subclass of Random that generates numbers uniformly distributed within a specified range
UniformGravityA uniform gravitational force applied to every body in the system
UnimplementedVirtualMethod
UnitRow< S >This type is used for the transpose of UnitVec, and as the returned row type of a Rotation
UnitVec< S >This class is a Vec3 plus an ironclad guarantee either that:

  • the length is one (to within a very small tolerance), or
  • all components are NaN
UnivalentAtomBase class for atoms with exaclty one covalent bond partner
UniversalTwo mobilities -- rotation about the x axis, followed by a rotation about the new y axis
UnrecognizedParameter
Ununbium
Ununhexium
Ununpentium
Ununquadium
Ununtrium
UracilBase
Uranium
Uridylate
UserFunction< T >
Valine
Value< T >Templatized version of the abstract class, providing generic type-specific functionality that does not require specialization, with automatic conversion to the underlying type
ValueOutOfRange
ValueWasNegative
Vanadium
VanDerWaalsForce
VanderWallSphere
VdwAtom
Vec< M, ELT, STRIDE >Generic Vec
Vec3PairMatched pair of 3D vectors to be used in least-squares superposition
VectorPredefined MatrixCharacter for an ordinary column vector of a particular size
VectorThis is the default commitment for a column vector
Vector_< ELT >This is the Vector class intended to appear in user code
VectorBase< ELT >This is a dataless rehash of the MatrixBase class to specialize it for Vectors
VectorIterator< ELT, VECTOR_CLASS >This is an iterator for iterating over the elements of a Vector
VectorView_< ELT >This class is identical to a Vector_; it is used only to manage the C++ rules for when copy constructors are called by introducing a separate type to prevent certain allowed optimizations from occuring when we don't want them
VelocityRescalingThermostatThis is an event handler that acts as a thermostat for controlling the temperature of a simulation efficiently, and in a qualitatively reasonable manner although not with the correct statistical temperature distribution
VerletIntegratorThis is an Integrator based on the velocity Verlet algorithm
Vertex
VmdConnection
VmdFloat3
VoxelHash< T >
VoxelIndex
VTKEventReporterThis is an EventReporter that makes it easy to generate on-screen movies of any simulation
VTKVisualizer
WallSphere
Water
WaterDroplet
WeldZero mobilities
WeldSix constraint equations
Wider< R1, R2 >
Wider< double, double >
Wider< double, float >
Wider< double, long double >
Wider< float, double >
Wider< float, float >
Wider< float, long double >
Wider< long double, double >
Wider< long double, float >
Wider< long double, long double >
Widest< R1, R2 >This class is specialized for all 36 combinations of standard types (that is, real and complex types in each of three precisions) and has typedefs "Type" which is the appropriate "widened" type for use when R1 & R2 appear in an operation together, and "Precision" which is the wider precision (float,double,long double)
Widest< complex< R1 >, complex< R2 > >
Widest< complex< R1 >, R2 >
Widest< double, double >
Widest< double, float >
Widest< double, long double >
Widest< float, double >
Widest< float, float >
Widest< float, long double >
Widest< long double, double >
Widest< long double, float >
Widest< long double, long double >
Widest< R1, complex< R2 > >
XCoordinateAxis
Xenon
XTypeAxis
YCoordinateAxis
Ytterbium
Yttrium
YTypeAxis
ZCoordinateAxis
ZeroFunctionFunction f(x) = 0 for all x
ZeroLeadingCoefficientThis is an exception which is thrown by all of the PolynomialRootFinder::findRoots() methods
Zinc
ZincIonZn2+ zinc ion with +2 charge
Zirconium
ZTypeAxis

Generated on Wed Dec 30 11:05:08 2009 for SimTKcore by  doxygen 1.6.1