| _DlsMat | |
| _FUserData | |
| _generic_N_Vector | |
| _generic_N_Vector_Ops | |
| _N_VectorContent_Parallel | |
| _N_VectorContent_Serial | |
| _SpgmrMemRec | |
| AbstractValue | Abstract base class representing an arbitrary value of self-describing type |
| AcetylResidue | Widely used acetyl protein N-terminal end cap |
| AdaptiveMuUpdate | Non-monotone mu update |
| AdenineBase | |
| AlcoholOHGroup | AlcoholOHGroup is OH group for attachment to aliphatic carbon |
| AlgorithmBuilder | Builder to create a complete IpoptAlg object |
| AlgorithmStrategyObject | This is the base class for all algorithm strategy objects |
| AliphaticCarbon | AliphaticCarbon is a tetrahedral sp3 carbon atom for bonding to four other things |
| AliphaticHydrogen | AliphaticHydrogen is a hydrogen atom for bonding to AliphaticCarbon atoms (see below) |
| Amber99ForceSubsystem | |
| AminoAcidResidue | Amino acid residue building block for protein polypeptide chain molecules |
| AminoAcidResidue::Alanine | |
| AminoAcidResidue::Arginine | |
| AminoAcidResidue::Asparagine | |
| AminoAcidResidue::Aspartate | |
| AminoAcidResidue::Cysteine | |
| AminoAcidResidue::Glutamate | |
| AminoAcidResidue::Glutamine | |
| AminoAcidResidue::Glycine | |
| AminoAcidResidue::Histidine | |
| AminoAcidResidue::Isoleucine | |
| AminoAcidResidue::Leucine | |
| AminoAcidResidue::Lysine | |
| AminoAcidResidue::Methionine | |
| AminoAcidResidue::Phenylalanine | |
| AminoAcidResidue::Proline | |
| AminoAcidResidue::Serine | |
| AminoAcidResidue::Threonine | |
| AminoAcidResidue::Tryptophan | |
| AminoAcidResidue::Tyrosine | |
| AminoAcidResidue::Valine | |
| AnalyticBrick | This is a rectangular solid |
| AnalyticCircle | An analytic circle has only a radius |
| AnalyticCurve | |
| AnalyticCylinder | The 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 |
| AnalyticGeometry | This abstract class represents a piece of high-quality geometry that can be used for valid physical simulation |
| AnalyticLine | An analytic line has only a length |
| AnalyticSphere | |
| AnalyticSurface | |
| AnalyticVolume | |
| APIArgcheckFailed | |
| Argon | The noble gas argon, which does not bond with other atoms |
| AromaticSixMemberedCHGroup | Two atom C-H group in six membered aromatic rings |
| Array | Container class like std::vector<T> but with hidden implementation |
| ArrayBase | |
| ArrayHelper | Non-templatized helper class for ArrayBase<T> |
| ArrayView | This class is a duplicate of Array and can be cast to an Array with no harm |
| Assert | |
| AtomicInteger | This class functions exactly like an int, except that the following operators are atomic: ++, --, +=, -=, *=, /=, =, &=, |=, ^=, <<=, and >>= |
| AugRestoSystemSolver | Class that converts the an augmented system with compound restoration pieces into a smaller "pivoted" system to be solved with an existing AugSystemSolver |
| AugSystemSolver | Base class for Solver for the augmented system |
| BacktrackingLineSearch | General implementation of a backtracking line search |
| BacktrackingLSAcceptor | Base class for backtracking line search acceptors |
| Base | |
| BetaBranchedAminoAcidResidue | |
| BetaUnbranchedAminoAcidResidue | |
| Biopolymer | The base class for DNA, RNA, and Protein molecules |
| BiopolymerResidue | |
| Biotype | |
| BivalentAtom | Base class for atoms having exactly two covalent bonds |
| Body | |
| Body::Ground | |
| Body::Linear | |
| Body::Massless | |
| Body::Rigid | |
| CachedResults | Cache Priority Enum |
| CacheEntry | |
| CalciumIon | Ca2+ calcium ion with +2 charge |
| Cant | |
| CarboxylateGroup | CaboxylateGroup is COO- for attachment to tetrahedral carbon |
| CesiumIon | Cs+ cesium ion with +1 charge |
| ChlorideIon | Cl- chloride ion with -1 charge |
| Clonable | |
| CNT | Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them |
| CNT::Result | |
| CNT::Substitute | |
| CNT< complex< R > > | Specializations of CNT for numeric types |
| CNT< conjugate< R > > | |
| CNT< double > | |
| CNT< float > | |
| CNT< long double > | |
| CollisionDetectionAlgorithm | A CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them |
| CollisionDetectionAlgorithm::HalfSpaceSphere | This algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Sphere |
| CollisionDetectionAlgorithm::HalfSpaceTriangleMesh | This algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::TriangleMesh |
| CollisionDetectionAlgorithm::SphereSphere | This algorithm detects contacts between two ContactGeometry::Sphere objects |
| CollisionDetectionAlgorithm::SphereTriangleMesh | This algorithm detects contacts between a ContactGeometry::Sphere and a ContactGeometry::TriangleMesh |
| CollisionDetectionAlgorithm::TriangleMeshTriangleMesh | This algorithm detects contacts between two ContactGeometry::TriangleMesh objects |
| Compound | The base class for atoms, molecules, and chemical groups |
| Compound::SingleAtom | Base class for single-atom Compound building blocks |
| CompoundMatrix | Class for Matrices consisting of other matrices |
| CompoundMatrixSpace | This is the matrix space for CompoundMatrix |
| CompoundSymMatrix | Class for symmetric matrices consisting of other matrices |
| CompoundSymMatrixSpace | This is the matrix space for CompoundSymMatrix |
| CompoundSystem | Derived class of MolecularMechanicsSystem that knows how to model molmodel Compounds |
| CompoundVector | Class of Vectors consisting of other vectors |
| CompoundVectorSpace | This vectors space is the vector space for CompoundVector |
| Concretize | Wrap a pointer to an abstract base class in a way that makes it behave like a concrete class (sometimes called a "ClonePtr") |
| conjugate | SimTK::conjugate<R> should be instantiated only for float, double, long double |
| conjugate< double > | |
| conjugate< float > | |
| conjugate< long double > | |
| Constraint | This is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation |
| Constraint::Ball | Three constraint equations |
| Constraint::ConstantAngle | One constraint equation |
| Constraint::ConstantOrientation | Three constraint equations |
| Constraint::ConstantSpeed | One non-holonomic constraint equation |
| Constraint::CoordinateCoupler | This is a subclass of Constraint::Custom which uses a Function object to define a holonomic (position) constraint |
| Constraint::Custom | The handle class Constraint::Custom (dataless) and its companion class Constraint::Custom::Implementation can be used together to define new Constraint types with arbitrary properties |
| Constraint::Custom::Implementation | |
| Constraint::NoSlip1D | One non-holonomic constraint equation |
| Constraint::PointInPlane | One constraint equation |
| Constraint::PointOnLine | Two constraint equations |
| Constraint::PrescribedMotion | This is a subclass of Constraint::Custom which uses a Function to prescribe the behavior of a single generalized coordinate as a function of time |
| Constraint::Rod | One constraint equation |
| Constraint::SpeedCoupler | This is a subclass of Constraint::Custom which uses a Function object to define a nonholonomic (velocity) constraint |
| Constraint::Weld | Six constraint equations |
| Contact | A Contact contains information about two bodies that are in contact with each other |
| ContactGeometry | A ContactGeometry object describes the physical shape of a body |
| ContactGeometry::HalfSpace | This ContactGeometry subclass represents an object that occupies the entire half-space x>0 |
| ContactGeometry::HalfSpaceImpl | |
| ContactGeometry::Sphere | This ContactGeometry subclass represents a sphere centered at the origin |
| ContactGeometry::SphereImpl | |
| ContactGeometry::TriangleMesh | This ContactGeometry subclass represents an arbitrary shape described by a mesh of triangular faces |
| ContactGeometry::TriangleMesh::OBBTreeNode | This class represents a node in the Oriented Bounding Box Tree for a TriangleMesh |
| ContactGeometry::TriangleMeshImpl | |
| ContactGeometry::TriangleMeshImpl::Edge | |
| ContactGeometry::TriangleMeshImpl::Face | |
| ContactGeometry::TriangleMeshImpl::Vertex | |
| ContactGeometryImpl | |
| ContactImpl | This is the internal implementation class for Contact |
| ConvergedFailed | |
| ConvergenceCheck | Base class for checking the algorithm termination criteria |
| CoordinateAxis | |
| CoordinateAxis::XCoordinateAxis | |
| CoordinateAxis::XTypeAxis | |
| CoordinateAxis::YCoordinateAxis | |
| CoordinateAxis::YTypeAxis | |
| CoordinateAxis::ZCoordinateAxis | |
| CoordinateAxis::ZTypeAxis | |
| CPodes | This is a straightforward translation of the Sundials CPODES C interface into C++ |
| CPodesIntegrator | This is an Integrator based on the CPODES library |
| CPodesMultibodySystem | |
| CPodesSystem | This abstract class defines the system to be integrated with SimTK CPodes |
| Cubic | |
| CVadjCheckPointRec | |
| CytosineBase | |
| DecorationSubsystem | This is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem |
| DecorativeBrick | This defines a rectangular solid centered at the origin and aligned with the local frame axes |
| DecorativeCircle | This defines a circle in the x-y plane, centered at the origin |
| DecorativeCylinder | This defines a cylinder centered on the origin and aligned in the y direction |
| DecorativeEllipsoid | This defines an ellipsoidal solid centered at the origin and aligned with the local frame axes |
| DecorativeFrame | This defines geometry to represent a coordinate frame |
| DecorativeGeometry | This is an abstract handle class using the PIMPL design pattern to hide the private implementation |
| DecorativeGeometryImplementation | Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above |
| DecorativeLine | A line between two points |
| DecorativeMesh | This defines a polygonal mesh |
| DecorativeSphere | This defines a sphere centered at the origin |
| DecorativeText | This defines a text label with its base at the origin |
| DefaultIterateInitializer | Class implementing the default initialization procedure (based on user options) for the iterates |
| DefaultSystemSubsystem | This is a concrete Subsystem that is part of every System |
| DenseGenMatrix | Class for dense general matrices |
| DenseGenMatrixSpace | This is the matrix space for DenseGenMatrix |
| DenseSymMatrix | Class for dense symetrix matrices |
| DenseSymMatrixSpace | This is the matrix space for DenseSymMatrix |
| DenseVector | Dense Vector Implementation |
| DenseVectorSpace | This vectors space is the vector space for DenseVector |
| DependentResult | Templated class which stores one entry for the CachedResult class |
| DiagMatrix | Class for diagonal matrices |
| DiagMatrixSpace | This is the matrix space for DiagMatrix |
| Differentiator | Given a function f(y), where f, y or both can be vectors, calculate the derivative (gradient, Jacobian) df/dy |
| Differentiator::Function | This abstract class defines a function to be differentiated (repeatedly) by a Differentiator object |
| Differentiator::GradientFunction | Derive a concrete class from this one if you have a scalar function of multiple variables that you want to differentiate |
| Differentiator::JacobianFunction | Derive 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 |
| Differentiator::ScalarFunction | Derive a concrete class from this one if you have a scalar function of a single scalar variable that you want to differentiate |
| DuMMForceFieldSubsystem | This is a concrete subsystem that provides basic molecular mechanics functionality FOR DEMO AND PROOF OF CONCEPT only!!! It is not likely to perform well on anything |
| DuplicatePdbResidue | |
| Eigen | Class to compute Eigen values and Eigen vectors of a matrix |
| ElasticFoundationForce | |
| Element | |
| Element::Actinium | |
| Element::Aluminum | |
| Element::Americium | |
| Element::Antimony | |
| Element::Argon | |
| Element::Arsenic | |
| Element::Astatine | |
| Element::Barium | |
| Element::Berkelium | |
| Element::Beryllium | |
| Element::Bismuth | |
| Element::Bohrium | |
| Element::Boron | |
| Element::Bromine | |
| Element::Cadmium | |
| Element::Calcium | |
| Element::Californium | |
| Element::Carbon | |
| Element::Cerium | |
| Element::Cesium | |
| Element::Chlorine | |
| Element::Chromium | |
| Element::Cobalt | |
| Element::Copper | |
| Element::Curium | |
| Element::Darmstadtium | |
| Element::Deuterium | |
| Element::Dubnium | |
| Element::Dysprosium | |
| Element::Einsteinium | |
| Element::Erbium | |
| Element::Europium | |
| Element::Fermium | |
| Element::Fluorine | |
| Element::Francium | |
| Element::Gadolinium | |
| Element::Gallium | |
| Element::Germanium | |
| Element::Gold | |
| Element::Hafnium | |
| Element::Hassium | |
| Element::Helium | |
| Element::Holmium | |
| Element::Hydrogen | |
| Element::Indium | |
| Element::Iodine | |
| Element::Iridium | |
| Element::Iron | |
| Element::Krypton | |
| Element::Lanthanum | |
| Element::Lawrencium | |
| Element::Lead | |
| Element::Lithium | |
| Element::Lutetium | |
| Element::Magnesium | |
| Element::Manganese | |
| Element::Meitnerium | |
| Element::Mendelevium | |
| Element::Mercury | |
| Element::Molybdenum | |
| Element::Neodymium | |
| Element::Neon | |
| Element::Neptunium | |
| Element::Nickel | |
| Element::Niobium | |
| Element::Nitrogen | |
| Element::Nobelium | |
| Element::Osmium | |
| Element::Oxygen | |
| Element::Palladium | |
| Element::Phosphorus | |
| Element::Platinum | |
| Element::Plutonium | |
| Element::Polonium | |
| Element::Potassium | |
| Element::Praseodymium | |
| Element::Promethium | |
| Element::Protactinium | |
| Element::Radium | |
| Element::Radon | |
| Element::Rhenium | |
| Element::Rhodium | |
| Element::Roentgenium | |
| Element::Rubidium | |
| Element::Ruthenium | |
| Element::Rutherfordium | |
| Element::Samarium | |
| Element::Scandium | |
| Element::Seaborgium | |
| Element::Selenium | |
| Element::Silicon | |
| Element::Silver | |
| Element::Sodium | |
| Element::Strontium | |
| Element::Sulfur | |
| Element::Tantalum | |
| Element::Technetium | |
| Element::Tellurium | |
| Element::Terbium | |
| Element::Thallium | |
| Element::Thorium | |
| Element::Thulium | |
| Element::Tin | |
| Element::Titanium | |
| Element::Tungsten | |
| Element::Ununbium | |
| Element::Ununhexium | |
| Element::Ununpentium | |
| Element::Ununquadium | |
| Element::Ununtrium | |
| Element::Uranium | |
| Element::Vanadium | |
| Element::Xenon | |
| Element::Ytterbium | |
| Element::Yttrium | |
| Element::Zinc | |
| Element::Zirconium | |
| Enumeration | This class defines an enumerated type |
| Enumeration::iterator | This class provides an interface for iterating over the set of all possible enumerated values |
| EnumerationSet | This class provides an efficient implementation of a set for storing values of an enumerated type defined with Enumeration |
| EnumerationSet::EnumerationSetRep | This class is the internal implementation of EnumerationSet |
| EnumerationSet::iterator | This class provides an interface for iterating over the content of an EnumerationSet |
| EqMultiplierCalculator | Base Class for objects that compute estimates for the equality constraint multipliers y_c and y_d |
| Ethane | The small hydrocarbon ethane, C2H6, which has a single torsion degree of freedom |
| EventHandler | An EventHandler is an object that defines an event that can occur within a system |
| EventReporter | An EventReporter is an object that defines an event that can occur within a system |
| EventStatus | |
| ExactHessianUpdater | Implementation of the HessianUpdater for the use of exact second derivatives |
| ExpansionMatrix | Class for expansion/projection matrices |
| ExpansionMatrixSpace | This is the matrix space for ExpansionMatrix |
| ExplicitEulerIntegrator | This is an Integrator based on the explicit Euler algorithm |
| Factor | Abstract class for performing matrix factorizations |
| FactorLU | Class for performing LU matrix factorizations |
| FactorQTZ | Class to perform a QTZ (linear least squares) factorization |
| FactorSVD | Class to compute a singular value decomposition of a matrix |
| FileJournal | FileJournal class |
| Filter | Class for the filter |
| FilterEntry | Class for one filter entry |
| FilterLSAcceptor | Filter line search |
| FivePrimeRnaHydroxylGroup | Phosphate group at 5' end (beginning) of RNA |
| FivePrimeRnaPhosphateGroup | Phosphate group at 5' end (beginning) of RNA |
| Force | A Force object applies forces to the bodies in a system |
| Force::ConstantForce | A constant force applied to a body station |
| Force::ConstantTorque | A constant torque to a body |
| Force::Custom | This class can be used to define new forces |
| Force::Custom::Implementation | |
| Force::GlobalDamper | A general energy "drain" on the system |
| Force::MobilityConstantForce | A constant (scalar) "force" f applied to a mobility |
| Force::MobilityLinearDamper | A linear damper on a mobility coordinate |
| Force::MobilityLinearSpring | A linear spring along or around a mobility coordinate |
| Force::TwoPointConstantForce | A constant force f (a signed scalar) which acts along the line between two points, specified as a station on each of two bodies |
| Force::TwoPointLinearDamper | A force which resists changes in the distance between two points, acting along the line between those points |
| Force::TwoPointLinearSpring | A linear spring between two points, specified as a station on each of two bodies |
| Force::UniformGravity | A uniform gravitational force applied to every body in the system |
| ForceSubsystem | This is logically an abstract class, more specialized than "Subsystem" but not yet concrete |
| ForceSubsystem::Guts | Public declaration of internals for ForceSubsystem extension |
| Function | This abstract class represents a mathematical function that calculates an N component vector based on M real arguments |
| Function::Constant | This is a Function subclass which simply returns a fixed value, independent of its arguments |
| Function::Linear | This is a Function subclass whose output value is a linear function of its arguments: f(x, y, |
| Function::Polynomial | This is a Function subclass whose output value is a polynomial of its argument: f(x) = ax^n+bx^(n-1)+ |
| GCVSPLUtil | This class provides entry points for using the GCVSPL algorithm in terms of SimTK data types |
| GeneralContactSubsystem | This class performs collision detection for use in contact modeling |
| GeneralForceSubsystem | This is a concrete subsystem which can apply arbitrary forces to a MultibodySystem |
| GenericScalarFunc | |
| GenTMatrix | Class for general matrices stored in triplet format |
| GenTMatrixSpace | This is the matrix space for a GenTMatrix with fixed sparsity structure |
| GradientScaling | This class does problem scaling by setting the scaling parameters based on the maximum of the gradient at the user provided initial point |
| GrinPointer | |
| GuanineBase | |
| HessianUpdater | Abstract base class for objects responsible for updating the Hessian information |
| HNAminoAcidResidue | AminoAcidResidue differs from HNAminoAcidResidue in lacking "HN" proton, so Proline can be derived |
| HuntCrossleyContact | This is a concrete subsystem that handles simple, frictionless contact situations with a model due to Hunt & Crossley: K |
| HuntCrossleyForce | |
| IdentityMatrix | Class for Matrices which are multiples of the identity matrix |
| IdentityMatrixSpace | This is the matrix space for IdentityMatrix |
| IllegalLapackArg | |
| IMDEnergies | |
| IncompatibleValues | |
| IncorrectArrayLength | |
| IndexOutOfRange | |
| Inertia | The physical meaning of an inertia is the distribution of a rigid body's mass about a *particular* point |
| Integrator | An 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 |
| InverseTransform | Transform from frame B to frame F, but with the internal representation inverted |
| IpoptAlgorithm | The main ipopt algorithm class |
| IpoptApplication | This is the main application class for making calls to Ipopt |
| IpoptCalculatedQuantities | Class for all IPOPT specific calculated quantities |
| IpoptData | Class to organize all the data required by the algorithm |
| IpoptException | This is the base class for all exceptions |
| IpoptNLP | This is the abstract base class for classes that map the traditional NLP into something that is more useful by Ipopt |
| IpoptProblemInfo | |
| IterateInitializer | Base class for all methods for initializing the iterates |
| IteratesVector | Specialized CompoundVector class specifically for the algorithm iterates |
| IteratesVectorSpace | Vector Space for the IteratesVector class |
| IterationOutput | Base class for objects that do the output summary per iteration |
| Journal | Journal class (part of the Journalist implementation |
| Journalist | Class responsible for all message output |
| Kabsch78 | |
| Lapack | |
| LapackSolverInterface | Interface to the linear solver Lapack, derived from SparseSymLinearSolverInterface |
| LeastSquareMultipliers | Class for calculator for the least-square equality constraint multipliers |
| LigandDroplet | |
| LimMemQuasiNewtonUpdater | Implementation of the HessianUpdater for limit-memory quasi-Newton approximation of the Lagrangian Hessian |
| LineSearch | Base class for line search objects |
| List | Container class with hidden implementation |
| ListBase | |
| ListBase< T * > | |
| ListView | ListView is a 'dummy' class which is completely interchangeable with List |
| LithiumIon | Li+ lithium ion with +1 charge |
| LocalEnergyMinimizer | This class performs local energy minimization of a MultibodySystem |
| LoqoMuOracle | Implementation of the LOQO formula for computing the barrier parameter |
| LowRankAugSystemSolver | Solver for the augmented system with LowRankUpdateSymMatrix Hessian matrices |
| LowRankUpdateSymMatrix | Class for symmetric matrices, represented as low-rank updates |
| LowRankUpdateSymMatrixSpace | This is the matrix space for LowRankUpdateSymMatrix |
| MagnesiumIon | Mg2+ magnesium ion with +2 charge |
| MassProperties | This class contains the mass, center of mass, and inertia of a rigid body B |
| Mat | CS is total spacing between columns in memory (default M) RS is total spacing between rows in memory (default 1) |
| Mat::EltResult | |
| Mat::Result | |
| Mat::SubMat | |
| Mat::Substitute | |
| Matrix | Matrix Base Class |
| Matrix_ | This is the class intended to appear in user code |
| MatrixBase | Variable-size 2d matrix of Composite Numerical Type (ELT) elements |
| MatrixBase::EltResult | |
| MatrixCondition | |
| MatrixConditions | |
| MatrixHelper | |
| MatrixHelper::DeepCopy | |
| MatrixHelper::DiagonalView | |
| MatrixHelper::ShallowCopy | |
| MatrixHelper::TransposeView | |
| MatrixShape | |
| MatrixShapes | |
| MatrixSize | |
| MatrixSpace | MatrixSpace base class, corresponding to the Matrix base class |
| MatrixSparseFormats | |
| MatrixSparsity | |
| MatrixStorage | |
| MatrixStorageFormats | |
| MatrixStructure | |
| MatrixStructures | Class of enums used to communicate various attributes of matrices that affect which alogrithms are used for factoring, solving etc |
| MatrixView_ | 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 |
| MechanicalDAEIntegrator | This interface is to be implemented whenever you want to treat your mechanical system as a DAE to be solved with coordinate projection |
| Methane | The simplest hydrocarbon methane, CH4 |
| MethyleneGroup | MethyleneGroup is -CH2- group for bonding to aliphatic carbon and a second something |
| MethylGroup | MethylGroup is CH3 for attaching to aliphatic carbon |
| MinC_1NrmRestorationPhase | Restoration Phase that minimizes the 1-norm of the constraint violation - using the interior point method (Ipopt) |
| MobilizedBody | This is the base class for all MobilizedBody classes, just a handle for the underlying hidden implementation |
| MobilizedBody::Ball | Three mobilities -- unrestricted orientation modeled with a quaternion which is never singular |
| MobilizedBody::BendStretch | Two 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) |
| MobilizedBody::Custom | The handle class MobilizedBody::Custom (dataless) and its companion class MobilizedBody::Custom::Implementation can be used together to define new MobilizedBody types with arbitrary properties |
| MobilizedBody::Custom::Implementation | |
| MobilizedBody::Cylinder | Two mobilities -- rotation and translation along the common z axis of the inboard and outboard mobilizer frames |
| MobilizedBody::Ellipsoid | Three mobilities -- coordinated rotation and translation along the surface of an ellipsoid fixed to the parent (inboard) body |
| MobilizedBody::Free | Unrestricted motion for a rigid body (six mobilities) |
| MobilizedBody::FreeLine | Five mobilities, representing unrestricted motion for a body which is inertialess along its own z axis |
| MobilizedBody::FunctionBased | This is a subclass of MobilizedBody::Custom which uses a set of Function objects to define the behavior of the MobilizedBody |
| MobilizedBody::Gimbal | Three mobilities -- unrestricted orientation modeled as a 1-2-3 body-fixed Euler angle sequence |
| MobilizedBody::Ground | This is a special type of "mobilized" body used as a placeholder for Ground in the 0th slot for a MatterSubsystem's mobilized bodies |
| MobilizedBody::LineOrientation | Two mobilities, representing unrestricted orientation for a body which is inertialess along its own z axis |
| MobilizedBody::Pin | One mobility -- rotation about the common z axis of the inboard and outboard mobilizer frames |
| MobilizedBody::Planar | Three mobilities -- z rotation and x,y translation |
| MobilizedBody::Screw | One mobility -- coordinated rotation and translation along the common z axis of the inboard and outboard mobilizer frames |
| MobilizedBody::Slider | One mobility -- translation along the common x axis of the inboard and outboard mobilizer frames |
| MobilizedBody::Translation | Three translational mobilities |
| MobilizedBody::Universal | Two mobilities -- rotation about the x axis, followed by a rotation about the new y axis |
| MobilizedBody::Weld | Zero mobilities |
| MolecularMechanicsSystem | This is a particular kind of MultibodySystem, one intended for use in moleular mechanics (MM) |
| Molecule | Base class for complete covalently connected molecules |
| MonotoneMuUpdate | Monotone Mu Update |
| MultibodyDynamicsStudy | |
| MultibodySystem | The job of the MultibodySystem class is to coordinate the activities of various subsystems which can be part of a multibody system |
| MultiVectorMatrix | Class for Matrices with few columns that consists of Vectors |
| MultiVectorMatrixSpace | This is the matrix space for MultiVectorMatrix |
| MuOracle | Abstract Base Class for classes that are able to compute a suggested value of the barrier parameter that can be used as an oracle in the NonmontoneMuUpdate class |
| MuUpdate | Abstract Base Class for classes that implement methods for computing the barrier and fraction-to-the-boundary rule parameter for the current iteration |
| MyObjectiveFunc | |
| MyVectorFunc | |
| N_Vector_Ops_SimTK | |
| N_Vector_SimTK | |
| N_VectorContent_SimTK | |
| negator | 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 |
| negator::Result | |
| negator::Substitute | |
| NLP | Brief Class Description |
| NLPScalingObject | This is the abstract base class for problem scaling |
| NMethylAmideResidue | Neutral C-terminal protein cap |
| NoNLPScalingObject | Class implementing the scaling object that doesn't to any scaling |
| NotPositiveDefinite | |
| NTraits | |
| NTraits< complex< R > > | Partial specialization for complex numbers -- underlying real R is still a template parameter |
| NTraits< complex< R > >::Result | |
| NTraits< complex< R > >::Substitute | |
| NTraits< conjugate< R > > | |
| NTraits< conjugate< R > >::Result | |
| NTraits< conjugate< R > >::Substitute | |
| OBBTreeNodeImpl | |
| ObservedPointFitter | This class attempts to find the configuration of an internal coordinate model which best fits a set of observed data |
| Observer | Slight Variation of the Observer Design Pattern |
| OLDCPodesIntegrator | |
| OLDExplicitEuler | |
| OLDRungeKuttaMerson | |
| OperationNotAllowedOnNonconstReadOnlyView | |
| OperationNotAllowedOnOwner | |
| OperationNotAllowedOnView | |
| OptimalityErrorConvergenceCheck | Brief Class Description |
| Optimizer | API for Simmath's optimizers |
| OptimizerFailed | |
| OptimizerSystem | Abstract class which defines an objective/cost function which is optimized by and Optimizer object |
| OptionsList | This class stores a list of user set options |
| OrientedBoundingBox | This class represents a rectangular box with arbitrary position and orientation |
| OrigIpoptNLP | This class maps the traditional NLP into something that is more useful by Ipopt |
| OrigIterationOutput | Class for the iteration summary output for the original NLP |
| P12 | |
| Parallel2DExecutor | This class is used for performing multithreaded computations over two dimensional ranges |
| Parallel2DExecutor::Task | Concrete subclasses of this abstract class represent tasks that can be executed by a Parallel2DExecutor |
| ParallelExecutor | This class is used for performing multithreaded computations |
| ParallelExecutor::Task | Concrete subclasses of this abstract class represent tasks that can be executed by a ParallelExecutor |
| PbData | |
| PdbAtom | One atom, which may have more than one location, in the case of static or dynamic disorder in an X-ray structure |
| PdbAtomLocation | Location information for a PdbAtom, corresponding to one altLoc for a PdbAtom |
| PdbChain | One molecule in a PDB structure |
| PdbModel | PDB 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 |
| PDBReader | This class parses PDB files, then constructs Systems and States based on them for use in Simbody |
| PdbResidue | One residue in a protein or nucleic acid, or a single molecule in the case of non-polymer structures |
| PdbResidueId | Composite key for residue within a chain, composed of residue number and insertion code |
| PdbStructure | Complete PDB file, possibly including multiple MODELS, in the case of NMR structures or molecular dynamics trajectories |
| PDFullSpaceSolver | This is the implemetation of the Primal-Dual System, using the full space approach with a direct linear solver |
| PDPerturbationHandler | Class for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system |
| PDSystemSolver | Pure Primal Dual System Solver Base Class |
| PeriodicEventHandler | PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals |
| PeriodicEventReporter | PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals |
| PeriodicPdbWriter | Writes atomic coordinates in PDB format to a file stream at specified intervals during a simulation |
| PeriodicVmdReporter | Writes atomic coordinates in PDB format to a file stream at specified intervals during a simulation |
| PhiMatrix | |
| PhiMatrixTranspose | |
| PIMPLHandle | This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes |
| PIMPLImplementation | This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles) |
| PointContact | This subclass of Contact represents a symmetric contact centered at a single point, such as between two spheres or a sphere and a half space |
| PointContactImpl | This is the internal implementation class for PointContact |
| PolygonalMesh | This class provides a description of a mesh made of polygonal faces |
| PolynomialRootFinder | This class provides static methods for finding the roots of polynomials |
| PolynomialRootFinder::ZeroLeadingCoefficient | This is an exception which is thrown by all of the PolynomialRootFinder::findRoots() methods |
| PotassiumIon | K+ potassium ion with +1 charge |
| PreconData | |
| PrimaryAmineGroup | PrimaryAmineGroup is NH3+ for attachment to tetrahedral carbon |
| ProbingMuOracle | Implementation of the probing strategy for computing the barrier parameter |
| ProblemData | |
| ProblemSystem | |
| Propane | |
| Protein | |
| PseudorotationMobilizer | |
| PurineBaseCore | |
| PyrimidineBaseCore | |
| QuadrivalentAtom | Base class for atoms having exactly four covalent bonds |
| QualityFunctionMuOracle | Implementation of the probing strategy for computing the barrier parameter |
| Quaternion | A 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
|
| Random | This class defines the interface for pseudo-random number generators |
| Random::Gaussian | This is a subclass of Random that generates numbers according to a Gaussian distribution with a specified mean and standard deviation |
| Random::Uniform | This is a subclass of Random that generates numbers uniformly distributed within a specified range |
| RealizeCheckFailed | |
| RealizeTopologyMustBeCalledFirst | |
| ReferencedObject | ReferencedObject class |
| Referencer | Psydo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject |
| RegisteredOption | Base class for registered options |
| RegisteredOptions | Class for storing registered options |
| RestoFilterConvergenceCheck | Convergence check for the restoration phase as called by the filter |
| RestoIpoptNLP | This class maps the traditional NLP into something that is more useful by Ipopt |
| RestoIterateInitializer | Class implementing the default initialization procedure (based on user options) for the iterates |
| RestoIterationOutput | Class for the iteration summary output for the restoration phase |
| RestorationPhase | Base class for different restoration phases |
| RestoRestorationPhase | Recursive Restoration Phase for the.MinC_1NrmRestorationPhase |
| RibonucleosideResidue | |
| RibonucleotideResidue | |
| RibonucleotideResidue::Adenylate | |
| RibonucleotideResidue::Cytidylate | |
| RibonucleotideResidue::Guanylate | |
| RibonucleotideResidue::TwoNMethylGuanylate | |
| RibonucleotideResidue::Uridylate | |
| RiboseCore | |
| RiboseNu3Mobilizer | |
| RNA | |
| RnaPhosphodiesterLinkage | |
| Rotation | Mat33 that guarantees that the matrix is a legitimate 3x3 array associated with the relative orientation of two right-handed, orthogonal, unit vector bases |
| Row | Generic Row |
| Row::EltResult | |
| Row::Result | |
| Row::Substitute | |
| RowVector_ | |
| RowVectorBase | This is a dataless rehash of the MatrixBase class to specialize it for RowVectors |
| RowVectorBase::EltResult | |
| RowVectorView_ | |
| RubidiumIon | Rb+ rubidium ion with +1 charge |
| RungeKuttaFeldbergIntegrator | |
| RungeKuttaMersonIntegrator | |
| ScaledMatrix | Class for a Matrix in conjunction with its scaling factors for row and column scaling |
| ScaledMatrixSpace | This is the matrix space for ScaledMatrix |
| ScheduledEventHandler | ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance |
| ScheduledEventReporter | ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance |
| SimbodyMatterSubsystem | The Simbody low-level multibody tree interface |
| SimbodyMatterSubtree | A SimbodyMatterSubtree is a view of a connected subgraph of the tree of mobilized bodies in a SimbodyMatterSubsystem |
| SimbodyMatterSubtreeResults | |
| SingularMatrix | |
| SinOmegaX | |
| SinusoidFunction | Implements a simple functional relationship, y = amplitude * sin(x - phase) |
| SizeOutOfRange | |
| SizeWasNegative | |
| SmartPtr | Template class for Smart Pointers |
| SodiumIon | Na+ sodium ion with +1 charge |
| SolveStatistics | This class collects statistics about an optimziation run, such as iteration count, final infeasibilities etc |
| SparseSymLinearSolverInterface | Base class for interfaces to symmetric indefinite linear solvers for sparse matrices |
| SpbcgMemRec | |
| Spline | This class implements a non-uniform B-spline curve |
| Spline::SplineImpl | |
| SplineFitter | Given a set of data points, this class creates a Spline which interpolates or approximates them |
| SplineFitter::SplineFitterImpl | |
| SptfqmrMemRec | |
| StableArray | 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
|
| Stage | This class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic |
| StageIsWrong | |
| StageOutOfRange | |
| StageTooHigh | |
| StageTooLow | |
| StandardScalingBase | This is a base class for many standard scaling techniques |
| State | This is the handle class for the hidden State implementation |
| StdAugSystemSolver | Solver for the augmented system for triple type matrices |
| StdInterfaceTNLP | Implementation of a TNLP for the Standard C interface |
| String | SimTK::String is just an std::string with some additional methods defined |
| Study | The handle class which serves as the abstract parent of all Studies |
| Study::Guts | This is the declaration for the Study::Guts class, the abstract object to which a Study handle points |
| Subject | Slight Variation of the Observer Design Pattern (Subject part) |
| Subsystem | The abstract parent of all Subsystems |
| Subsystem::Guts | The abstract parent of all Subsystems |
| SumMatrix | Class for Matrices which are sum of matrices |
| SumMatrixSpace | Class for matrix space for SumMatrix |
| SumSymMatrix | Class for Matrices which are sum of symmetric matrices |
| SumSymMatrixSpace | Class for matrix space for SumSymMatrix |
| SymLinearSolver | Base class for all derived symmetric linear solvers |
| SymMat | RS is total spacing between rows in memory (default 1) |
| SymMat::EltResult | |
| SymMat::Result | |
| SymMat::Substitute | |
| SymMatrix | This is the base class for all derived symmetric matrix types |
| SymMatrixSpace | SymMatrixSpace base class, corresponding to the SymMatrix base class |
| SymScaledMatrix | Class for a Matrix in conjunction with its scaling factors for row and column scaling |
| SymScaledMatrixSpace | This is the matrix space for SymScaledMatrix |
| SymTMatrix | Class for symmetric matrices stored in triplet format |
| SymTMatrixSpace | This is the matrix space for a SymTMatrix with fixed sparsity structure |
| System::EventTriggerInfo | This class is used to communicate between the System and an Integrator regarding the properties of a particular event trigger function |
| System::Guts | This is the declaration for the System::Guts class, the abstract object to which a System handle points |
| TaggedObject | TaggedObject class |
| TextDataEventReporter | This is an EventReporter which prints out numeric data at regular intervals in tabular form |
| ThreadLocal | This class represents a "thread local" variable: one which has a different value on each thread |
| ThreePrimeRnaHydroxylGroup | Phosphate group at 3' end (beginning) of RNA |
| ThreePrimeRnaPhosphateGroup | Phosphate group at 3' end (end) of RNA |
| TimedTask | This class is used to collect timing information for a particular task |
| TimeStepper | This class uses an Integrator to advance a System through time |
| TimingStatistics | This class collects all timing statistics for Ipopt |
| TmpMatrixView_ | XXX not ready for prime time |
| TmpRowVectorView_ | XXX not ready for prime time |
| TmpVectorViewT | XXX not ready for prime time |
| TNLP | Base class for all NLP's that use standard triplet matrix form and dense vectors |
| TNLPAdapter | This class Adapts the TNLP interface so it looks like an NLP interface |
| Transform | This 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 | |
| TriangleMeshContact | This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh |
| TriangleMeshContactImpl | This is the internal implementation class for TriangleMeshContact |
| TriggeredEventHandler | TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system |
| TriggeredEventReporter | TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system |
| TripletHelper | |
| TripletToCSRConverter | Class for converting symmetric matrices given in triplet format to matrices in compressed sparse row (CSR) format of the upper triangual part (or, equivalently, compressed sparse column (CSC) format for the lower triangular part) |
| TripletToDenseConverter | Class for converting symmetric matrices given in triplet format to matrices in dense format |
| TrivalentAtom | Base class for atoms having exactly three covalent bonds |
| TSymLinearSolver | General driver for linear solvers for sparse indefinite symmetric matrices |
| TSymScalingMethod | Base class for the method for computing scaling factors for symmetric matrices in triplet format |
| TwoNMethylGuanidineGroup | |
| TwoNMethylGuanineBaseGroup | |
| UndefinedAminoAcidResidue | |
| UndefinedPdbChainId | |
| UnimplementedVirtualMethod | |
| UnitRow | This type is used for the transpose of UnitVec, and as the returned row type of a Rotation |
| UnitVec | 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
|
| UnivalentAtom | Base class for atoms with exaclty one covalent bond partner |
| UnrecognizedParameter | |
| UracilBase | |
| UserData | |
| UserFunction | |
| UserScaling | This class does problem scaling by getting scaling parameters from the user (through the NLP interface) |
| Value | A particular kind of AbstractValue, with automatic converstion to the underlying type |
| ValueHelper | Templatized version of the abstract class, providing generic type-specific functionality that does not require specialization |
| ValueOutOfRange | |
| ValueWasNegative | |
| VanderWallSphere | |
| Vec | Generic Vec |
| Vec3Pair | Matched pair of 3D vectors to be used in least-squares superposition |
| Vec::EltResult | |
| Vec::Result | |
| Vec::Substitute | |
| Vector | Vector Base Class |
| Vector_ | |
| VectorBase | This is a dataless rehash of the MatrixBase class to specialize it for Vectors |
| VectorBase::EltResult | |
| VectorIterator | This is an iterator for iterating over the elements of a matrix |
| VectorSpace | VectorSpace base class, corresponding to the Vector base class |
| VectorView_ | |
| VelocityRescalingThermostat | This is an event handler that acts as a thermostat for controlling the temperature of a simulation |
| VerletIntegrator | This is an Integrator based on the velocity Verlet algorithm |
| VmdConnection | |
| VmdFloat3 | |
| Voxel | |
| Voxel::Map | |
| VoxelIndex | |
| VTKEventReporter | This is an EventReporter that makes it easy to generate on-screen movies of any simulation |
| VTKVisualizer | |
| WarmStartIterateInitializer | Class implementing an initialization procedure for warm starts |
| Water | |
| WaterDroplet | |
| WebData | |
| Wider | |
| 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 | |
| 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 > > | |
| WritePdbReporter | |
| ZeroFunction | Function f(x) = 0 for all x |
| ZeroMatrix | Class for Matrices with only zero entries |
| ZeroMatrixSpace | Class for matrix space for ZeroMatrix |
| ZincIon | Zn2+ zinc ion with +2 charge |
