 |
API
4.4
For C++ developers
|
|
API
4.4
For C++ developers
|
| ►NOpenSim | The Moco interface is contained within the OpenSim namespace |
| CAbstractChannel | One of the values of an Output |
| CAbstractDataTable | AbstractDataTable is the base-class of all DataTable_(templated) allowing storage of DataTable_ templated on different types to be stored in a container like std::vector |
| CAbstractInput | A specialized Socket that connects to an Output signal is an Input |
| CAbstractOutput | Output formalizes the access to a value of interest computed by the owning Component |
| CAbstractPathPoint | An abstract class implementing a path point interface |
| CAbstractProperty | An abstract property is a serializable (name,value) pair, for which we do not know the type of the value |
| CAbstractReporter | This abstract class represents a Reporter that generates a report from values generated by Components in a Model during a simulation |
| CAbstractSocket | A Socket formalizes the dependency between a Component and another object (typically another Component) without owning that object |
| CAbstractTool | An abstract class for specifying the interface for an investigation |
| CAbstractValueArray | ValueArray (of type T) represents an array of SimTK::Value (of type T) |
| CAccelerationMotion | This class is a thin wrapper to Simbody's SimTK::Motion for prescribing the acceleration of all degrees of freedom (UDot), and is used when enforcing dynamics using implicit differential equations (UDot is supplied by the solver, not by Simbody) |
| CAckermannVanDenBogert2010Force | This class is still under development |
| CActivationCoordinateActuator | Similar to CoordinateActuator (simply produces a generalized force) but with first-order linear activation dynamics |
| CActivationFiberLengthMuscle | A base class representing a two-state muscle-tendon actuator |
| CActivationFiberLengthMuscle_Deprecated | A base class representing a muscle-tendon actuator |
| CActiveForceLengthCurve | This class serves as a serializable ActiveForceLengthCurve, commonly used to model the active element in muscle models |
| CActuation | A class for recording the basic actuator information for a model during a simulation |
| CActuator | Base class for an actuator (e.g., a torque motor, muscle, ...) that requires a generic external input (a vector of controls) to generate force |
| CActuatorForceProbe | ActuatorForceProbe is a ModelComponent Probe for computing an operation on a force or sum of forces in the model during a simulation |
| CActuatorForceTarget | A Computed Muscle Control (CMC) optimization target for controlling dynamic systems whose actuators may be themselves governed by differential equations, meaning there may be non-linear behavior and delays in force production |
| CActuatorForceTargetFast | A Computed Muscle Control (CMC) optimization target for controlling dynamic systems whose actuators may be themselves governed by differential equations, meaning there may be non-linear behavior and delays in force production |
| CActuatorPowerProbe | ActuatorPowerProbe is a ModelComponent Probe for computing an operation on a actuator power or sum of actuator powers in the model during a simulation |
| CAnalysis | An abstract class for specifying the interface for an analysis plugin |
| CAnalysisSet | A class for holding and managing a set of integration callbacks for a model |
| CAnalyticGeometry | Abstract class for analytical geometry (e.g |
| CAnalyzeTool | An abstract class for specifying the interface for an investigation |
| CAPDMDataReader | APDMDataReader is a class that reads files produced by IMU manufacturer APDM and produces datatables from them |
| CAPDMDataReaderSettings | APDMDataReaderSettings is a class that reads files produced by IMU manufacturer APDM and produces datatables from them |
| CAppearance | A class that holds the Appearance properties of Geometry displayed in the OpenSim Visualizer |
| CArray | A class for storing an array of values of type T |
| CArrayPtrs | |
| CArrow | Arrow is a Geometry subclass used to represent an arrow |
| CAssemblySolver | Solve for the coordinates (degrees-of-freedom) of the model that satisfy the set of constraints imposed on the model as well as set of desired coordinate values |
| CBallJoint | A class implementing a Ball joint |
| CBhargava2004MuscleMetabolicsProbe | Bhargava2004MuscleMetabolicsProbe is a Probe ModelComponent for computing the net metabolic energy rate of a set of Muscles in the model during a simulation |
| CBhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameter | Documentation for this class has been provided with the documentation for the Bhargava2004MuscleMetabolicsProbe class |
| CBhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameterSet | MetabolicMuscleParameterSet is a class that holds the set of MetabolicMuscleParameters for each muscle |
| CBhargava2004SmoothedMuscleMetabolics | This class implements the metabolic energy model of Bhargava et al (2004) and provides an option to use smooth (i.e., twice continuously differentiable) approximations |
| CBhargava2004SmoothedMuscleMetabolics_MuscleParameters | Object class that holds the metabolic parameters required to calculate metabolic power for a single muscle |
| CBlankevoort1991Ligament | This class implements a nonlinear spring ligament model introduced by Blankevoort et al. (1991) [1] and further described in Smith et al. (2016) [2] |
| CBody | An OpenSim::Body is a PhysicalFrame (reference frame) with associated inertia specified by its mass, center-of-mass located in the PhysicalFrame, and its moment of inertia tensor about the center-of-mass |
| CBodyActuator | Apply a spatial force (that is, [torque, force]) on a given point of the given body |
| CBodyKinematics | A class for recording the kinematics of the bodies of a model during a simulation |
| CBodyScale | A class implementing a set of parameters describing how to scale a body segment |
| CBodyScaleSet | A class for holding a set of body scales |
| CBodySet | A class for holding a set of bodies |
| CBrick | A class to represent Brick geometry |
| CBufferedOrientationsReference | Subclass of OrientationsReference that handles live data by providing a DataQueue that allows clients to push data into and allows the InverseKinematicsSolver to draw data from for solving |
| CBushingForce | A class implementing a Bushing Force |
| CC3DFileAdapter | C3DFileAdapter reads a C3D file into markers and forces tables of type TimeSeriesTableVec3 |
| CClutchedPathSpring | The ClutchedPathSpring is an actuator that has passive path spring behavior only when the clutch is engaged |
| CCMC | Computed Muscle Control (CMC) is an optimization-based control technique designed specifically for controlling dynamic models that are actuated by redundant sets of actuators whose force-generating properties may be nonlinear and governed by differential equations (and so have delays in force production) |
| CCMC_Joint | A class for specifying the tracking task for a joint |
| CCMC_Orientation | A class for tracking the orientation of a body |
| CCMC_Point | A class for specifying and computing parameters for tracking a point |
| CCMC_Task | An abstract base class for specifying a task objective for a dynamic simulation |
| CCMC_TaskSet | An class for holding and managing a set of tasks |
| CCMCTool | An abstract class for specifying the interface for an investigation |
| CColumnIndexOutOfRange | |
| ►CComponent | The abstract Component class defines the interface used to add computational elements to the underlying SimTK::System (MultibodySystem) |
| CCacheVariable | A cache variable containing a value of type T |
| CStateVariable | |
| CComponentAlreadyPartOfOwnershipTree | |
| CComponentFilter | A class to specify a filter to be used to iterate through components |
| CComponentFilterAbsolutePathNameContainsString | A component is considered a match if its absolute path name contains the given string |
| CComponentFilterMatchAll | ComponentFilterMatchAll is a trivial Filter that matches all components |
| CComponentHasNoName | Component Exceptions |
| CComponentHasNoSystem | |
| CComponentIsAnOrphan | |
| CComponentIsRootWithNoSubcomponents | |
| CComponentList | Collection (linked list) of components to iterate through |
| CComponentListIterator | Class used to iterate over subcomponents of a specific type (by default, any Component) |
| CComponentNotFound | |
| CComponentNotFoundOnSpecifiedPath | |
| CComponentPath | A representation of a path within a Component tree |
| CComponentSet | A class for holding a set of miscellaneous model components |
| CCondition | A parent class for implementing an OpenSim Condition |
| CConditionalPathPoint | A class implementing a conditional path point, which is a point that is active only for a specified range of a coordinate |
| CCone | A class to represent a Cone geometry |
| CConnecteeNotSpecified | |
| CConsoleReporter_ | A reporter that simply prints quantities to the console (command window or terminal), perhaps to monitor the progress of a simulation as it executes |
| CConstant | A class for representing a constant value |
| CConstantDistanceConstraint | A class implementing a constraint that maintains a constant distance between between two points on separate PhysicalFrames |
| CConstantMuscleActivation | This constant muscle activation model simply holds activation at the value that was provided most recently, and can be used to generate an activation signal without relying on an excitation signal |
| CConstraint | A parent class for implementing a Simbody Constraint |
| CConstraintSet | A class for holding a set of constraints |
| CContactGeometry | This class represents the physical shape of an object for use in contact modeling |
| CContactGeometrySet | A class for holding a set of ContactGeometry components |
| CContactHalfSpace | This class represents a half space (that is, everything to one side of an infinite plane) for use in contact modeling |
| CContactMesh | This class represents a polygonal mesh for use in contact modeling |
| CContactSphere | This class represents a spherical object for use in contact modeling |
| CControl | A class that represents a control in a dynamic simulation |
| CControlConstant | A class that represents a constant control curve |
| CController | Controller is an abstract ModelComponent that defines the interface for an OpenSim Controller |
| CControllerSet | A class for holding and managing a set of controllers for a model |
| CControlLinear | A class that represents a piece-wise linear control curve |
| CControlLinearNode | A control node used to reconstruct a piecewise linear control |
| CControlSet | A class for holding and managing a set of controls for a dynamic simulation |
| CControlSetController | ControlSetController that simply assigns controls from a ControlSet |
| CCoordinate | A Coordinate is a ModelComponent for managing the access and behavior of a model's generalized coordinate including its value, speed and acceleration (once system accelerations have been realized) |
| CCoordinateActuator | An actuator that applies a generalized force in the direction of a generalized coordinate |
| CCoordinateCouplerConstraint | |
| CCoordinateLimitForce | Generate a force that acts to limit the range of motion of a coordinate |
| CCoordinateReference | Reference value to be achieved for a specified coordinate that will be used via optimization and/or tracking |
| CCoordinateSet | A class for holding a set of coordinates |
| CCorrectionController | This is a simple feedback controller to be used in generating a forward dynamic simulation |
| CCSVFileAdapter | CSVFileAdapter is a DelimFileAdapter that presets the delimiters appropriately for CSV files |
| CCustomJoint | A class implementing a custom joint |
| CCylinder | A class to represent a Cylinder geometry |
| CDataAdapter | DataAdapter is an abstract class defining an interface for reading/writing in/out the contents of a DataTable |
| CDataAdapterAlreadyRegistered | |
| CDataQueue_ | DataQueue is a wrapper around the std::queue customized to handle data processing and synchronization, and limiting the interface to only the subset of operations needed for this use case |
| CDataQueueEntry_ | This base class defines the interface for a DataQueue |
| CDataTable_ | DataTable_ is an in-memory storage container for data with support for holding metadata (using the base class AbstractDataTable) |
| CDataTypeMismatch | |
| CDeGrooteFregly2016Muscle | This muscle model was published in De Groote et al |
| CDelimFileAdapter | DelimFileAdapter is a FileAdapter that reads and writes text files with given delimiters |
| CDelp1990Muscle_Deprecated | A class implementing a SIMM muscle |
| CDiscreteController | This component is used internally by Moco for passing a solver's control variables to a Model |
| CDiscreteForces | This class is a thin wrapper to Simbody's SimTK::Force::DiscreteForces class |
| CDynamicsTool | An abstract Tool for defining tools for performing a dynamics analysis with a given model |
| CElasticFoundationForce | This Force subclass implements an elastic foundation contact model |
| CEllipsoid | A class to represent an Ellipsoid geometry |
| CEllipsoidJoint | A class implementing a Ellipsoid joint |
| CEmptyFileName | |
| CEmptyTable | |
| CEspositoMiller2018Force | This contact model uses a continuous equation to transition between in and out of contact |
| CEvent | Struct representing an event extracted from a C3D file |
| CException | A class for basic exception functionality |
| CExperimentalFrame | ExperimentalFrame is a concrete Frame that represents the experimental value of a Frame and can be used to display its frame in the OpenSim Visualizer |
| CExperimentalMarker | ExperimentalMarker is a concrete Point that represents the experimental value of a Marker and can be used to display its location in the OpenSim Visualizer |
| CExperimentalSensor | A class representing the experimental sensor, such as IMU, and its association to a model (component) in OpenSim |
| CExpressionBasedBushingForce | A class implementing a bushing force specified by expressions of the deflection between two bushing frames |
| CExpressionBasedCoordinateForce | |
| CExpressionBasedPointToPointForce | A point-to-point Force who's force magnitude is determined by a user-defined expression, with the distance (d) and its time derivative (ddot) as variables |
| CExternalForce | An ExternalForce is a Force class specialized at applying an external force and/or torque to a body as described by arrays (columns) of a Storage object |
| CExternalLoads | A convenience class for managing ExternaForce(s) to be applied to a model |
| CFiberCompressiveForceCosPennationCurve | This class serves as a serializable FiberCompressiveForceCosPennationCurve, which is used to ensure that the pennation angle approaches but never reaches an angle of 90 degrees |
| CFiberCompressiveForceLengthCurve | This class serves as a serializable FiberCompressiveForceLengthCurve, which is used to ensure that the fiber cannot generate force at, nor shorten beyond a minimum normalized length |
| CFiberForceLengthCurve | This class serves as a serializable FiberForceLengthCurve, commonly used to model the parallel elastic element in muscle models |
| CFileAdapter | FileAdapter is a DataAdapter that reads and writes files with methods read and writeFile respectively |
| CFileDeletionThrower | This class helps a user cause an exception within the code |
| CFileDeletionThrowerException | Thrown by FileDeletionThrower::throwIfDeleted() |
| CFileDoesNotExist | |
| CFileExtensionNotFound | |
| CFileIsEmpty | |
| CFileRemover | When an instance of this class is destructed, it removes (deletes) the file at the path provided in the constructor |
| CFirstOrderMuscleActivationDynamics | Computes muscle activation using a modified version of the first-order dynamic models used by Thelen (2003) and Winters (1995) |
| CForce | This abstract class represents a force applied to bodies or generalized coordinates during a simulation |
| CForceAdapter | This acts as an adapter to allow a Force or Actuator to be used as a SimTK::Force |
| CForceReporter | A class for recording the Forces applied to a model during a simulation |
| CForceSet | A class for holding and managing a set of forces for a model |
| CForceVelocityCurve | This class serves as a serializable ForceVelocityCurve for use in muscle models |
| CForceVelocityInverseCurve | This class serves as a serializable ForceVelocityInverseCurve for use in equilibrium muscle models |
| CForwardTool | A concrete tool for performing forward dynamics simulations |
| CFrame | A Frame is an OpenSim representation of a reference frame |
| CFrameGeometry | A class to represent Frame geometry |
| CFreeJoint | A class implementing a Free joint |
| CFunction | An abstract class for representing a function |
| CFunctionBasedBushingForce | A class implementing a bushing force specified by functions of the frame deflections |
| CFunctionSet | A class for holding a set of functions |
| CFunctionThresholdCondition | FunctionThresholdCondition is a concrete implementation of a Condition |
| CGCVSpline | A class for representing a smooth function with a generalized cross-validation spline |
| CGCVSplineSet | A class for holding a set of generalized cross-validated splines |
| CGenericModelMaker | A class implementing a set of parameters describing a generic musculoskeletal model |
| CGeometry | Class Geometry is intended to be used as the base class for all geometry that needs to be represented in the system, including mesh files, and built in analytic shapes |
| CGeometryPath | A base class representing a path (muscle, ligament, etc.) |
| CGimbalJoint | A class implementing a Gimbal joint |
| CGround | Ground is an inertial reference frame in which the motion of all Frames and points may conveniently and efficiently be expressed |
| CHuntCrossleyForce | This force subclass implements a Hunt-Crossley contact model |
| CIKCoordinateTask | |
| CIKMarkerTask | |
| CIKTask | |
| CIKTaskSet | |
| CIMU | IMU is a Model Component that represents an IMU along with its Geometry for visualization |
| CIMUDataReader | |
| CIMUDataReporter | A class for recording the readings off an IMU object placed on a model during a simulation |
| CIMUInverseKinematicsTool | A Study that performs an Inverse Kinematics analysis with a given model |
| CIMUPlacer | A class implementing a set of parameters describing how to place IMUs on a model to match placement of experimental sensors (IMUs) |
| CIncorrectMetaDataLength | |
| CIncorrectNumColumnLabels | |
| CIncorrectNumColumns | |
| CIncorrectNumMetaDataKeys | |
| CIncorrectNumRows | |
| CIncorrectNumTokens | |
| CIncorrectTableType | |
| CIndexOutOfRange | |
| CInducedAccelerations | A class to perform an Induced Accelerations analysis using a constraint- method of replacing external (contact) forces in order to determine the contributions of actuators to external reaction forces and thus model accelerations including that of the center-of-mass |
| CInducedAccelerationsSolver | A Solver to compute the induced accelerations of an applied "force" acting on the model |
| CInput | An Input<Y> must be connected by an Output<Y> |
| CInputNotConnected | ComponentSocket Exceptions |
| CInputNotFound | |
| CInvalidArgument | |
| CInvalidCall | |
| CInvalidColumn | |
| CInvalidColumnLabel | |
| CInvalidComponentName | |
| CInvalidPropertyValue | Property Exceptions |
| CInvalidRow | |
| CInvalidTable | |
| CInvalidTemplateArgument | |
| CInvalidTimeRange | |
| CInvalidTimestamp | |
| CInverseDynamicsSolver | Solve for the generalized coordinate forces (1 per degree-of- freedom) that satisfy the unconstrained equations of motion given kinematics: q, u, u_dot |
| CInverseDynamicsTool | A Tool that performs an Inverse Dynamics analysis with a given model |
| CInverseKinematicsSolver | Solve for the coordinates (degrees of freedom) of the model that satisfy the set of constraints imposed on the model and the set of desired coordinate values |
| CInverseKinematicsTool | A Tool that performs an Inverse Kinematics analysis with a given model |
| CInverseKinematicsToolBase | A Tool that performs an Inverse Kinematics analysis with a given model |
| ►CIO | A class for performing input and output with OpenSim API |
| CCwdChanger | A class that: |
| CIOError | |
| CJoint | An OpenSim Joint is an OpenSim::ModelComponent which connects two PhysicalFrames together and specifies their relative permissible motion as described in internal coordinates |
| CJointFramesAreTheSame | |
| CJointFramesHaveSameBaseFrame | |
| CJointHasNoCoordinates | |
| CJointInternalPowerProbe | JointInternalPowerProbe is a ModelComponent Probe for computing an operation on internal joint power or sum of joint powers in the model during a simulation |
| CJointReaction | An analysis for reporting the joint reaction loads from a model |
| CJointSet | A class for holding a set of joints |
| CKeyExists | |
| CKeyMissing | |
| CKeyNotFound | |
| CKinematics | A class for recording the kinematics of the generalized coordinates of a model during a simulation |
| CLigament | A class implementing a ligament |
| CLinearFunction | A class for representing a LinearFunction |
| CLineGeometry | LineGeometry is a utility class used to abstract a line segment |
| CLogger | This is a singleton class (single instance) for logging messages and controlling how those messages are presented to the user |
| CLogSink | Derive from this class to implement your own way of reporting logged messages |
| CManager | A class that manages the execution of a simulation |
| CMarker | A class implementing a Mocap marker |
| CMarkerData | A class implementing a sequence of marker frames from a TRC/TRB file |
| CMarkerFrame | A class implementing a frame of marker data from a TRC/TRB file |
| CMarkerPair | A class for holding the names of a pair of markers (for making measurements on a model) |
| CMarkerPairSet | A class for holding a set of SimmMarkerPairs |
| CMarkerPlacer | A class implementing a set of parameters describing how to place markers on a model (presumably after it has been scaled to fit a subject) |
| CMarkerSet | A class for holding a set of markers |
| CMarkersReference | Reference values to be achieved for specified Markers that will be used via optimization and/or tracking |
| CMarkerWeight | |
| CMcKibbenActuator | McKibben Pneumatic Actuator Model based on the simple cylindrical formulation described in J |
| CMeasurement | A class implementing a measurement (the distance between one or more pairs of markers, used to scale a model) |
| CMeasurementSet | A class for holding a set of measurements |
| CMesh | A class to represent Mesh geometry that comes from a file |
| CMetaDataLengthMismatch | |
| CMeyerFregly2016Force | This contact model is from the following paper: Meyer A |
| CMillard2012AccelerationMuscle | This class implements a 3 state (activation,fiber length and fiber velocity) acceleration musculo-tendon model that has several advantages over equilibrium musculo-tendon models: it is possible to simulate 0 activation, it requires fewer integrator steps to simulate, and physiological active force-length (with a minimum value of 0) and force velocity (with true asymptotes at the maximum shortening and lengthening velocities) curves can be employed |
| CMillard2012EquilibriumMuscle | This class implements a configurable equilibrium muscle model, as described in Millard et al. (2013) |
| CMissingHeader | |
| CMissingMetaData | |
| CMocoAccelerationTrackingGoal | The squared difference between a model frame origin's linear acceleration and a reference acceleration value, summed over the frames for which a reference is provided, and integrated over the phase |
| CMocoAngularVelocityTrackingGoal | The squared difference between a model frame's angular velocity and a reference angular velocity value, summed over the frames for which a reference is provided, and integrated over the phase |
| CMocoAverageSpeedGoal | This goal requires the average speed of the system to match a desired average speed |
| CMocoBounds | Small struct-like class to handle bounds |
| CMocoCasADiSolver | This solver uses the CasADi library (https://casadi.org) to convert the MocoProblem into a generic nonlinear programming problem |
| CMocoCasADiSolverNotAvailable | |
| CMocoConstraintInfo | Information for a given constraint in the optimal control problem |
| CMocoContactTrackingGoal | |
| CMocoContactTrackingGoalGroup | |
| CMocoControlBoundConstraint | This class constrains any number of control signals from ScalarActautors to be between two time-based functions |
| CMocoControlGoal | Minimize the sum of the absolute value of the controls raised to a given exponent, integrated over the phase |
| CMocoControlTrackingGoal | |
| CMocoControlTrackingGoalReference | Associate a control variable with a column from the reference data |
| CMocoDirectCollocationSolver | This is a base class for solvers that use direct collocation to convert an optimal control problem into a generic nonlinear programming problem |
| CMocoFinalBounds | Used for specifying the bounds on a variable at the end of a phase |
| CMocoFinalOutputGoal | This goal allows you to minimize or constrain a Model Output value at the end of a trajectory |
| CMocoFinalTimeGoal | Endpoint cost for final time |
| CMocoFrameDistanceConstraint | This path constraint enforces that the distance between the origins of pairs of model frames is kept between minimum and maximum bounds |
| CMocoFrameDistanceConstraintPair | |
| ►CMocoGoal | A goal is a term in the cost functional to be minimized, or a set of endpoint constraints that must lie within provided bounds |
| CGoalInput | |
| CIntegrandInput | |
| CMocoInitialActivationGoal | For all muscles with activation dynamics, the initial activation and initial excitation should be the same |
| CMocoInitialBounds | Used for specifying the bounds on a variable at the start of a phase |
| CMocoInitialForceEquilibriumDGFGoal | For all DeGrooteFregly2016Muscles with explicit tendon compliance dynamics, constrain (or minimize) the error computed from the muscle-tendon force equilibrium equation |
| CMocoInitialOutputGoal | This goal allows you to minimize or constrain a Model Output value at the beginning of a trajectory |
| CMocoInitialVelocityEquilibriumDGFGoal | For DeGrooteFregly2016Muscle components with implicit tendon compliance dynamics, the initial tendon and fiber velocities are determined based the derivative of the linearized muscle-tendon equilibrium equation described in Millard et al |
| CMocoInverse | This tool solves problems in which the kinematics are prescribed and you seek the actuator (e.g., muscle) behavior that may have given rise to the provided kinematics |
| CMocoInverseSolution | This class holds the solution from MocoInverse |
| CMocoJointReactionGoal | Minimize the sum of squares of specified reaction moment and force measures for a given joint, integrated over the phase |
| CMocoKinematicConstraint | A model kinematic constraint to be enforced in the optimal control problem |
| CMocoMarkerFinalGoal | The squared distance between a single model point location and reference location in the final state |
| CMocoMarkerTrackingGoal | |
| CMocoOrientationTrackingGoal | The squared difference between a model frame's orientation and a reference orientation value, summed over the frames for which a reference is provided, and integrated over the phase |
| CMocoOutputBase | This abstract base class provides convenience methods and common interfaces for all Output-related MocoGoal's |
| CMocoOutputConstraint | |
| CMocoOutputGoal | This goal allows you to use model Outputs of type double, SimTK::Vec3, and SimTK::SpatialVec in the integrand of a goal |
| CMocoOutputPeriodicityGoal | This goal allows you to minimize or constrain the difference of values from a Model Output from the beginning and end of a trajectory |
| CMocoOutputTrackingGoal | This goal allows you to minimize the squared difference between a Model Output value and a user-defined function |
| CMocoParameter | A MocoParameter allows you to optimize property values in an OpenSim Model |
| CMocoPathConstraint | A path constraint to be enforced in the optimal control problem |
| CMocoPeriodicityGoal | This goal enforces equality between initial and final variable values in the optimal control problem |
| CMocoPeriodicityGoalPair | Create pair of variables for use with a MocoPeriodicityGoal |
| CMocoPhase | The states, controls, dynamics, parameters, goals, and constraints for a phase of the problem |
| CMocoProblem | A description of an optimal control problem, backed by OpenSim Models |
| CMocoProblemInfo | This class is mostly for internal use for MocoProblemRep to pass select information about a problem to the MocoGoals and MocoPathConstraints of the problem during initializeOnModel() |
| CMocoProblemRep | The primary intent of this class is for use by MocoSolvers, but users can also use this class to apply parameter values to the model and evaluate cost terms |
| CMocoScaleFactor | A scale factor is a scalar value optimized by Moco that can be used to scale a tracked reference quantity in the cost function |
| CMocoSolution | Return type for MocoStudy::solve() |
| CMocoSolver | Once the solver is created, you should not make any edits to the MocoProblem |
| CMocoStateTrackingGoal | |
| CMocoStepLengthAsymmetryGoal | Minimize the error between a model's step time asymmetry and a specified target asymmetry value over a gait cycle |
| CMocoStepTimeAsymmetryGoal | Minimize the error between a model's step time asymmetry and a specified target asymmetry value over a gait cycle |
| CMocoStepTimeAsymmetryGoalGroup | A contact group includes a list of contact force component paths in the model |
| CMocoStudy | The top-level class for solving a custom optimal control problem |
| CMocoStudyFactory | This class creates MocoStudies of common interest |
| CMocoSumSquaredStateGoal | Minimize the sum of squared states, integrated over the phase |
| ►CMocoTool | This is a base class for solving problems that depend on an observed motion using Moco's optimal control methods |
| CTimeInfo | |
| CMocoTrack | |
| CMocoTrajectory | The values of the variables in an optimal control problem |
| CMocoTrajectoryIsSealed | This exception is thrown if you try to invoke most methods on MocoTrajectory while the trajectory is sealed |
| CMocoTranslationTrackingGoal | The squared difference between a model frame's origin position and a reference position value, summed over the frames for which a reference is provided, and integrated over the phase |
| ►CMocoTropterSolver | Solve the MocoProblem using the tropter direct collocation library |
| CExplicitTropterProblem | |
| CImplicitTropterProblem | |
| COCProblem | Internal tropter optimal control problem |
| CTropterProblemBase | |
| CMocoTropterSolverNotAvailable | |
| CMocoVariableInfo | Bounds on continuous variables (states, controls, multipliers, etc) |
| CMocoWeight | This class contains a single property that holds a weighting factor to be used in a MocoGoal |
| CMocoWeightSet | A container for Moco weights |
| CModel | A concrete class that specifies the interface to a musculoskeletal model |
| CModelComponent | This defines the abstract ModelComponent class, which is used to specify components of a musculoskeletal model and the elements they add to the underlying computational SimTK::System (MultibodySystem) |
| CModelComponentSet | |
| CModelDisplayHints | This class captures information indicating user or programmer preferences to guide automatic display geometry generation by a Model |
| CModelFactory | This class provides utilities for creating OpenSim models |
| CModelHasNoSystem | Model Exceptions |
| CModelOperator | This abstract base class describes any operation that modifies a Model as part of a ModelProcessor |
| CModelProcessor | This class describes a workflow for processing a Model using ModelOperators |
| CModelScaler | A class for scaling a model |
| CModelVisualizer | This class manages runtime visualization of a Model that is being manipulated through the OpenSim API |
| CModelVisualPreferences | A class that holds the Visual Preferences of a full OpenSim Model displayed in Visualizer |
| CModOpAddExternalLoads | Add external loads (e.g., ground reaction forces) to the model from a XML file |
| CModOpAddReserves | Add reserve actuators to the model using ModelFactory::createReserveActuators |
| CModOpFiberDampingDGF | Set the fiber damping for all DeGrooteFregly2016Muscles in the model |
| CModOpIgnoreActivationDynamics | Turn off activation dynamics for all muscles in the model |
| CModOpIgnorePassiveFiberForcesDGF | Turn off passive fiber forces for all DeGrooteFregly2016Muscles in the model |
| CModOpIgnoreTendonCompliance | Turn off tendon compliance for all muscles in the model |
| CModOpPassiveFiberStrainAtOneNormForceDGF | Set passive fiber stiffness for all DeGrooteFregly2016Muscles in the model |
| CModOpRemoveMuscles | Remove all muscles contained in the model's ForceSet |
| CModOpReplaceJointsWithWelds | |
| CModOpReplaceMusclesWithDeGrooteFregly2016 | Invoke DeGrooteFregly2016Muscle::replaceMuscles() on the model |
| CModOpScaleActiveFiberForceCurveWidthDGF | Scale the active fiber force curve width for all DeGrooteFregly2016Muscles in the model |
| CModOpScaleMaxIsometricForce | Scale the max isometric force for all muscles in the model |
| CModOpTendonComplianceDynamicsModeDGF | For DeGrooteFregly2016Muscle muscles whose 'ignore_tendon_compliance' property is false, set the tendon compliance dynamics mode to either 'explicit' or 'implicit' |
| CModOpUseImplicitTendonComplianceDynamicsDGF | Set the tendon compliance dynamics mode to "implicit" for all DeGrooteFregly2016Muscles in the model |
| CMomentArmSolver | Solve for the effective moment arms at all degrees-of-freedom due to one or more point forces |
| CMovingPathPoint | A class implementing a moving muscle point, which is a muscle point that moves in a body's reference frame as a function of a coordinate |
| CMultiplierFunction | A class implementing a Function and a scale factor for the function's value |
| CMultivariatePolynomialFunction | A multivariate polynomial function |
| ►CMuscle | A base class for modeling a muscle-tendon actuator |
| CFiberVelocityInfo | FiberVelocityInfo contains velocity quantities related to the velocity of the muscle (fiber + tendon) complex |
| CMuscleDynamicsInfo | MuscleDynamicsInfo contains quantities that are related to the forces that the muscle generates |
| CMuscleLengthInfo | The MuscleLengthInfo struct contains information about the muscle that is strictly a function of the length of the fiber and the tendon, and the orientation of the muscle fiber |
| CMusclePotentialEnergyInfo | MusclePotentialEnergyInfo contains quantities related to the potential energy of the muscle (fiber + tendon) complex |
| ►CMuscleActivationDynamics | An abstract class for modeling muscle activation dynamics |
| CExcitationGetter | The ExcitationGetter abstract class defines a standard interface for supplying muscle excitation to activation models |
| CMuscleActiveFiberPowerProbe | MuscleActiveFiberPowerProbe is a ModelComponent probe for computing an operation on the active fiber power of a muscle |
| ►CMuscleAnalysis | A class for recording and computing basic quantities (length, shortening velocity, tendon length, ...) for muscles during a simulation |
| Cprivate | |
| CMuscleCannotEquilibrate | |
| CMuscleFirstOrderActivationDynamicModel | This is a muscle modeling utility class that computes the time derivative of activation using a first-order dynamic model |
| CMuscleFixedWidthPennationModel | This is a muscle modeling utility class containing kinematic equations that describe the deformation of muscle fibers as they change length using a fixed-width-parallelogram pennation model |
| CMuscleSecondOrderActivationDynamicModel | This function is a muscle modeling utility class that simulates dynamics of muscle force development as a function of input excitation |
| CMuscleStateTrackingTask | A TrackingTask for that corresponds to a muscle state variable |
| CNoColumnLabels | |
| CNonUniqueLabels | |
| CNoRegisteredDataAdapter | |
| CNoTableFound | |
| CObject | This is the base class for all OpenSim objects that are serializable (meaning they can be written to and read back from files) |
| CObject_GetClassName | |
| CObject_GetClassName< bool > | |
| CObject_GetClassName< char > | |
| CObject_GetClassName< double > | |
| CObject_GetClassName< float > | |
| CObject_GetClassName< int > | |
| CObject_GetClassName< long double > | |
| CObject_GetClassName< long int > | |
| CObject_GetClassName< long long int > | |
| CObject_GetClassName< short int > | |
| CObject_GetClassName< signed char > | |
| CObject_GetClassName< SimTK::Quaternion_< SimTK::Real > > | |
| CObject_GetClassName< SimTK::Rotation_< SimTK::Real > > | |
| CObject_GetClassName< SimTK::SpatialVec > | |
| CObject_GetClassName< SimTK::Transform > | |
| CObject_GetClassName< SimTK::Vec2 > | |
| CObject_GetClassName< SimTK::Vec3 > | |
| CObject_GetClassName< SimTK::Vec6 > | |
| CObject_GetClassName< SimTK::Vector_< SimTK::Real > > | |
| CObject_GetClassName< SimTK::Vector_< SimTK::SpatialVec > > | |
| CObject_GetClassName< SimTK::Vector_< SimTK::Vec3 > > | |
| CObject_GetClassName< SimTK::Vector_< SimTK::Vec6 > > | |
| CObject_GetClassName< std::string > | |
| CObject_GetClassName< unsigned char > | |
| CObject_GetClassName< unsigned int > | |
| CObject_GetClassName< unsigned long int > | |
| CObject_GetClassName< unsigned long long int > | |
| CObject_GetClassName< unsigned short int > | |
| CObjectGroup | A class implementing an object group |
| CObjectProperty | |
| COffsetFrame | An OffsetFrame is a Frame whose transform (translation and orientation) with respect to another (parent) Frame is constant in time |
| COpenSenseUtilities | |
| COptimizationTarget | This class provides an interface specification for optimizing redundant systems |
| COrientationsReference | Reference values for the Orientations of model frames that will be used to to compute tracking errors |
| COrientationWeight | |
| COrientationWeightSet | |
| ►COutput | |
| CChannel | |
| COutputNotFound | |
| COutputReporter | The OutputReporter Analysis is a wrapper for a TableReporter |
| CPathActuator | This is the base class for actuators that apply controllable tension along a geometry path |
| CPathPoint | A path point that is stationary with respect to parent's PhysicalFrame |
| CPathPointSet | A class for holding a set of path points |
| CPathSpring | A class implementing a PathSpring |
| CPathWrapPoint | A class implementing a path wrapping point, which is a path point that is produced by a PathWrap |
| CPhysicalFrame | A PhysicalFrame is a Frame that locates a physical element of the multi- body system that underlies a Model |
| CPhysicalOffsetFrame | A PhysicalOffsetFrame is a PhysicalFrame whose transform is specified as a constant offset from another PhysicalFrame |
| CPhysicalOffsetFramesFormLoop | |
| CPiecewiseConstantFunction | A class implementing a step function |
| CPiecewiseLinearFunction | A class implementing a linear function |
| CPinJoint | A Class implementing a Pin joint |
| CPlanarJoint | A class implementing a Planar joint |
| CPoint | A Point is an OpenSim abstraction for any location in space |
| CPointActuator | A class that implements a point actuator acting on the model |
| CPointConstraint | A class implementing a Point Constraint |
| CPointForceDirection | Convenience class for a generic representation of geometry of a complex Force (or any other object) with multiple points of contact through which forces are applied to bodies |
| CPointKinematics | A class for recording the kinematics of a point on a body of a model during a simulation |
| CPointOnLineConstraint | A class implementing a Point On Line Constraint |
| CPointToPointActuator | A class that implements a force actuator acting between two points on two bodies |
| CPointToPointSpring | A simple point to point spring with a resting length and stiffness |
| CPolynomialFunction | A class for representing a Polynomial of x |
| CPositionMotion | This class prescribes the value, speed, and acceleration of all coordinates in the model using SimTK::Motion |
| CPrescribedController | PrescribedController is a concrete Controller that specifies functions that prescribe the control values of its actuators as a function of time |
| CPrescribedForce | This applies to a PhysicalFrame a force and/or torque that is specified as a function of time |
| CProbe | This class represents a Probe which is designed to query a Vector of model values given system state |
| CProbeReporter | A class for reporting the outputs of all model-connected Probes to file during a simulation |
| CProbeSet | A class for holding a set of probes |
| ►CProperty | A Property<T> is a serializable (name, list-of-values) pair, where each value is of type T |
| CTypeHelper | This is the generic definition of Property::TypeHelper to be used whenever T does not have a specialization, meaning that T must be a type derived from class Object |
| CProperty_Deprecated | |
| CPropertyBool | Class PropertyBool extends class Property |
| CPropertyBoolArray | Class PropertyBoolArray extends class Property |
| CPropertyDbl | Class PropertyDbl extends class Property |
| CPropertyDblArray | Class PropertyDblArray extends class Property |
| CPropertyDblVec_ | Class PropertyDblVec_ extends class Property |
| CPropertyGroup | A class implementing a property group |
| CPropertyInt | Class PropertyInt extends class Property |
| CPropertyIntArray | Class PropertyIntArray extends class Property |
| CPropertyObj | Class PropertyObj extends class Property |
| CPropertyObjArray | Class PropertyObjArray extends class Property |
| CPropertyObjPtr | Class PropertyObjPtr extends class Property |
| CPropertySet | A property set is simply a set of properties |
| CPropertyStr | Class PropertyStr extends class Property |
| CPropertyStrArray | Class PropertyStrArray extends class Property |
| CPropertyTable | A property table is the container that an OpenSim Object uses to hold its properties (each derived from base class AbstractProperty) |
| CPropertyTransform | Class PropertyTransform extends class Property |
| CReference_ | This base (abstract) class defines the interface for a Reference signals to be achieved/tracked via optimization and/or tracking controller |
| CReporter | This is an abstract Reporter with a single list Input named "inputs" whose type is templated (InputT) |
| CRigidTendonMuscle | A class implementing a RigidTendonMuscle actuator with no states |
| CRollingOnSurfaceConstraint | A class implementing a collection of rolling-without-slipping and non-penetration constraints on a surface |
| CRootSolver | A class for finding the N roots of N one-dimensional non-linear equations |
| CRowIndexOutOfRange | |
| CRowLengthMismatch | |
| CRRATool | An abstract class for specifying the interface for an investigation |
| CScalarActuator | This is a derived class from the base class actuator (e.g., a torque motor, muscle, ...) that requires exactly one external input (control) to generate a scalar value force, such as a torque/force magnitude or a tension |
| CScale | |
| CScaleSet | |
| CScaleTool | A class implementing a set of parameters describing how to scale a model to fit a subject, place markers on it, and do IK on one or more motion trials |
| CScapulothoracicJoint | A class implementing a 4-DOF ScapulothoracicJoint |
| CSchutte1993Muscle_Deprecated | A class implementing a SIMM muscle |
| CSegmentedQuinticBezierToolkit | This is a low level Quintic Bezier curve class that contains functions to design continuous sets of 'C' shaped Bezier curves, and to evaluate their values and derivatives |
| CSet | A class for holding a set of pointers to objects |
| CSignal | A class for signal processing |
| CSignalGenerator | SignalGenerator is a type of Component with no inputs and only one output |
| CSimbodyEngine | A wrapper class to use the SimTK Simbody dynamics engine as the underlying engine for OpenSim |
| CSimmSpline | A class implementing a smooth function with a cubic spline as implemented in SIMM |
| CSimpleProperty | |
| CSine | A class for representing a Sine function |
| CSliderJoint | A class implementing a Slider joint |
| CSMC_Joint | A class for specifying the tracking task for a joint |
| CSmoothSegmentedFunction | This class contains the quintic Bezier curves, x(u) and y(u), that have been created by SmoothSegmentedFunctionFactory to follow a physiologically meaningful muscle characteristic |
| CSmoothSegmentedFunctionFactory | This is a class that acts as a user friendly wrapper to QuinticBezerCurveSet to build specific kinds of physiologically plausible muscle curves using C2 continuous sets of quintic Bezier curves |
| CSmoothSphereHalfSpaceForce | This compliant contact force model is similar to HuntCrossleyForce, except that this model applies force even when not in contact |
| CSocket | |
| CSocketNotFound | |
| CSolver | The base (abstract) class for a family of objects responsible for solving system equations (statics, dynamic, kinematics, muscle, etc...) given by a model for values of interest |
| CSpatialTransform | A class encapsulating the spatial transformation between two bodies that defines the behavior of a custom joint |
| CSphere | A class to represent Sphere geometry |
| CSpringGeneralizedForce | A Force that exerts a generalized force based on spring-like characteristics (stiffness and viscosity) |
| CStatesReporter | A class for recording the states of a model during a simulation |
| ►CStatesTrajectory | |
| CDataIsInDegrees | Thrown by createFromStatesStorage() |
| CExtraColumns | Thrown when trying to create a StatesTrajectory from states data, and the data contains columns that do not correspond to continuous state variables |
| CIncompatibleModel | Thrown when trying to use a StatesTrajectory with an incompatible model |
| CInconsistentState | Thrown when trying to append a state that is not consistent with the rest of the trajectory |
| CMissingColumns | Thrown when trying to create a StatesTrajectory from states data, and the data does not contain a column for every continuous state variable |
| CStatesTrajectoryReporter | Stores the states during a simulation in a StatesTrajectory |
| CStateTrackingTask | A tracking task objective that corresponds to a state variable of a Force component (e.g |
| CStateVector | A class which stores a vector of states or data at a specified time |
| CStaticOptimization | This class implements static optimization to compute Muscle Forces and activations |
| CStaticOptimizationTarget | This class provides an interface specification for static optimization Objective Function |
| CStation | A Station is a Point fixed to and located on a PhysicalFrame, which can be a Body, Ground or any PhysicalOffsetFrame |
| CStationPlaneContactForce | This class models compliant point contact with a ground plane y=0 |
| CStepFunction | A class for representing a StepFunction |
| CSTODataTypeNotSupported | |
| CSTOFileAdapter_ | STOFileAdapter is a DelimFileAdapter that presets the delimiters appropriately for STO files |
| CStopwatch | Record and report elapsed real time ("clock" or "wall" time) in seconds |
| CStorage | A class for storing an array of statevectors |
| CStorageCreator | |
| CStorageFactory | |
| CStorageInterface | |
| CStreamableReference_ | |
| CStringLogSink | This sink stores all messages in a string |
| CSubcomponentsWithDuplicateName | |
| CSurfaceProperties | SurfaceProperties class holds the appearance properties of a piece of Geometry displayed in the OpenSim visualizer or GUI as a surface |
| CSystemEnergyProbe | SystemEnergyProbe is a ModelComponent Probe for computing an operation on a total system energy during a simulation |
| CTableMissingHeader | |
| CTableNotFoundException | |
| CTableOperator | This abstract class describes any operation that consumes and modifies a TimeSeriesTable as part of a TableProcessor |
| CTableProcessor | This class describes a workflow for processing a table using TableOperators |
| CTableReporter_ | This concrete Reporter class collects and reports Output<InputT>s within a TimeSeriesTable_ |
| CTableSource_ | Component representing a source of data from a TimeSeriesTable_ |
| CTableUtilities | |
| CTabOpConvertDegreesToRadians | |
| CTabOpLowPassFilter | Apply a low-pass filter to the trajectory |
| CTabOpUseAbsoluteStateNames | Update table column labels to use post-4.0 state paths instead of pre-4.0 state names |
| CTendonForceLengthCurve | This class serves as a serializable TendonForceLengthCurve for use in muscle models |
| CThelen2003Muscle | Implementation of a two state (activation and fiber-length) Muscle model by Thelen 2003. This a complete rewrite of a previous implementation (present in OpenSim 2.4 and earlier) contained numerous errors |
| CThelen2003Muscle_Deprecated | A class implementing a SIMM muscle |
| CThreadsafeJar | This class lets you store objects of a single type for reuse by multiple threads, ensuring threadsafe access to each of those objects |
| CTimeColumnNotIncreasing | |
| CTimeOutOfRange | |
| CTimeSeriesTable_ | TimeSeriesTable_ is a DataTable_ where the independent column is time of type double |
| CTimestampGreaterThanEqualToNext | |
| CTimestampLessThanEqualToPrevious | |
| CTool | A Tool is an OpenSim abstraction that encapsulates an analysis or series of modeling and analysis steps |
| CTorqueActuator | A TorqueActuator applies equal and opposite torques on the two bodies (bodyA and B) that it connects |
| CTorus | A class to represent Torus geometry |
| CTrackingController | TrackingController is an abstract class from which all tracking type of controllers should be derived |
| CTrackingTask | An abstract base class for specifying a target for a tracking problem |
| CTransformAxis | A class expressing a transformation of a child body in relation to a parent body along either a translation or about a rotation axis |
| CTRCFileAdapter | TRCFileAdapter is a FileAdapter that reads and writes TRC files |
| CTwoFrameLinker | TwoFrameLinker is a utility class to extend a Component such that it connects two Frames |
| CUmberger2010MuscleMetabolicsProbe | Umberger2010MuscleMetabolicsProbe is a Probe ModelComponent for computing the net metabolic energy rate of a set of Muscles in the model during a simulation |
| CUmberger2010MuscleMetabolicsProbe_MetabolicMuscleParameter | Documentation for this class has been provided with the documentation for the Umberger2010MuscleMetabolicsProbe class |
| CUmberger2010MuscleMetabolicsProbe_MetabolicMuscleParameterSet | MetabolicMuscleParameterSet is an internal container class containing the set of MetabolicMuscleParameters for each muscle that is probed |
| CUnexpectedColumnLabel | |
| CUnexpectedMetaDataKey | |
| CUnilateralConstraint | An abstract class defining an OpenSim UnilateralConstraint |
| CUnits | A class implementing various units for measuring quantities |
| CUniversalJoint | A class implementing a Universal joint |
| CUnsupportedFileType | |
| CValueArray | |
| CValueArrayDictionary | ValueArrayDictionary represents an associative array mapping from a string to an AbstractValueArray |
| CVectorFunction | An abstract class for representing a vector function |
| CVectorFunctionForActuators | An abstract class for representing a vector function |
| CVectorFunctionUncoupledNxN | An abstract class for representing a vector function |
| CVisualizerUtilities | |
| CWeldConstraint | A class implementing a Weld Constraint |
| CWeldJoint | A class implementing a Weld joint |
| CWrapCylinder | A class implementing a cylinder for muscle wrapping |
| CWrapEllipsoid | A class implementing an ellipsoid for muscle wrapping |
| CWrapObject | An abstract class that specifies the interface for a wrapping object |
| CWrapObjectSet | A class for holding a set of wrap objects |
| CWrapSphere | A class implementing a sphere for muscle wrapping |
| CWrapTorus | A class implementing a torus for muscle wrapping |
| CXMLDocument | |
| CXsensDataReader | XsensDataReader is a class that reads files produced by IMU manufacturer Xsens and produces datatables from them |
| CXsensDataReaderSettings | XsensDataReaderSettings is a class that reads files produced by IMU manufacturer Xsens and produces datatables from them |
| CZerothOrderMuscleActivationDynamics | This zeroth-order muscle activation dynamic model simply sets activation to excitation, and can be used when activation dynamics are being ignored |
| ►NSimTK | |
| CDefaultGeometry | |
| CCoordinateIndex | Unique integer type for local Coordinate indexing |
| CMemberSubcomponentIndex | Unique integer type for local member subcomponent indexing |
| CosimInstantiator | |
| CosimMocoInstantiator |
1.8.13