Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

►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
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)
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
CMocoContactImpulseTrackingGoal
CMocoContactImpulseTrackingGoalGroup
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
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
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
►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
CosimInstantiator
CosimMocoInstantiator