| ►NSimTK | This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols |
| ►NException | This sub-namespace of SimTK is used for the exception types that are thrown by our error handing code |
| CAPIArgcheckFailed | This is for reporting problems detected by checking the caller's supplied arguments to a SimTK API method |
| CAPIMethodFailed | |
| CAssert | This is for reporting internally-detected bugs only, not problems induced by confused users (that is, it is for confused developers instead) |
| CBase | |
| CCacheEntryOutOfDate | |
| CCant | |
| CConvergedFailed | |
| CErrorCheck | This 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 |
| CIllegalLapackArg | |
| CIncompatibleValues | |
| CIncorrectArrayLength | |
| CIndexOutOfRange | |
| CLoopConstraintConstructionFailure | |
| CMobilizerCantExactlyRepresentRequestedQuantity | |
| CNewtonRaphsonFailure | |
| CNotPositiveDefinite | |
| COperationNotAllowedOnNonconstReadOnlyView | |
| COperationNotAllowedOnOwner | |
| COperationNotAllowedOnView | |
| COptimizerFailed | |
| CRealizeCheckFailed | |
| CRealizeTopologyMustBeCalledFirst | |
| CRepLevelException | |
| CSingularMatrix | |
| CSizeOutOfRange | |
| CSizeWasNegative | |
| CStageIsWrong | |
| CStageOutOfRange | |
| CStageTooHigh | |
| CStageTooLow | |
| CStateAndSystemTopologyVersionsMustMatch | |
| CUnimplementedMethod | |
| CUnimplementedVirtualMethod | |
| CUnrecognizedParameter | |
| CValueOutOfRange | |
| CValueWasNegative | |
| ►CAbstractMeasure | This is the base class for all Measure handle classes |
| CImplementation | The abstract parent of all Measure Implementation classes |
| CSetHandle | An object of this type is used as a dummy argument to make sure the automatically-generated handle constructor's signature doesn't conflict with an explicitly-defined one |
| CAbstractValue | Abstract base class representing an arbitrary value of self-describing type |
| CAndOpType | This is an operator for and-ing compile-time truth types |
| CAndOpType< FalseType, FalseType > | |
| CAndOpType< FalseType, TrueType > | |
| CAndOpType< TrueType, FalseType > | |
| CAndOpType< TrueType, TrueType > | |
| CArray_ | The SimTK::Array_<T> container class is a plug-compatible replacement for the C++ standard template library (STL) std::vector<T> class, but with some important advantages in performance, and functionality, and binary compatibility |
| CArrayIndexTraits | This templatized type is used by the Array_<T,X> classes to obtain the information they need to use the class X as an index class for the array |
| CArrayIndexTraits< bool > | Specialization of ArrayIndexTraits for bool used as an index |
| CArrayIndexTraits< char > | Specialization of ArrayIndexTraits for char used as an index |
| CArrayIndexTraits< int > | Specialization of ArrayIndexTraits for (signed) int used as an index |
| CArrayIndexTraits< long > | Specialization of ArrayIndexTraits for (signed) long used as an index |
| CArrayIndexTraits< long long > | Specialization of ArrayIndexTraits for long long used as an index |
| CArrayIndexTraits< short > | Specialization of ArrayIndexTraits for (signed) short used as an index |
| CArrayIndexTraits< signed char > | Specialization of ArrayIndexTraits for signed char used as an index |
| CArrayIndexTraits< unsigned > | Specialization of ArrayIndexTraits for unsigned (that is, unsigned int) used as an index |
| CArrayIndexTraits< unsigned char > | Specialization of ArrayIndexTraits for unsigned char used as an index |
| CArrayIndexTraits< unsigned long > | Specialization of ArrayIndexTraits for unsigned long used as an index |
| CArrayIndexTraits< unsigned long long > | Specialization of ArrayIndexTraits for unsigned long long used as an index |
| CArrayIndexTraits< unsigned short > | Specialization of ArrayIndexTraits for unsigned short used as an index |
| CArrayView_ | This Array_ helper class is the base class for Array_, extending ArrayViewConst_ to add the ability to modify elements, but not the ability to change size or reallocate |
| CArrayViewConst_ | This Array_ helper class is the base class for ArrayView_ which is the base class for Array_; here we provide only the minimal read-only "const" functionality required by any Array_ object, and shallow copy semantics |
| CArticulatedInertia_ | An articulated body inertia (ABI) matrix P(q) contains the spatial inertia properties that a body appears to have when it is the free base body of an articulated multibody tree in a given configuration q |
| CAssembler | This Study attempts to find a configuration (set of joint coordinates q) of a Simbody MultibodySystem that satisfies the System's position Constraints plus optional additional assembly conditions |
| CAssemblyCondition | Define an assembly condition consisting of a scalar goal and/or a related set of assembly error equations (that is, an objective and/or some constraints) |
| CAtomicInteger | This class functions exactly like an int, except that the following operators are atomic: ++, –, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, and >>= |
| CBicubicFunction | This is a two-argument Function built using a shared BicubicSurface and managing current state to optimize for localized access |
| ►CBicubicSurface | This class will create a smooth surface that approximates a two-argument function F(X,Y) from a given set of samples of that function on a rectangular grid with regular or irregular spacing |
| CPatchHint | This object is used to hold precalculated data about the most recently accessed patch to accelerate the common case of repeated access to the same patch or to nearby patches |
| ►CBody | Reference frame that can be used to describe mass properties and geometry |
| CGround | This is a Body representing something immobile, of effectively infinite mass and inertia, that cannot be modified to be anything else |
| CLinear | This is a rigid body in the shape of a line, which is inherently inertialess about its axis |
| CMassless | This is a Body that is constitutively massless (and inertialess); meaning that no amount of fiddling with it will ever give it any mass or inertia |
| CRigid | A general rigid body |
| CBoundedSpeedConstraint | TODO: not implemented yet |
| CBrickHalfSpaceContact | This subclass of Contact is used when one ContactGeometry object is a half plane and the other is a Brick |
| CBrokenContact | This subclass of Contact represents a pair of contact surfaces that were in contact (meaning within cutoff range) but have now gone out of range |
| ►CCableObstacle | An obstacle is any significant object along the cable path – one of the end points, a via point, or a surface |
| CSurface | This obstacle is a solid object represented by a ContactGeometry surface |
| CViaPoint | This is a point through which the cable must pass |
| CCableObstacleIndex | This is a unique integer type for identifying obstacles comprising a particular cable path |
| CCablePath | This class represents the path of a frictionless cable from an origin point fixed to a body, through via points and over geometric obstacles fixed to other bodies, to a final termination point |
| CCablePathIndex | This is a unique integer type for quickly identifying specific cables for fast lookup purposes |
| CCableSpring | This force element implements a passive elastic element (like a rubber band) that follows a frictionless CablePath across a set of "obstacles" |
| CCableTrackerSubsystem | This subsystem tracks the paths of massless, frictionless cables that take the shortest route between two distant points of a multibody system, passing smoothly over geometric obstacles that are attached to intermediate bodies |
| CCacheEntryIndex | This unique integer type is for selecting non-shared cache entries |
| CCircularPointContact | This subclass of Contact represents a contact between two non-conforming surfaces 1 and 2 that initially meet at a point where each surface has a uniform radius of curvature in all directions (R1 and R2), like a sphere (inside or outside) or a halfspace, resulting in a contact region with circular symmetry |
| CClonePtr | Wrap a pointer to an abstract base class in a way that makes it behave like a concrete class |
| ►CCNT | Specialized information about Composite Numerical Types which allows us to define appropriate templatized classes using them |
| CResult | |
| CSubstitute | |
| CCNT< complex< R > > | Specializations of CNT for numeric types |
| CCNT< conjugate< R > > | |
| CCNT< double > | |
| CCNT< float > | |
| CCNT< long double > | |
| ►CCollisionDetectionAlgorithm | A CollisionDetectionAlgorithm implements an algorithm for detecting overlaps between pairs of ContactGeometry objects, and creating Contact objects based on them |
| CConvexConvex | This algorithm detects contacts between two ContactGeometry::Convex objects |
| CHalfSpaceEllipsoid | This algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Ellipsoid |
| CHalfSpaceSphere | This algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Sphere |
| CHalfSpaceTriangleMesh | This algorithm detects contacts between a ContactGeometry::HalfSpace and a ContactGeometry::TriangleMesh |
| CSphereSphere | This algorithm detects contacts between two ContactGeometry::Sphere objects |
| CSphereTriangleMesh | This algorithm detects contacts between a ContactGeometry::Sphere and a ContactGeometry::TriangleMesh |
| CTriangleMeshTriangleMesh | This algorithm detects contacts between two ContactGeometry::TriangleMesh objects |
| CCompliantContactSubsystem | This is a force subsystem that implements a compliant contact model to respond to Contact objects as detected by a ContactTrackerSubsystem |
| CConditionalConstraint | TODO: Simbody model element representing a conditionally-enforced constraint |
| Cconjugate | SimTK::conjugate<R> should be instantiated only for float, double, long double |
| Cconjugate< double > | |
| Cconjugate< float > | |
| Cconjugate< long double > | |
| ►CConstraint | This is the base class for all Constraint classes, which is just a handle for the underlying hidden implementation |
| CBall | Enforce that a fixed station on one body remains coincident with a fixed station on a second body, as though there were a ball joint connecting them at those points |
| CConstantAcceleration | Constrain a single mobility to have a particular acceleration |
| CConstantAngle | This constraint consists of a single constraint equation that enforces that a unit vector v1 fixed to one body (the "base body") must maintain a fixed angle theta with respect to a unit vector v2 fixed on the other body (the "follower body") |
| CConstantCoordinate | Constrain a single mobilizer coordinate q to have a particular value |
| CConstantOrientation | Three constraint equations |
| CConstantSpeed | Constrain a single mobility to have a particular speed |
| CCoordinateCoupler | This is a Constraint that uses a Function object to define a single holonomic (position) constraint equation acting to relate a set of generalized coordinates q |
| ►CCustom | 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 |
| CImplementation | This is the abstract base class for the implementation of custom constraints. See Constraint::Custom for more information |
| CLineOnLineContact | This constraint represents a bilateral connection between an edge on one body and a non-parallel edge on another |
| CNoSlip1D | One non-holonomic constraint equation |
| CPointInPlane | One constraint equation |
| CPointOnLine | Two constraint equations |
| CPointOnPlaneContact | (Advanced) This is the underlying constraint for unilateral contact with friction but must be combined with contact and friction conditions |
| CPrescribedMotion | This is a Constraint that uses a Function to prescribe the behavior of a single generalized coordinate as a function of time |
| CRod | This constraint consists of one constraint equation that enforces a constant distance between a point on one body and a point on another body |
| CSpeedCoupler | This is a Constraint that uses a Function object to define a nonholonomic (velocity) constraint |
| CSphereOnPlaneContact | This constraint represents a bilateral connection between a sphere on one body and a plane on another |
| CSphereOnSphereContact | This constraint represents a bilateral connection between a sphere on one body and a sphere on another |
| CWeld | Six constraint equations |
| CConstraintIndex | This is for arrays indexed by constraint number within a subsystem (typically the SimbodyMatterSubsystem). It is assigned when a Constraint is added to the subsystem |
| CContact | A Contact contains information about the spatial relationship between two surfaces that are near, or in contact with, each other |
| CContactDetail | This provides deformed geometry and force details for one element of a contact patch that may be composed of many elements |
| CContactForce | This is a simple class containing the basic force information for a single contact between deformable surfaces S1 and S2 mounted on rigid bodies B1 and B2 |
| ►CContactForceGenerator | A ContactForceGenerator implements an algorithm for responding to overlaps or potential overlaps between pairs of ContactSurface objects, as detected by a ContactTrackerSubsystem |
| CBrickHalfSpacePenalty | This ContactForceGenerator handles contact between a brick and a half-space |
| CDoNothing | This ContactForceGenerator silently does nothing |
| CElasticFoundation | This ContactForceGenerator handles contact between a TriangleMesh and a variety of other geometric objects, all of which produce a TriangleMeshContact tracking object |
| CHertzCircular | This ContactForceGenerator handles contact between non-conforming objects that meet at a point and generate a circular contact patch; those generate a CircularPointContact tracking object |
| CHertzElliptical | This ContactForceGenerator handles contact between non-conforming objects that meet at a point and generate an elliptical contact patch; those generate an EllipticalPointContact tracking object |
| CThrowError | This ContactForceGenerator throws an error if it is every invoked |
| ►CContactGeometry | A ContactGeometry object describes the shape of all or part of the boundary of a solid object, for the purpose of modeling with Simbody physical effects that occur at the surface of that object, such as contact and wrapping forces |
| CBrick | This ContactGeometry subclass represents a rectangular solid centered at the origin |
| CCylinder | This ContactGeometry subclass represents a cylinder centered at the origin, with radius r in the x-y plane, and infinite length along z |
| CEllipsoid | This ContactGeometry subclass represents an ellipsoid centered at the origin, with its principal axes pointing along the x, y, and z axes and half dimensions a,b, and c (all > 0) along those axes, respectively |
| CHalfSpace | This ContactGeometry subclass represents an object that occupies the entire half-space x>0 |
| CSmoothHeightMap | This ContactGeometry subclass represents a smooth surface fit through a set of sampled points using bicubic patches to provide C2 continuity |
| CSphere | This ContactGeometry subclass represents a sphere centered at the origin |
| CTorus | This ContactGeometry subclass represents a torus centered at the origin with the axial direction aligned to the z-axis |
| ►CTriangleMesh | This ContactGeometry subclass represents an arbitrary shape described by a mesh of triangular faces |
| COBBTreeNode | This class represents a node in the Oriented Bounding Box Tree for a TriangleMesh |
| CContactGeometryTypeId | This is a unique integer type for quickly identifying specific types of contact geometry for fast lookup purposes |
| CContactId | This is a unique integer Id assigned to each contact pair when we first begin to track it |
| CContactMaterial | Define the physical properties of the material from which a contact surface is made, including properties needed by a variety of contact response techniques that might be applied during contact |
| CContactPatch | A ContactPatch is the description of the forces and the deformed shape of the contact surfaces that result from compliant contact interactions |
| CContactSnapshot | Objects of this class represent collections of surface-pair interactions that are being tracked at a particular instant during a simulation |
| CContactSurface | This class combines a piece of ContactGeometry with a ContactMaterial to make an object suitable for attaching to a body which can then engage in contact behavior with other contact surfaces |
| CContactSurfaceIndex | This defines a unique index for all the contact surfaces being handled either by a ContactTrackerSubsystem or within a single ContactSet of a GeneralContactSubsystem |
| ►CContactTracker | A ContactTracker implements an algorithm for detecting overlaps or potential overlaps between pairs of ContactGeometry objects, and managing Contact objects that track individual contacts as they evolve through time |
| CConvexImplicitPair | This ContactTracker handles contacts between two smooth, convex objects by using their implicit functions |
| CGeneralImplicitPair | (TODO: not implemented yet) This ContactTracker handles contacts between two arbitrary smooth surfaces by using their implicit functions, with no shape restrictions |
| CHalfSpaceBrick | This ContactTracker handles contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Sphere, in that order |
| CHalfSpaceConvexImplicit | This ContactTracker handles contacts between a ContactGeometry::HalfSpace and any ContactGeometry that can be considered a convex, implicit surface, in that order |
| CHalfSpaceEllipsoid | This ContactTracker handles contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Ellipsoid, in that order |
| CHalfSpaceSphere | This ContactTracker handles contacts between a ContactGeometry::HalfSpace and a ContactGeometry::Sphere, in that order |
| CHalfSpaceTriangleMesh | This ContactTracker handles contacts between a ContactGeometry::HalfSpace and a ContactGeometry::TriangleMesh, in that order |
| CSphereSphere | This ContactTracker handles contacts between two ContactGeometry::Sphere objects |
| CSphereTriangleMesh | This ContactTracker handles contacts between a ContactGeometry::Sphere and a ContactGeometry::TriangleMesh, in that order |
| CTriangleMeshTriangleMesh | This ContactTracker handles contacts between two ContactGeometry::TriangleMesh surfaces |
| CContactTrackerSubsystem | This subsystem identifies and tracks potential contacts between bodies of a multibody system, but does not generate any physical responses to those contacts |
| CContactTypeId | This is a small integer that serves as the unique typeid for each type of concrete Contact class |
| ►CCoordinateAxis | This class, along with its sister class CoordinateDirection, provides convenient manipulation of the three coordinate axes via the definition of three constants XAxis, YAxis, and ZAxis each with a unique subtype and implicit conversion to the integers 0, 1, and 2 whenever necessary. Methods are provided to allow code to be written once that can be used to work with the axes in any order |
| CXCoordinateAxis | |
| CYCoordinateAxis | |
| CZCoordinateAxis | |
| ►CCoordinateDirection | A CoordinateDirection is a CoordinateAxis plus a direction indicating the positive or negative direction along that axis |
| CNegative | Use for compile-time construction of a negative CoordinateDirection along one of the coordinate axes |
| CNegXDirection | |
| CNegYDirection | |
| CNegZDirection | |
| CCPodes | This is a straightforward translation of the Sundials CPODES C interface into C++ |
| CCPodesIntegrator | This is an Integrator based on the CPODES library |
| CCPodesSystem | This abstract class defines the system to be integrated with SimTK CPodes |
| CDecorationGenerator | A DecorationGenerator is used to define geometry that may change over the course of a simulation |
| CDecorations | This defines a single DecorativeGeometry object that is composed of a collection of other DecorativeGeometry objects |
| CDecorationSubsystem | This is the client-side handle class encapsulating the hidden implementation of the DecorationSubsystem |
| CDecorativeBrick | This defines a rectangular solid centered at the origin and aligned with the local frame axes |
| CDecorativeCircle | This defines a circle in the x-y plane, centered at the origin |
| CDecorativeCylinder | This defines a cylinder centered on the origin and aligned in the y direction |
| CDecorativeEllipsoid | This defines an ellipsoidal solid centered at the origin and aligned with the local frame axes |
| CDecorativeFrame | This defines geometry to represent a coordinate frame |
| CDecorativeGeometry | This is the client-side interface to an implementation-independent representation of "Decorations" suitable for visualization, annotation, logging, or debugging but which cannot have any effect on the behavior of a System or the evolution of a Study |
| CDecorativeGeometryImplementation | Use this abstract class to connect your implementation of decorative geometry to the implementation-independent classes above |
| CDecorativeLine | A line between two points |
| CDecorativeMesh | This defines a displayable mesh by referencing an already-existing PolygonalMesh object |
| CDecorativeMeshFile | This defines a displayable mesh by referencing a file name containing the mesh |
| CDecorativePoint | A point of interest |
| CDecorativeSphere | This defines a sphere centered at the origin |
| CDecorativeText | This defines a text label with its base at the origin |
| CDefaultOptimizer | |
| CDefaultSystemSubsystem | This is a concrete Subsystem that is part of every System. It provides a variety of services for the System, such as maintaining lists of event handlers and reporters, and acting as a source of globally unique event IDs |
| ►CDifferentiator | Given a function f(y), where f, y or both can be vectors, calculate the derivative (gradient, Jacobian) df/dy |
| CFunction | This abstract class defines a function to be differentiated (repeatedly) by a Differentiator object |
| CGradientFunction | Derive a concrete class from this one if you have a scalar function of multiple variables that you want to differentiate |
| CJacobianFunction | 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 |
| CScalarFunction | Derive a concrete class from this one if you have a scalar function of a single scalar variable that you want to differentiate |
| CDiscreteVariableIndex | This unique integer type is for selecting discrete variables |
| CDontCopy | This is a special type used for causing invocation of a particular constructor or method overload that will avoid making a copy of the source (that is, perform a "shallow" copy rather than a "deep" copy) |
| CEdgeEdgeContact | (Experimental – API will change – use at your own risk) Define an edge on each of two bodies, by providing an "edge frame" where the origin is the edge center, x axis is aligned with the edge, and z axis points in the "outward" direction away from the solid whose edge it is |
| CEigen | Class to compute Eigen values and Eigen vectors of a matrix |
| CElasticFoundationForce | This class implements an elastic foundation or "bed of springs" contact model |
| CEllipticalPointContact | This subclass of Contact represents a contact between two non-conforming surfaces 1 and 2 that initially meet at a point and where each surface has two principal curvatures (maximum and minimum) in perpendicular directions |
| ►CEvent | An Event is "something that happens" during a Study that is advancing through time |
| CCause | These are all the possible causes for events |
| CEventHandler | An EventHandler is an object that defines an event that can occur within a system |
| CEventId | This is a class to represent unique IDs for events in a type-safe way |
| CEventReporter | An EventReporter is an object that defines an event that can occur within a system |
| CEventTriggerByStageIndex | Unique integer type for Subsystem-local, per-stage event indexing |
| CEventTriggerInfo | This class is used to communicate between the System and an Integrator regarding the properties of a particular event trigger function |
| CExplicitEulerIntegrator | This is an Integrator based on the explicit Euler algorithm |
| CFactor | Base class for the various matrix factorizations |
| CFactorLU | Class for performing LU matrix factorizations |
| CFactorQTZ | Class to perform a QTZ (linear least squares) factorization |
| CFactorSVD | Class to compute a singular value decomposition of a matrix |
| CFalseType | This is a compile-time equivalent of "false", used in compile-time condition checking in templatized implementations |
| ►CForce | This is the base class from which all Force element handle classes derive |
| CConstantForce | A constant force applied to a body station |
| CConstantTorque | A constant torque to a body |
| ►CCustom | This class is used to define new force elements |
| CImplementation | Every custom force requires implementation of a class that is derived from this abstract class. See Force::Custom for details |
| CDiscreteForces | Arbitrary discrete body forces and mobility (generalized) forces. Useful for applying external forces or forces that are updated at discrete times due to the occurrence of events |
| CGlobalDamper | A general energy "drain" on the system |
| CGravity | This force element represents a uniform gravitational field applied to a set of bodies |
| CLinearBushing | This 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 |
| CMobilityConstantForce | A constant generalized force f (a scalar) applied to a mobility |
| CMobilityDiscreteForce | A discrete mobility (generalized) force f applied to a particular mobility that is specified at construction. Useful for applying external forces or forces that are updated at discrete times due to the occurrence of events |
| CMobilityLinearDamper | A linear damper that acts along or around a mobility coordinate to apply a generalized force there |
| CMobilityLinearSpring | A linear spring that acts along or around a mobility coordinate to apply a generalized force there |
| CMobilityLinearStop | Model a compliant stop element that acts to keep a mobilizer coordinate q within specified bounds |
| CThermostat | This 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 |
| CTwoPointConstantForce | A constant force f (a signed scalar) which acts along the line between two points, specified as a station on each of two bodies |
| CTwoPointLinearDamper | A force which resists changes in the distance between two points, acting along the line between those points |
| CTwoPointLinearSpring | A linear spring between two points, specified as a station on each of two bodies |
| CUniformGravity | A uniform gravitational force applied to every body in the system. See Force::Gravity for a more flexible option |
| CForceIndex | This type represents the index of a Force element within its subsystem |
| ►CForceSubsystem | This is logically an abstract class, more specialized than "Subsystem" but not yet concrete |
| CGuts | Public declaration of internals for ForceSubsystem extension |
| ►CFunction_ | This abstract class represents a mathematical function that calculates a value of arbitrary type based on M real arguments |
| CConstant | This is a Function_ subclass which simply returns a fixed value, independent of its arguments |
| CLinear | This is a Function_ subclass whose output value is a linear function of its arguments: f(x, y, ...) = ax+by+...+c |
| CPolynomial | This is a Function_ subclass whose output value is a polynomial of its argument: f(x) = ax^n+bx^(n-1)+...+c |
| CSinusoid | This is a Function_ subclass whose output value is a sinusoid of its argument: f(x) = a*sin(w*x + p) where a is amplitude, w is frequency in radians per unit of x, p is phase in radians |
| CStep | This is a Function_ subclass whose output value y=f(x) is smoothly stepped from y=y0 to y1 as its input argument goes from x=x0 to x1 |
| CGCVSPLUtil | This class provides entry points for using the GCVSPL algorithm in terms of SimTK data types |
| CGeneralContactSubsystem | This class performs collision detection for use in contact modeling |
| CGeneralForceSubsystem | This is a concrete subsystem which can apply arbitrary forces to a MultibodySystem |
| ►CGeo | Collects geometric primitives intended to deal with raw, fixed-size geometric shapes occupying minimal memory and providing maximum performance through small inline methods and larger high performance algorithms |
| CAlignedBox_ | A 3d box aligned with an unspecified frame F and centered at a given point measured from that frame's origin |
| CBicubicBezierPatch_ | A primitive useful for computations involving a single bicubic Bezier patch |
| CBicubicHermitePatch_ | A primitive useful for computations involving a single bicubic Hermite patch |
| CBox_ | A 3d rectangular box aligned with an unspecified frame F and centered at that frame's origin |
| CCircle_ | |
| CCubicBezierCurve_ | This is a primitive useful for computations involving a single cubic Bezier curve segment |
| CCubicHermiteCurve_ | A primitive useful for computations involving a single cubic Hermite curve segment in algebraic or geometric (Hermite) form |
| CLine_ | |
| CLineSeg_ | A 3d line segment primitive represented by its end points in an unspecified frame, and a collection of line segment-related utility methods |
| COrientedBox_ | TODO: A 3d box oriented and positioned with respect to an unspecified frame F |
| CPlane_ | |
| CPoint_ | A 3d point primitive represented by a Vec3 from the origin of an unspecified frame, and a collection of point-related utility methods |
| CSphere_ | A geometric primitive representing a sphere by its radius and center point, and a collection of sphere-related utility methods |
| CTriangle_ | A geometric primitive representing a triangle by its vertices as points in some unspecified frame, and a collection of triangle-related utility methods |
| CGeodesic | This class stores a geodesic curve after it has been determined |
| CGeodesicDecorator | This class generates decoration (line segments) for a geodesic curve |
| CGeodesicIntegrator | This is a stripped-down numerical integrator for small ODE or DAE problems whose size is known at compile time, with no provision for discrete variables, event detection, or interpolation |
| CGeodesicOptions | This class stores options for calculating geodesics |
| CGeodHitPlaneEvent | A event handler to terminate integration when geodesic hits the plane |
| CHandleEventsOptions | Options for the handleEvent() method |
| CHandleEventsResults | Results returned by the handleEvent() method |
| CHardStopLower | (Experimental – API will change – use at your own risk) Set a hard limit on the minimum value of a generalized coordinate q |
| CHardStopUpper | (Experimental – API will change – use at your own risk) Set a hard limit on the maximum value of a generalized coordinate q |
| CHuntCrossleyContact | This is a concrete subsystem that handles simple, frictionless contact situations with a model due to Hunt & Crossley: K |
| CHuntCrossleyForce | This class models the forces generated by simple point contacts, such as between two spheres, or a sphere and a half space |
| ►CImpulseSolver | This is the abstract base class for impulse solvers, which solve an important subproblem of the contact and impact equations |
| CBoundedRT | |
| CConstraintLtdFrictionRT | |
| CStateLtdFrictionRT | |
| CUncondRT | |
| CUniContactRT | |
| CUniSpeedRT | |
| CInertia_ | The physical meaning of an inertia is the distribution of a rigid body's mass about a particular point |
| CIntegrator | An Integrator is an object that can advance the State of a System through time |
| CInverseRotation_ | (Advanced) This InverseRotation class is the inverse of a Rotation |
| CInverseTransform_ | Transform from frame B to frame F, but with the internal representation inverted |
| CIs64BitHelper | |
| CIs64BitHelper< false > | |
| CIs64BitHelper< true > | |
| CIsArithmeticType | Compile-time test: is this one of the built-in "arithmetic" types, meaning an integral or floating type? |
| CIsFloatingType | Compile-time type test: is this one of the built-in floating point types? |
| CIsIntegralType | Compile-time type test: is this one of the built-in integral types? |
| CIsVoidType | Compile-time type test: is this the void type? |
| CIsVoidType< void > | |
| CLapack | |
| CLocalEnergyMinimizer | This class performs local potential energy minimization of a MultibodySystem |
| CMarkers | This AssemblyCondition specifies a correspondence between stations on mobilized bodies ("markers") and fixed ground-frame locations ("observations") |
| CMassProperties_ | This class contains the mass, center of mass, and unit inertia matrix of a rigid body B |
| ►CMat | This class represents a small matrix whose size is known at compile time, containing elements of any Composite Numerical Type (CNT) and engineered to have no runtime overhead whatsoever |
| CEltResult | |
| CResult | |
| CSubMat | |
| CSubstitute | |
| CMatrix_ | This is the matrix class intended to appear in user code for large, variable size matrices |
| ►CMatrixBase | This is the common base class for Simbody's Vector_ and Matrix_ classes for handling large, variable-sized vectors and matrices |
| CEltResult | |
| ►CMatrixCharacter | A 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 |
| CLapackFull | Predefined MatrixCharacter for an ordinary Lapack-style full matrix of a particular dimension m x n (nrows X ncols) |
| CMask | This class collects masks of each characteristic type for representing sets of accceptable characteristics |
| CRowVector | Predefined MatrixCharacter for an ordinary row vector of a particular size |
| CVector | Predefined MatrixCharacter for an ordinary column vector of a particular size |
| ►CMatrixCommitment | A MatrixCommitment provides a set of acceptable matrix characteristics |
| CHermitian | This is the default commitment for a Hermitian (*not* symmetric) matrix |
| CRowVector | This is the default commitment for a row vector |
| CSkewHermitian | This is the default commitment for a skew Hermitian (*not* skew symmetric) matrix |
| CSkewSymmetric | This is the default commitment for skew symmetric (*not* skew Hermitian) matrix |
| CSymmetric | This is the default commitment for a symmetric (*not* Hermitian) matrix |
| CTriangular | This is the default commitment for a triangular matrix |
| CVector | This is the default commitment for a column vector |
| ►CMatrixCondition | Matrix "condition" is a statement about the numerical characteristics of a Matrix |
| CMask | Use this class to represent a set of acceptable Condition values |
| ►CMatrixHelper | Here we define class MatrixHelper<S>, the scalar-type templatized helper class for the more general, composite numerical type-templatized class MatrixBase<ELT> |
| CDeepCopy | |
| CDiagonalView | |
| CShallowCopy | |
| CTransposeView | |
| CMatrixHelperRep | |
| ►CMatrixOutline | Matrix "outline" refers to the characteristic relationship between the number of rows and columns of a matrix, without necessarily specifying the absolute dimensions |
| CMask | |
| ►CMatrixStorage | Matrix "storage" refers to the physical layout of data in the computer’s memory |
| CMask | Use this class to represent sets of acceptable values for each of the storage attributes (packing, position, order, diagonal) |
| ►CMatrixStructure | Matrix "structure" refers to an inherent mathematical (or at least algorithmic) characteristic of the matrix rather than a storage strategy |
| CMask | |
| CMatrixView_ | (Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignment semantics |
| ►CMeasure_ | This is the base handle class for all Measures whose value type is known, including all the Simbody built-in Measure types |
| ►CConstant | This creates a Measure whose value is a Topology-stage constant of any type T |
| CImplementation | |
| ►CDelay | (CAUTION: still under development) This is a Measure whose value at time t is the value that its source operand had at time t-delay for a specified delay |
| CImplementation | |
| ►CDifferentiate | This Measure operator returns the time derivative of its operand measure, or a numerical approximation of the time derivative if an analytic one is not available |
| CImplementation | |
| ►CExtreme | This Measure tracks extreme values attained by the elements of its source operand since the last initialize() call or explicit call to setValue() |
| CImplementation | |
| CImplementation | This is the base Implementation class for all Measures whose value type is known |
| ►CIntegrate | This measure yields the time integral of a given derivative measure, initializing with an initial condition measure of the same type T |
| CImplementation | The implementation for Integrate measures allocates a continuous state variable or variables from the State's z pool and generates zdot values to be integrated into those z variables |
| CMaxAbs | Track the value of the operand that is of maximum absolute value |
| CMaximum | Track the maximum value of the operand (signed) |
| CMinAbs | Track the value of the operand that is of minimum absolute value (not very useful) |
| CMinimum | Track the minimum value of the operand (signed) |
| ►CMinus | This Measure is the difference of two Measures of the same type T |
| CImplementation | |
| COne | This creates a Measure::Constant whose value is always T(1) and can't be changed |
| ►CPlus | This Measure is the sum of two Measures of the same type T |
| CImplementation | |
| ►CResult | This Measure holds the result of some externally-determined computation, and helps to coordinate the validity of that computation with respect to the state variables |
| CImplementation | |
| CSampleAndHold | NOT IMPLEMENTED YET – 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 |
| ►CScale | This Measure multiplies some other Measure by a Real scale factor |
| CImplementation | |
| ►CSinusoid | This measure produces a sinusoidal function of time: |
| CImplementation | |
| ►CTime | This creates a Measure::Time whose value is always T(time) |
| CImplementation | |
| ►CVariable | This creates a Measure whose value is a discrete State variable of any type T |
| CImplementation | |
| CZero | This creates a Measure::Constant whose value is always T(0) and can't be changed |
| ►CMobilizedBody | A MobilizedBody is Simbody's fundamental body-and-joint object used to parameterize a system's motion by constructing a multibody tree containing each body and its unique "mobilizer" (internal coordinate joint) |
| CBall | Three mobilities – unrestricted orientation modeled with a quaternion which is never singular |
| CBendStretch | 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) |
| CBushing | Six mobilities – arbitrary relative motion modeled as x-y-z translation followed by an x-y-z body-fixed Euler angle sequence, though with a singularity when the middle angle is +/- 90 degrees |
| ►CCustom | 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 |
| CImplementation | This is the implementation class for Custom mobilizers |
| CCylinder | Two mobilities – rotation and translation along the common z axis of the inboard and outboard mobilizer frames |
| CEllipsoid | Three mobilities – coordinated rotation and translation along the surface of an ellipsoid fixed to the parent (inboard) body |
| CFree | Unrestricted motion for a rigid body (six mobilities) |
| CFreeLine | Five mobilities, representing unrestricted motion for a body which is inertialess along its own z axis |
| CFunctionBased | This is a subclass of MobilizedBody::Custom which uses a set of Function objects to define the behavior of the MobilizedBody |
| CGimbal | Three mobilities – unrestricted orientation modeled as a 1-2-3 body-fixed Euler angle sequence, though with a singularity when the middle angle is +/- 90 degrees |
| CGround | This is a special type of "mobilized" body generated automatically by Simbody as a placeholder for Ground in the 0th slot for a SimbodyMatterSubsystem's mobilized bodies; don't create this yourself |
| CLineOrientation | Two mobilities, representing unrestricted orientation for a body which is inertialess along its own z axis |
| CPin | Provides one rotational mobility about the common z axis of the F and M frames of the mobilizer |
| CPlanar | Three mobilities – z rotation and x,y translation |
| CScrew | One mobility – coordinated rotation and translation along the common z axis of the inboard and outboard mobilizer frames |
| CSlider | One mobility – translation along the common x axis of the F (inboard) and M (outboard) mobilizer frames |
| CSphericalCoords | Three mobilities – body fixed 3-2 (z-y) rotation followed by translation along body z or body x |
| CTranslation | Three translational mobilities describing the Cartesian motion of a point |
| CUniversal | Two mobilities – rotation about the x axis, followed by a rotation about the new y axis |
| CWeld | Zero mobilities |
| CMobilizedBodyIndex | This is for arrays indexed by mobilized body number within a subsystem (typically the SimbodyMatterSubsystem). It is assigned when a MobilizedBody is added to a subsystem. You can abbreviate this as MobodIndex if you prefer |
| CMobilizerQIndex | The Mobilizer associated with each MobilizedBody, once modeled, has a specific number of generalized coordinates q (0-7) and generalized speeds (mobilities) u (0-6). This is the index type for the small array of Mobilizer-local q's |
| CMobilizerUIndex | The Mobilizer associated with each MobilizedBody, once modeled, has a specific number of generalized coordinates q (0-7) and generalized speeds (mobilities) u (0-6). This is the index type for the small array of Mobilizer-local u's |
| ►CMotion | A Motion object belongs to a particular MobilizedBody and prescribes how the associated motion is to be calculated |
| ►CCustom | This class can be used to define new motions |
| CImplementation | This is the abstract base class for Custom Motion implementations |
| CSinusoid | Prescribe position, velocity, or acceleration motion as a sinusoidal function of time, m(t) = a * sin( w*t + p ) |
| CSteady | This non-holonomic Motion object imposes a constant rate on all mobilities |
| ►CMultibodyGraphMaker | Construct a reasonably good spanning-tree-plus-constraints structure for modeling a given set of bodies and joints with a generalized coordinate multibody system like Simbody |
| CBody | Local class that collects information about bodies |
| CJoint | Local class that collects information about joints |
| CJointType | Local class that defines the properties of a known joint type |
| CLoopConstraint | Local class that represents one of the constraints that were added to close topological loops that were cut to form the spanning tree |
| CMobilizer | Local class that represents one of the mobilizers (tree joints) in the generated spanning tree |
| CMultibodySystem | The job of the MultibodySystem class is to coordinate the activities of various subsystems which can be part of a multibody system |
| CMultiplierIndex | Unique integer type for Subsystem-local multiplier indexing |
| CNarrowest | 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) |
| CNarrowest< complex< R1 >, complex< R2 > > | |
| CNarrowest< complex< R1 >, R2 > | |
| CNarrowest< double, double > | |
| CNarrowest< double, float > | |
| CNarrowest< double, long double > | |
| CNarrowest< float, double > | |
| CNarrowest< float, float > | |
| CNarrowest< float, long double > | |
| CNarrowest< long double, double > | |
| CNarrowest< long double, float > | |
| CNarrowest< long double, long double > | |
| CNarrowest< R1, complex< R2 > > | |
| ►Cnegator | 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 |
| CResult | |
| CSubstitute | |
| CNiceTypeName | In case you don't like the name you get from typeid(), you can specialize this class to provide a nicer name |
| CNTraits | |
| ►CNTraits< complex< R > > | Partial specialization for complex numbers – underlying real R is still a template parameter |
| CResult | |
| CSubstitute | |
| ►CNTraits< conjugate< R > > | |
| CResult | |
| CSubstitute | |
| COBBLeaf | TODO |
| COBBNode | TODO |
| COBBTree | TODO |
| CObservedPointFitter | This class attempts to find the configuration of an internal coordinate model which best fits a set of observed data |
| ►COptimizer | API for SimTK Simmath's optimizers |
| COptimizerRep | |
| COptimizerSystem | Abstract class which defines an objective/cost function which is optimized by and Optimizer object |
| COrientationSensors | This AssemblyCondition specifies a correspondence between orientation sensors fixed on mobilized bodies ("osensors") and Ground-relative orientation sensor readings ("observations") |
| COrientedBoundingBox | This class represents a rectangular box with arbitrary position and orientation |
| COrOpType | This is an operator for or-ing compile-time truth types |
| COrOpType< FalseType, FalseType > | |
| COrOpType< FalseType, TrueType > | |
| COrOpType< TrueType, FalseType > | |
| COrOpType< TrueType, TrueType > | |
| ►CParallel2DExecutor | This class is used for performing multithreaded computations over two dimensional ranges |
| CTask | Concrete subclasses of this abstract class represent tasks that can be executed by a Parallel2DExecutor |
| ►CParallelExecutor | This class is used for performing multithreaded computations |
| CTask | Concrete subclasses of this abstract class represent tasks that can be executed by a ParallelExecutor |
| ►CParallelWorkQueue | This class is used for performing multithreaded computations. It maintains a queue of tasks to be executed, and a pool of threads for executing them |
| CTask | Concrete subclasses of this abstract class represent tasks that can be executed by a ParallelWorkQueue |
| CParticleConSurfaceSystem | |
| CParticleConSurfaceSystemGuts | |
| CPathDecorator | This class generates decoration for contact points and straight line path segments |
| CPathname | This class encapsulates the handling of file and directory pathnames in a platform-independent manner |
| CPeriodicEventHandler | PeriodicEventHandler is a subclass of ScheduledEventHandler which generates a series of uniformly spaced events at regular intervals |
| CPeriodicEventReporter | PeriodicEventReporter is a subclass of ScheduledEventReporter which generates a series of uniformly spaced events at regular intervals |
| CPGSImpulseSolver | Projected Gauss Seidel impulse solver |
| CPhiMatrix | |
| CPhiMatrixTranspose | |
| CPIMPLHandle | This class provides some infrastructure useful in making SimTK Private Implementation (PIMPL) classes |
| CPIMPLImplementation | This class provides some infrastructure useful in creating PIMPL Implementation classes (the ones referred to by Handles) |
| CPlane | A simple plane class |
| CPlaneDecorator | This class generates decoration for a plane |
| CPlugin | This is the base class for representing a runtime-linked dynamic library, also known as a "plugin", in a platform-independent manner |
| CPLUSImpulseSolver | TODO: PLUS (Poisson-Lankarani-Uchida-Sherman) impulse solver |
| CPointContact | OBSOLETE – use CircularPointContact or EllipticalPointContact |
| CPointPlaneContact | (Experimental – API will change – use at your own risk) Define a point on one body that cannot penetrate a plane attached to another body |
| CPointPlaneFrictionlessContact | (Experimental – API will change – use at your own risk) Define a point on one body that cannot penetrate a plane attached to another body |
| CPolygonalMesh | This class provides a description of a mesh made of polygonal faces (not limited to triangles) |
| ►CPolynomialRootFinder | This class provides static methods for finding the roots of polynomials |
| CZeroLeadingCoefficient | This is an exception which is thrown by all of the PolynomialRootFinder::findRoots() methods |
| CProjectOptions | Options for the advanced project() methods |
| CProjectResults | Results for advanced users of project() methods |
| CQErrIndex | Unique integer type for Subsystem-local qErr indexing |
| CQIndex | Unique integer type for Subsystem-local q indexing |
| CQuaternion_ | A Quaternion is a Vec4 with the following behavior: |
| CQValue | This AssemblyCondition requests that a particular generalized coordinate end up with a specified value |
| ►CRandom | This class defines the interface for pseudo-random number generators |
| CGaussian | This is a subclass of Random that generates numbers according to a Gaussian distribution with a specified mean and standard deviation |
| CUniform | This is a subclass of Random that generates numbers uniformly distributed within a specified range |
| CRealizeOptions | (NOT USED YET) Options for the advanced realize() methods |
| CRealizeResults | (NOT USED YET) Results for advanced users of realize() methods |
| CReferencePtr | This is a smart pointer that implements "cross reference" semantics where a pointer data member of some object is intended to refer to some target object in a larger data structure |
| CRope | (Experimental – API will change – use at your own risk) Set a hard upper limit on the separation between a point P on one body and a point Q on another |
| CRotation_ | The Rotation class is a Mat33 that guarantees that the matrix can be interpreted as a legitimate 3x3 rotation matrix giving the relative orientation of two right-handed, orthogonal, unit vector bases |
| ►CRow | This is a fixed-length row vector designed for no-overhead inline computation |
| CEltResult | |
| CResult | |
| CSubstitute | |
| CRowVector_ | Represents a variable size row vector; much less common than the column vector type Vector_ |
| ►CRowVectorBase | This is a dataless rehash of the MatrixBase class to specialize it for RowVectors |
| CEltResult | |
| CRowVectorView_ | (Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assignment semantics |
| CRTraits | RTraits is a helper class for NTraits |
| CRTraits< double > | |
| CRTraits< float > | |
| CRTraits< long double > | |
| CRungeKutta2Integrator | This is a 2nd order Runge-Kutta Integrator using coefficients that are also known as the explicit trapezoid rule |
| CRungeKutta3Integrator | This is a 3rd order Runge-Kutta Integrator using coefficents from J.C |
| CRungeKuttaFeldbergIntegrator | |
| CRungeKuttaMersonIntegrator | |
| CScheduledEventHandler | ScheduledEventHandler is a subclass of EventHandler for events that occur at a particular time that is known in advance |
| CScheduledEventReporter | ScheduledEventReporter is a subclass of EventReporter for events that occur at a particular time that is known in advance |
| CSegment | A convenient struct for anything requiring an offset and length to specify a segment of some larger sequence |
| CSemiExplicitEuler2Integrator | This is an implementation of a variable-step, first-order semi-explicit Euler method, also known as semi-implicit Euler or symplectic Euler |
| CSemiExplicitEulerIntegrator | This is an implementation of the fixed-step Semi-Explicit Euler method, also known as Semi-Implicit Euler or Symplectic Euler |
| CSemiExplicitEulerTimeStepper | A low-accuracy, high performance, velocity-level time stepper for models containing unilateral rigid contacts or other conditional constraints |
| CSimbodyMatterSubsystem | This subsystem contains the bodies ("matter") in the multibody system, the mobilizers (joints) that define the generalized coordinates used to represent the motion of those bodies, and constraints that must be satisfied by the values of those coordinates |
| CSimbodyMatterSubtree | A SimbodyMatterSubtree is a view of a connected subgraph of the tree of mobilized bodies in a SimbodyMatterSubsystem |
| CSimbodyMatterSubtreeResults | |
| CSpatialInertia_ | A spatial inertia contains the mass, center of mass point, and inertia matrix for a rigid body |
| CSpherePlaneContact | (Experimental – API will change – use at your own risk) Define a sphere on one body that cannot penetrate a plane attached to another body |
| CSphereSphereContact | (Experimental – API will change – use at your own risk) Define a sphere on each of two bodies |
| ►CSpline_ | This class implements a non-uniform Bezier curve |
| CSplineImpl | This is the implementation class that supports the Spline_ interface |
| ►CSplineFitter | Given a set of data points, this class creates a Spline_ which interpolates or approximates them |
| CSplineFitterImpl | |
| CStableArray | StableArray<T> is like std::vector<T> (or SimTK::Array_<T>) but more stable in two ways: |
| CStage | This class is basically a glorified enumerated type, type-safe and range checked but permitting convenient (if limited) arithmetic |
| CState | This object is intended to contain all state information for a SimTK::System, except topological information which is stored in the System itself |
| CStateLimitedFriction | TODO: not implemented yet |
| CString | SimTK::String is a plug-compatible std::string replacement (plus some additional functionality) intended to be suitable for passing through the SimTK API without introducing binary compatibility problems the way std::string does, especially on Windows |
| ►CStudy | |
| CGuts | This is the declaration for the Study::Guts class, the abstract object to which a Study handle points |
| ►CSubsystem | A Subsystem is expected to be part of a larger System and to have interdependencies with other subsystems of that same System |
| CGuts | The abstract parent of all Subsystem implementation classes |
| CSubsystemIndex | Provide a unique integer type for identifying Subsystems |
| ►CSymMat | This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation |
| CEltResult | |
| CResult | |
| CSubstitute | |
| CSysConstraintFunc | |
| CSysObjectiveFunc | |
| ►CSystem | This is the base class that serves as the parent of all SimTK System objects; most commonly Simbody's MultibodySystem class |
| CGuts | This is the declaration for the System::Guts class, the abstract object to which a System handle points |
| CSystemEventTriggerByStageIndex | This unique integer type is for identifying a triggered event within a particular Stage of the full System-level view of the State |
| CSystemEventTriggerIndex | This unique integer type is for identifying a triggered event in the full System-level view of the State |
| CSystemMultiplierIndex | This unique integer type is for indexing global "multiplier-like" arrays, that is, arrays that inherently have the same dimension as the total number of Lagrange multipliers in the full System-level view of the State |
| CSystemQErrIndex | This unique integer type is for indexing global "qErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of position-level constraint equations in the full System-level view of the State |
| CSystemQIndex | This unique integer type is for indexing global "q-like" arrays, that is, arrays that inherently have the same dimension as the total number of second order state variables (generalized coordinates) in the full System-level view of the State |
| CSystemUDotErrIndex | This unique integer type is for indexing global "uDotErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of acceleration-level constraint equations in the full System-level view of the State |
| CSystemUErrIndex | This unique integer type is for indexing global "uErr-like" arrays, that is, arrays that inherently have the same dimension as the total number of velocity-level constraint equations in the full System-level view of the State |
| CSystemUIndex | This unique integer type is for indexing global "u-like" arrays, that is, arrays that inherently have the same dimension as the total number of mobilities (generalized speeds) in the full System-level view of the State |
| CSystemYErrIndex | This unique integer type is for indexing the global, System-level "yErr-like" arrays, that is, the arrays in which all of the various Subsystems' qErr and uErr constraint equation slots have been collected together |
| CSystemYIndex | This unique integer type is for indexing the global, System-level "y-like" arrays, that is, the arrays in which all of the various Subsystems' continuous state variables q, u, and z have been collected into contiguous memory |
| CSystemZIndex | This unique integer type is for indexing global "z-like" arrays, that is, arrays that inherently have the same dimension as the total number of auxiliary state variables in the full System-level view of the State |
| ►CTest | This is the main class to support testing |
| CSubtest | Internal utility class for generating test messages for subtests |
| ►CTextDataEventReporter | This is an EventReporter which prints out numeric data at regular intervals in tabular form |
| CUserFunction | This template class defines a standard interface for objects that calculate a function based on a System and State for use in a TextDataEventReporter |
| CThreadLocal | This class represents a "thread local" variable: one which has a different value on each thread |
| CTimeStepper | This class uses an Integrator to advance a System through time |
| CTransform_ | 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 |
| CTriangleMeshContact | This subclass of Contact is used when one or both of the ContactGeometry objects is a TriangleMesh |
| CTriggeredEventHandler | TriggeredEventHandler is a subclass of EventHandler for events that occur when some condition is satisfied within the system |
| CTriggeredEventReporter | TriggeredEventReporter is a subclass of EventReporter for events that occur when some condition is satisfied within the system |
| CTrueType | This is a compile-time equivalent of "true", used in compile-time condition checking in templatized implementations |
| CTrustMe | This is a special type used for forcing invocation of a particularly dangerous constructor or method overload; don't use this unless you are an advanced user and know exactly what you're getting into |
| CUDotErrIndex | Unique integer type for Subsystem-local uDotErr indexing |
| CUErrIndex | Unique integer type for Subsystem-local uErr indexing |
| CUIndex | Unique integer type for Subsystem-local u indexing |
| CUnilateralContact | (Experimental – API will change – use at your own risk) A unilateral contact constraint uses a single holonomic (position) constraint equation to prevent motion in one direction while leaving it unrestricted in the other direction |
| CUnilateralSpeedConstraint | TODO: not implemented yet |
| CUnitInertia_ | A UnitInertia matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying it by the actual body mass |
| CUnitRow | This type is used for the transpose of UnitVec, and as the returned row type of a Rotation |
| CUnitVec | This class is a Vec3 plus an ironclad guarantee either that: |
| CUntrackedContact | This subclass of Contact represents a pair of contact surfaces that are not yet being tracked; there is no ContactId for them |
| CValue | Templatized version of the abstract class, providing generic type-specific functionality that does not require specialization, with automatic conversion to the underlying type |
| ►CVec | This is a fixed-length column vector designed for no-overhead inline computation |
| CEltResult | |
| CResult | |
| CSubstitute | Shape-preserving element substitution (always packed) |
| CVector_ | This is the vector class intended to appear in user code for large, variable size column vectors |
| ►CVectorBase | This is a dataless rehash of the MatrixBase class to specialize it for Vectors |
| CEltResult | |
| CVectorIterator | This is an iterator for iterating over the elements of a Vector_ or Vec object |
| CVectorView_ | (Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignment semantics |
| CVerletIntegrator | This is an Integrator based on the velocity Verlet algorithm |
| ►CVisualizer | Provide simple visualization of and interaction with a Simbody simulation, with real time control of the frame rate. There are several operating modes available, including real time operation permitting responsive user interaction with the simulation |
| CFrameController | This abstract class represents an object that will be invoked by the Visualizer just prior to rendering each frame |
| CInputListener | This abstract class defines methods to be called when the Visualizer reports user activity back to the simulation process. Derive a concrete event listener whose methods take appropriate actions when event of interest occur |
| CInputSilo | This pre-built InputListener is extremely useful for processing user input that is intended to affect a running simulation |
| CReporter | This is an EventReporter that makes it easy to generate on-screen movies of any simulation |
| CWider | |
| CWider< double, double > | |
| CWider< double, float > | |
| CWider< double, long double > | |
| CWider< float, double > | |
| CWider< float, float > | |
| CWider< float, long double > | |
| CWider< long double, double > | |
| CWider< long double, float > | |
| CWider< long double, long double > | |
| CWidest | 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) |
| CWidest< complex< R1 >, complex< R2 > > | |
| CWidest< complex< R1 >, R2 > | |
| CWidest< double, double > | |
| CWidest< double, float > | |
| CWidest< double, long double > | |
| CWidest< float, double > | |
| CWidest< float, float > | |
| CWidest< float, long double > | |
| CWidest< long double, double > | |
| CWidest< long double, float > | |
| CWidest< long double, long double > | |
| CWidest< R1, complex< R2 > > | |
| ►CXml | This class provides a minimalist capability for reading and writing XML documents, as files or strings |
| CAttribute | Elements can have attributes, which are name="value" pairs that appear within the element start tag in an XML document; this class represents the in-memory representation of one of those attributes and can be used to examine or modify the name or value |
| Cattribute_iterator | This is a bidirectional iterator suitable for moving forward or backward within a list of Attributes within an Element, for writable access |
| CComment | A comment contains only uninterpreted text |
| CElement | An element has (1) a tagword, (2) a map of (name,value) pairs called attributes, and (3) a list of child nodes |
| Celement_iterator | This is a bidirectional iterator suitable for moving forward or backward within a list of Element nodes, for writable access |
| CNode | Abstract handle for holding any kind of node in an XML tree |
| Cnode_iterator | This is a bidirectional iterator suitable for moving forward or backward within a list of Nodes, for writable access |
| CText | This is the "leaf" content of an element |
| CUnknown | This is something we don't understand but can carry around |
| CXorOpType | This is an operator for exclusive or-ing compile-time truth types |
| CXorOpType< FalseType, FalseType > | |
| CXorOpType< FalseType, TrueType > | |
| CXorOpType< TrueType, FalseType > | |
| CXorOpType< TrueType, TrueType > | |
| CZIndex | Unique integer type for Subsystem-local z indexing |
1.8.11 
