Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678910]

►COpenSim::AbstractChannel	One of the values of an Output
COpenSim::Output< T >::Channel
►COpenSim::AbstractDataTable	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
►COpenSim::DataTable_< double, SimTK::Real >
COpenSim::TimeSeriesTable_< SimTK::Real >
COpenSim::TimeSeriesTable_< ETY >	TimeSeriesTable_ is a DataTable_ where the independent column is time of type double
COpenSim::DataTable_< ETX, ETY >	DataTable_ is an in-memory storage container for data with support for holding metadata (using the base class AbstractDataTable)
►COpenSim::AbstractOutput	Output formalizes the access to a value of interest computed by the owning Component
COpenSim::Output< T >
►COpenSim::AbstractProperty	An abstract property is a serializable (name,value) pair, for which we do not know the type of the value
COpenSim::Property< T >	A Property<T> is a serializable (name, list-of-values) pair, where each value is of type T
►COpenSim::Property_Deprecated
COpenSim::PropertyDblVec_< 3 >
COpenSim::PropertyDblVec_< 2 >
COpenSim::PropertyBool	Class PropertyBool extends class Property
COpenSim::PropertyBoolArray	Class PropertyBoolArray extends class Property
COpenSim::PropertyDbl	Class PropertyDbl extends class Property
►COpenSim::PropertyDblArray	Class PropertyDblArray extends class Property
COpenSim::PropertyTransform	Class PropertyTransform extends class Property
COpenSim::PropertyDblVec_< M >	Class PropertyDblVec_ extends class Property
COpenSim::PropertyInt	Class PropertyInt extends class Property
COpenSim::PropertyIntArray	Class PropertyIntArray extends class Property
COpenSim::PropertyObj	Class PropertyObj extends class Property
COpenSim::PropertyObjArray< T >	Class PropertyObjArray extends class Property
COpenSim::PropertyObjPtr< T >	Class PropertyObjPtr extends class Property
COpenSim::PropertyStr	Class PropertyStr extends class Property
COpenSim::PropertyStrArray	Class PropertyStrArray extends class Property
►COpenSim::AbstractSocket	A Socket formalizes the dependency between a Component and another object (typically another Component) without owning that object
►COpenSim::AbstractInput	A specialized Socket that connects to an Output signal is an Input
COpenSim::Input< T >	An Input<Y> must be connected by an Output<Y>
COpenSim::Socket< T >
►COpenSim::AbstractValueArray	ValueArray (of type T) represents an array of SimTK::Value (of type T)
COpenSim::ValueArray< T >
COpenSim::Array< T >	A class for storing an array of values of type T
COpenSim::ArrayPtrs< T >
►Cspdlog::sinks::base_sink
►COpenSim::LogSink	Derive from this class to implement your own way of reporting logged messages
COpenSim::StringLogSink	This sink stores all messages in a string
►COpenSim::ComponentFilter	A class to specify a filter to be used to iterate through components
COpenSim::ComponentFilterAbsolutePathNameContainsString	A component is considered a match if its absolute path name contains the given string
COpenSim::ComponentFilterMatchAll	ComponentFilterMatchAll is a trivial Filter that matches all components
COpenSim::ComponentList< T >	Collection (linked list) of components to iterate through
COpenSim::ComponentPath	A representation of a path within a Component tree
►CContactParameters public Object
COpenSim::ElasticFoundationForce	This Force subclass implements an elastic foundation contact model
COpenSim::HuntCrossleyForce	This force subclass implements a Hunt-Crossley contact model
►CContactParametersSet public Set
COpenSim::ElasticFoundationForce	This Force subclass implements an elastic foundation contact model
COpenSim::HuntCrossleyForce	This force subclass implements a Hunt-Crossley contact model
COpenSim::IO::CwdChanger	A class that:
►COpenSim::DataAdapter	DataAdapter is an abstract class defining an interface for reading/writing in/out the contents of a DataTable
►COpenSim::FileAdapter	FileAdapter is a DataAdapter that reads and writes files with methods read and writeFile respectively
►COpenSim::DelimFileAdapter< double >
COpenSim::CSVFileAdapter	CSVFileAdapter is a DelimFileAdapter that presets the delimiters appropriately for CSV files
►COpenSim::DelimFileAdapter< T >	DelimFileAdapter is a FileAdapter that reads and writes text files with given delimiters
COpenSim::STOFileAdapter_< T >	STOFileAdapter is a DelimFileAdapter that presets the delimiters appropriately for STO files
COpenSim::TRCFileAdapter	TRCFileAdapter is a FileAdapter that reads and writes TRC files
►COpenSim::IMUDataReader
COpenSim::APDMDataReader	APDMDataReader is a class that reads files produced by IMU manufacturer APDM and produces datatables from them
COpenSim::XsensDataReader	XsensDataReader is a class that reads files produced by IMU manufacturer Xsens and produces datatables from them
COpenSim::DataQueue_< T >	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
COpenSim::DataQueueEntry_< U >	This base class defines the interface for a DataQueue
►CDecorationGenerator
CSimTK::DefaultGeometry
►CSimTK::Xml::Document
COpenSim::XMLDocument
COpenSim::Event	Struct representing an event extracted from a C3D file
►Cstd::exception
►COpenSim::Exception	A class for basic exception functionality
COpenSim::ComponentAlreadyPartOfOwnershipTree
COpenSim::ComponentHasNoName	Component Exceptions
COpenSim::ComponentHasNoSystem
COpenSim::ComponentIsAnOrphan
COpenSim::ComponentIsRootWithNoSubcomponents
►COpenSim::ComponentNotFound
COpenSim::ComponentNotFoundOnSpecifiedPath
COpenSim::ConnecteeNotSpecified
COpenSim::DataAdapterAlreadyRegistered
COpenSim::DataTypeMismatch
COpenSim::EmptyTable
COpenSim::FileDeletionThrowerException	Thrown by FileDeletionThrower::throwIfDeleted()
►COpenSim::IOError
COpenSim::FileDoesNotExist
COpenSim::FileIsEmpty
COpenSim::IncorrectNumColumnLabels
COpenSim::IncorrectNumMetaDataKeys
COpenSim::MetaDataLengthMismatch
COpenSim::MissingHeader
COpenSim::RowLengthMismatch
COpenSim::UnexpectedColumnLabel
COpenSim::UnexpectedMetaDataKey
COpenSim::IncorrectMetaDataLength
COpenSim::IncorrectNumTokens
►COpenSim::IndexOutOfRange
COpenSim::ColumnIndexOutOfRange
COpenSim::RowIndexOutOfRange
COpenSim::InputNotConnected	ComponentSocket Exceptions
COpenSim::InputNotFound
►COpenSim::InvalidArgument
COpenSim::EmptyFileName
COpenSim::FileExtensionNotFound
COpenSim::IncorrectTableType
COpenSim::KeyMissing
COpenSim::NoTableFound
COpenSim::InvalidCall
►COpenSim::InvalidColumn
COpenSim::IncorrectNumRows
COpenSim::InvalidColumnLabel
COpenSim::InvalidComponentName
COpenSim::InvalidPropertyValue	Property Exceptions
►COpenSim::InvalidRow
COpenSim::IncorrectNumColumns
►COpenSim::InvalidTimestamp
COpenSim::TimestampGreaterThanEqualToNext
COpenSim::TimestampLessThanEqualToPrevious
►COpenSim::InvalidTable
COpenSim::TimeColumnNotIncreasing
COpenSim::InvalidTemplateArgument
COpenSim::InvalidTimeRange
COpenSim::JointFramesAreTheSame
COpenSim::JointFramesHaveSameBaseFrame
COpenSim::JointHasNoCoordinates
COpenSim::KeyExists
COpenSim::KeyNotFound
COpenSim::MissingMetaData
COpenSim::MocoCasADiSolverNotAvailable
COpenSim::MocoTrajectoryIsSealed	This exception is thrown if you try to invoke most methods on MocoTrajectory while the trajectory is sealed
COpenSim::MocoTropterSolverNotAvailable
COpenSim::ModelHasNoSystem	Model Exceptions
COpenSim::MuscleCannotEquilibrate
COpenSim::NoColumnLabels
COpenSim::NoRegisteredDataAdapter
COpenSim::NonUniqueLabels
COpenSim::OutputNotFound
COpenSim::PhysicalOffsetFramesFormLoop
COpenSim::STODataTypeNotSupported
COpenSim::SocketNotFound
COpenSim::StatesTrajectory::DataIsInDegrees	Thrown by createFromStatesStorage()
COpenSim::StatesTrajectory::ExtraColumns	Thrown when trying to create a StatesTrajectory from states data, and the data contains columns that do not correspond to continuous state variables
COpenSim::StatesTrajectory::IncompatibleModel	Thrown when trying to use a StatesTrajectory with an incompatible model
COpenSim::StatesTrajectory::InconsistentState	Thrown when trying to append a state that is not consistent with the rest of the trajectory
COpenSim::StatesTrajectory::MissingColumns	Thrown when trying to create a StatesTrajectory from states data, and the data does not contain a column for every continuous state variable
COpenSim::SubcomponentsWithDuplicateName
COpenSim::TableMissingHeader
COpenSim::TableNotFoundException
COpenSim::TimeOutOfRange
COpenSim::UnsupportedFileType
COpenSim::MuscleActivationDynamics::ExcitationGetter	The ExcitationGetter abstract class defines a standard interface for supplying muscle excitation to activation models
COpenSim::FileDeletionThrower	This class helps a user cause an exception within the code
COpenSim::FileRemover	When an instance of this class is destructed, it removes (deletes) the file at the path provided in the constructor
►CSimTK::Function_
COpenSim::SmoothSegmentedFunction	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
COpenSim::MocoGoal::GoalInput
►CSimTK::Force::Custom::Implementation
COpenSim::ForceAdapter	This acts as an adapter to allow a Force or Actuator to be used as a SimTK::Force
COpenSim::MocoGoal::IntegrandInput
COpenSim::IO	A class for performing input and output with OpenSim API
►Cstd::iterator
COpenSim::ComponentListIterator< T >	Class used to iterate over subcomponents of a specific type (by default, any Component)
COpenSim::Logger	This is a singleton class (single instance) for logging messages and controlling how those messages are presented to the user
COpenSim::Manager	A class that manages the execution of a simulation
COpenSim::MocoInverseSolution	This class holds the solution from MocoInverse
COpenSim::MocoKinematicConstraint	A model kinematic constraint to be enforced in the optimal control problem
COpenSim::MocoProblemInfo	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()
COpenSim::MocoProblemRep	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
COpenSim::MocoStudyFactory	This class creates MocoStudies of common interest
►COpenSim::MocoTrajectory	The values of the variables in an optimal control problem
COpenSim::MocoSolution	Return type for MocoStudy::solve()
COpenSim::ModelFactory	This class provides utilities for creating OpenSim models
COpenSim::ModelVisualizer	This class manages runtime visualization of a Model that is being manipulated through the OpenSim API
►COpenSim::Object	This is the base class for all OpenSim objects that are serializable (meaning they can be written to and read back from files)
►COpenSim::Reference_< double >
COpenSim::CoordinateReference	Reference value to be achieved for a specified coordinate that will be used via optimization and/or tracking
►COpenSim::Reference_< SimTK::Vec3 >
COpenSim::MarkersReference	Reference values to be achieved for specified Markers that will be used via optimization and/or tracking
►COpenSim::Set< Analysis >
COpenSim::AnalysisSet	A class for holding and managing a set of integration callbacks for a model
►COpenSim::Set< Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameter >
COpenSim::Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameterSet	MetabolicMuscleParameterSet is a class that holds the set of MetabolicMuscleParameters for each muscle
►COpenSim::Set< BodyScale >
COpenSim::BodyScaleSet	A class for holding a set of body scales
►COpenSim::Set< TrackingTask >
COpenSim::CMC_TaskSet	An class for holding and managing a set of tasks
►COpenSim::Set< Control >
COpenSim::ControlSet	A class for holding and managing a set of controls for a dynamic simulation
►COpenSim::Set< Coordinate >
COpenSim::CoordinateSet	A class for holding a set of coordinates
►COpenSim::Set< Function >
►COpenSim::FunctionSet	A class for holding a set of functions
COpenSim::GCVSplineSet	A class for holding a set of generalized cross-validated splines
►COpenSim::Set< IKTask >
COpenSim::IKTaskSet
►COpenSim::Set< MarkerPair >
COpenSim::MarkerPairSet	A class for holding a set of SimmMarkerPairs
►COpenSim::Set< Measurement >
COpenSim::MeasurementSet	A class for holding a set of measurements
►COpenSim::Set< MocoWeight >
COpenSim::MocoWeightSet	A container for Moco weights
►COpenSim::Set< OrientationWeight >
COpenSim::OrientationWeightSet
►COpenSim::Set< AbstractPathPoint >
COpenSim::PathPointSet	A class for holding a set of path points
►COpenSim::Set< Scale >
COpenSim::ScaleSet
►COpenSim::Set< Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameter >
COpenSim::Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameterSet	MetabolicMuscleParameterSet is an internal container class containing the set of MetabolicMuscleParameters for each muscle that is probed
COpenSim::APDMDataReaderSettings	APDMDataReaderSettings is a class that reads files produced by IMU manufacturer APDM and produces datatables from them
►COpenSim::AbstractTool	An abstract class for specifying the interface for an investigation
COpenSim::AnalyzeTool	An abstract class for specifying the interface for an investigation
COpenSim::CMCTool	An abstract class for specifying the interface for an investigation
COpenSim::ForwardTool	A concrete tool for performing forward dynamics simulations
COpenSim::RRATool	An abstract class for specifying the interface for an investigation
►COpenSim::Analysis	An abstract class for specifying the interface for an analysis plugin
COpenSim::Actuation	A class for recording the basic actuator information for a model during a simulation
COpenSim::BodyKinematics	A class for recording the kinematics of the bodies of a model during a simulation
COpenSim::ForceReporter	A class for recording the Forces applied to a model during a simulation
COpenSim::IMUDataReporter	A class for recording the readings off an IMU object placed on a model during a simulation
COpenSim::InducedAccelerations	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
COpenSim::JointReaction	An analysis for reporting the joint reaction loads from a model
COpenSim::Kinematics	A class for recording the kinematics of the generalized coordinates of a model during a simulation
COpenSim::MuscleAnalysis	A class for recording and computing basic quantities (length, shortening velocity, tendon length, ...) for muscles during a simulation
COpenSim::OutputReporter	The OutputReporter Analysis is a wrapper for a TableReporter
COpenSim::PointKinematics	A class for recording the kinematics of a point on a body of a model during a simulation
COpenSim::ProbeReporter	A class for reporting the outputs of all model-connected Probes to file during a simulation
COpenSim::StatesReporter	A class for recording the states of a model during a simulation
COpenSim::StaticOptimization	This class implements static optimization to compute Muscle Forces and activations
COpenSim::Appearance	A class that holds the Appearance properties of Geometry displayed in the OpenSim Visualizer
COpenSim::Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameter	Documentation for this class has been provided with the documentation for the Bhargava2004MuscleMetabolicsProbe class
COpenSim::BodyScale	A class implementing a set of parameters describing how to scale a body segment
►COpenSim::Component	The abstract Component class defines the interface used to add computational elements to the underlying SimTK::System (MultibodySystem)
►COpenSim::AbstractReporter	This abstract class represents a Reporter that generates a report from values generated by Components in a Model during a simulation
►COpenSim::Reporter< T >
COpenSim::ConsoleReporter_< T >	A reporter that simply prints quantities to the console (command window or terminal), perhaps to monitor the progress of a simulation as it executes
►COpenSim::Reporter< SimTK::Real >
COpenSim::TableReporter_< InputT, ValueT >	This concrete Reporter class collects and reports Output<InputT>s within a TimeSeriesTable_
COpenSim::Reporter< InputT >	This is an abstract Reporter with a single list Input named "inputs" whose type is templated (InputT)
COpenSim::StatesTrajectoryReporter	Stores the states during a simulation in a StatesTrajectory
COpenSim::Bhargava2004SmoothedMuscleMetabolics_MuscleParameters	Object class that holds the metabolic parameters required to calculate metabolic power for a single muscle
►COpenSim::Geometry	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
►COpenSim::AnalyticGeometry	Abstract class for analytical geometry (e.g
COpenSim::Cone	A class to represent a Cone geometry
COpenSim::Cylinder	A class to represent a Cylinder geometry
COpenSim::Ellipsoid	A class to represent an Ellipsoid geometry
COpenSim::Sphere	A class to represent Sphere geometry
COpenSim::Torus	A class to represent Torus geometry
COpenSim::Arrow	Arrow is a Geometry subclass used to represent an arrow
COpenSim::Brick	A class to represent Brick geometry
COpenSim::FrameGeometry	A class to represent Frame geometry
COpenSim::LineGeometry	LineGeometry is a utility class used to abstract a line segment
COpenSim::Mesh	A class to represent Mesh geometry that comes from a file
COpenSim::MocoScaleFactor	A scale factor is a scalar value optimized by Moco that can be used to scale a tracked reference quantity in the cost function
►COpenSim::ModelComponent	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)
►COpenSim::Set< ModelComponent, ModelComponent >
►COpenSim::ModelComponentSet< ModelComponent >
COpenSim::ComponentSet	A class for holding a set of miscellaneous model components
COpenSim::ModelComponentSet< T >
COpenSim::AccelerationMotion	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)
COpenSim::Bhargava2004SmoothedMuscleMetabolics	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
►COpenSim::Constraint	A parent class for implementing a Simbody Constraint
►COpenSim::TwoFrameLinker< Constraint, PhysicalFrame >
COpenSim::WeldConstraint	A class implementing a Weld Constraint
COpenSim::ConstantDistanceConstraint	A class implementing a constraint that maintains a constant distance between between two points on separate PhysicalFrames
COpenSim::CoordinateCouplerConstraint
COpenSim::PointConstraint	A class implementing a Point Constraint
COpenSim::PointOnLineConstraint	A class implementing a Point On Line Constraint
►COpenSim::UnilateralConstraint	An abstract class defining an OpenSim UnilateralConstraint
COpenSim::RollingOnSurfaceConstraint	A class implementing a collection of rolling-without-slipping and non-penetration constraints on a surface
►COpenSim::ContactGeometry	This class represents the physical shape of an object for use in contact modeling
COpenSim::ContactHalfSpace	This class represents a half space (that is, everything to one side of an infinite plane) for use in contact modeling
COpenSim::ContactMesh	This class represents a polygonal mesh for use in contact modeling
COpenSim::ContactSphere	This class represents a spherical object for use in contact modeling
►COpenSim::Controller	Controller is an abstract ModelComponent that defines the interface for an OpenSim Controller
COpenSim::ControlSetController	ControlSetController that simply assigns controls from a ControlSet
COpenSim::DiscreteController	This component is used internally by Moco for passing a solver's control variables to a Model
COpenSim::PrescribedController	PrescribedController is a concrete Controller that specifies functions that prescribe the control values of its actuators as a function of time
►COpenSim::TrackingController	TrackingController is an abstract class from which all tracking type of controllers should be derived
COpenSim::CMC	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)
COpenSim::CorrectionController	This is a simple feedback controller to be used in generating a forward dynamic simulation
COpenSim::Coordinate	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)
COpenSim::DiscreteForces	This class is a thin wrapper to Simbody's SimTK::Force::DiscreteForces class
►COpenSim::Force	This abstract class represents a force applied to bodies or generalized coordinates during a simulation
►COpenSim::TwoFrameLinker< Force, PhysicalFrame >
COpenSim::BushingForce	A class implementing a Bushing Force
COpenSim::ExpressionBasedBushingForce	A class implementing a bushing force specified by expressions of the deflection between two bushing frames
COpenSim::FunctionBasedBushingForce	A class implementing a bushing force specified by functions of the frame deflections
►COpenSim::Actuator	Base class for an actuator (e.g., a torque motor, muscle, ...) that requires a generic external input (a vector of controls) to generate force
COpenSim::BodyActuator	Apply a spatial force (that is, [torque, force]) on a given point of the given body
►COpenSim::ScalarActuator	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
►COpenSim::CoordinateActuator	An actuator that applies a generalized force in the direction of a generalized coordinate
COpenSim::ActivationCoordinateActuator	Similar to CoordinateActuator (simply produces a generalized force) but with first-order linear activation dynamics
►COpenSim::PathActuator	This is the base class for actuators that apply controllable tension along a geometry path
COpenSim::ClutchedPathSpring	The ClutchedPathSpring is an actuator that has passive path spring behavior only when the clutch is engaged
COpenSim::McKibbenActuator	McKibben Pneumatic Actuator Model based on the simple cylindrical formulation described in J
►COpenSim::Muscle	A base class for modeling a muscle-tendon actuator
►COpenSim::ActivationFiberLengthMuscle	A base class representing a two-state muscle-tendon actuator
COpenSim::Thelen2003Muscle	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
►COpenSim::ActivationFiberLengthMuscle_Deprecated	A base class representing a muscle-tendon actuator
COpenSim::Delp1990Muscle_Deprecated	A class implementing a SIMM muscle
COpenSim::Schutte1993Muscle_Deprecated	A class implementing a SIMM muscle
COpenSim::Thelen2003Muscle_Deprecated	A class implementing a SIMM muscle
COpenSim::DeGrooteFregly2016Muscle	This muscle model was published in De Groote et al
COpenSim::Millard2012AccelerationMuscle	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
COpenSim::Millard2012EquilibriumMuscle	This class implements a configurable equilibrium muscle model, as described in Millard et al. (2013)
COpenSim::RigidTendonMuscle	A class implementing a RigidTendonMuscle actuator with no states
COpenSim::PointActuator	A class that implements a point actuator acting on the model
COpenSim::PointToPointActuator	A class that implements a force actuator acting between two points on two bodies
COpenSim::TorqueActuator	A TorqueActuator applies equal and opposite torques on the two bodies (bodyA and B) that it connects
COpenSim::Blankevoort1991Ligament	This class implements a nonlinear spring ligament model introduced by Blankevoort et al. (1991) [1] and further described in Smith et al. (2016) [2]
COpenSim::CoordinateLimitForce	Generate a force that acts to limit the range of motion of a coordinate
COpenSim::ElasticFoundationForce	This Force subclass implements an elastic foundation contact model
COpenSim::ExpressionBasedCoordinateForce
COpenSim::ExpressionBasedPointToPointForce	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
COpenSim::ExternalForce	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
COpenSim::HuntCrossleyForce	This force subclass implements a Hunt-Crossley contact model
COpenSim::Ligament	A class implementing a ligament
COpenSim::PathSpring	A class implementing a PathSpring
COpenSim::PointToPointSpring	A simple point to point spring with a resting length and stiffness
COpenSim::PrescribedForce	This applies to a PhysicalFrame a force and/or torque that is specified as a function of time
COpenSim::SmoothSphereHalfSpaceForce	This compliant contact force model is similar to HuntCrossleyForce, except that this model applies force even when not in contact
COpenSim::SpringGeneralizedForce	A Force that exerts a generalized force based on spring-like characteristics (stiffness and viscosity)
►COpenSim::StationPlaneContactForce	This class models compliant point contact with a ground plane y=0
COpenSim::AckermannVanDenBogert2010Force	This class is still under development
COpenSim::EspositoMiller2018Force	This contact model uses a continuous equation to transition between in and out of contact
COpenSim::MeyerFregly2016Force	This contact model is from the following paper: Meyer A
►COpenSim::Frame	A Frame is an OpenSim representation of a reference frame
COpenSim::ExperimentalFrame	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
COpenSim::OffsetFrame< C >	An OffsetFrame is a Frame whose transform (translation and orientation) with respect to another (parent) Frame is constant in time
►COpenSim::PhysicalFrame	A PhysicalFrame is a Frame that locates a physical element of the multi- body system that underlies a Model
►COpenSim::OffsetFrame< PhysicalFrame >
COpenSim::PhysicalOffsetFrame	A PhysicalOffsetFrame is a PhysicalFrame whose transform is specified as a constant offset from another PhysicalFrame
COpenSim::Body	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
COpenSim::Ground	Ground is an inertial reference frame in which the motion of all Frames and points may conveniently and efficiently be expressed
COpenSim::GeometryPath	A base class representing a path (muscle, ligament, etc.)
COpenSim::IMU	IMU is a Model Component that represents an IMU along with its Geometry for visualization
►COpenSim::Joint	An OpenSim Joint is an OpenSim::ModelComponent which connects two PhysicalFrames together and specifies their relative permissible motion as described in internal coordinates
COpenSim::BallJoint	A class implementing a Ball joint
COpenSim::CustomJoint	A class implementing a custom joint
COpenSim::EllipsoidJoint	A class implementing a Ellipsoid joint
COpenSim::FreeJoint	A class implementing a Free joint
COpenSim::GimbalJoint	A class implementing a Gimbal joint
COpenSim::PinJoint	A Class implementing a Pin joint
COpenSim::PlanarJoint	A class implementing a Planar joint
COpenSim::ScapulothoracicJoint	A class implementing a 4-DOF ScapulothoracicJoint
COpenSim::SliderJoint	A class implementing a Slider joint
COpenSim::UniversalJoint	A class implementing a Universal joint
COpenSim::WeldJoint	A class implementing a Weld joint
COpenSim::Model	A concrete class that specifies the interface to a musculoskeletal model
►COpenSim::MuscleActivationDynamics	An abstract class for modeling muscle activation dynamics
COpenSim::ConstantMuscleActivation	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
COpenSim::FirstOrderMuscleActivationDynamics	Computes muscle activation using a modified version of the first-order dynamic models used by Thelen (2003) and Winters (1995)
COpenSim::ZerothOrderMuscleActivationDynamics	This zeroth-order muscle activation dynamic model simply sets activation to excitation, and can be used when activation dynamics are being ignored
COpenSim::MuscleFirstOrderActivationDynamicModel	This is a muscle modeling utility class that computes the time derivative of activation using a first-order dynamic model
COpenSim::MuscleFixedWidthPennationModel	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
►COpenSim::Point	A Point is an OpenSim abstraction for any location in space
►COpenSim::AbstractPathPoint	An abstract class implementing a path point interface
COpenSim::MovingPathPoint	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
►COpenSim::PathPoint	A path point that is stationary with respect to parent's PhysicalFrame
COpenSim::ConditionalPathPoint	A class implementing a conditional path point, which is a point that is active only for a specified range of a coordinate
COpenSim::PathWrapPoint	A class implementing a path wrapping point, which is a path point that is produced by a PathWrap
COpenSim::ExperimentalMarker	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
►COpenSim::Station	A Station is a Point fixed to and located on a PhysicalFrame, which can be a Body, Ground or any PhysicalOffsetFrame
COpenSim::Marker	A class implementing a Mocap marker
COpenSim::PositionMotion	This class prescribes the value, speed, and acceleration of all coordinates in the model using SimTK::Motion
►COpenSim::Probe	This class represents a Probe which is designed to query a Vector of model values given system state
COpenSim::ActuatorForceProbe	ActuatorForceProbe is a ModelComponent Probe for computing an operation on a force or sum of forces in the model during a simulation
COpenSim::ActuatorPowerProbe	ActuatorPowerProbe is a ModelComponent Probe for computing an operation on a actuator power or sum of actuator powers in the model during a simulation
COpenSim::Bhargava2004MuscleMetabolicsProbe	Bhargava2004MuscleMetabolicsProbe is a Probe ModelComponent for computing the net metabolic energy rate of a set of Muscles in the model during a simulation
COpenSim::JointInternalPowerProbe	JointInternalPowerProbe is a ModelComponent Probe for computing an operation on internal joint power or sum of joint powers in the model during a simulation
COpenSim::MuscleActiveFiberPowerProbe	MuscleActiveFiberPowerProbe is a ModelComponent probe for computing an operation on the active fiber power of a muscle
COpenSim::SystemEnergyProbe	SystemEnergyProbe is a ModelComponent Probe for computing an operation on a total system energy during a simulation
COpenSim::Umberger2010MuscleMetabolicsProbe	Umberger2010MuscleMetabolicsProbe is a Probe ModelComponent for computing the net metabolic energy rate of a set of Muscles in the model during a simulation
►COpenSim::WrapObject	An abstract class that specifies the interface for a wrapping object
COpenSim::WrapCylinder	A class implementing a cylinder for muscle wrapping
COpenSim::WrapEllipsoid	A class implementing an ellipsoid for muscle wrapping
COpenSim::WrapSphere	A class implementing a sphere for muscle wrapping
COpenSim::WrapTorus	A class implementing a torus for muscle wrapping
COpenSim::SignalGenerator	SignalGenerator is a type of Component with no inputs and only one output
COpenSim::TableSource_< ET >	Component representing a source of data from a TimeSeriesTable_
COpenSim::TwoFrameLinker< C, F >	TwoFrameLinker is a utility class to extend a Component such that it connects two Frames
►COpenSim::Condition	A parent class for implementing an OpenSim Condition
COpenSim::FunctionThresholdCondition	FunctionThresholdCondition is a concrete implementation of a Condition
►COpenSim::Control	A class that represents a control in a dynamic simulation
COpenSim::ControlConstant	A class that represents a constant control curve
COpenSim::ControlLinear	A class that represents a piece-wise linear control curve
COpenSim::ControlLinearNode	A control node used to reconstruct a piecewise linear control
COpenSim::ExperimentalSensor	A class representing the experimental sensor, such as IMU, and its association to a model (component) in OpenSim
►COpenSim::Function	An abstract class for representing a function
COpenSim::ActiveForceLengthCurve	This class serves as a serializable ActiveForceLengthCurve, commonly used to model the active element in muscle models
COpenSim::Constant	A class for representing a constant value
COpenSim::FiberCompressiveForceCosPennationCurve	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
COpenSim::FiberCompressiveForceLengthCurve	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
COpenSim::FiberForceLengthCurve	This class serves as a serializable FiberForceLengthCurve, commonly used to model the parallel elastic element in muscle models
COpenSim::ForceVelocityCurve	This class serves as a serializable ForceVelocityCurve for use in muscle models
COpenSim::ForceVelocityInverseCurve	This class serves as a serializable ForceVelocityInverseCurve for use in equilibrium muscle models
COpenSim::GCVSpline	A class for representing a smooth function with a generalized cross-validation spline
COpenSim::LinearFunction	A class for representing a LinearFunction
COpenSim::MultiplierFunction	A class implementing a Function and a scale factor for the function's value
COpenSim::MultivariatePolynomialFunction	A multivariate polynomial function
COpenSim::PiecewiseConstantFunction	A class implementing a step function
COpenSim::PiecewiseLinearFunction	A class implementing a linear function
COpenSim::PolynomialFunction	A class for representing a Polynomial of x
COpenSim::SimmSpline	A class implementing a smooth function with a cubic spline as implemented in SIMM
COpenSim::Sine	A class for representing a Sine function
COpenSim::StepFunction	A class for representing a StepFunction
COpenSim::TendonForceLengthCurve	This class serves as a serializable TendonForceLengthCurve for use in muscle models
COpenSim::GenericModelMaker	A class implementing a set of parameters describing a generic musculoskeletal model
►COpenSim::IKTask
COpenSim::IKCoordinateTask
COpenSim::IKMarkerTask
COpenSim::IMUPlacer	A class implementing a set of parameters describing how to place IMUs on a model to match placement of experimental sensors (IMUs)
COpenSim::MarkerData	A class implementing a sequence of marker frames from a TRC/TRB file
COpenSim::MarkerFrame	A class implementing a frame of marker data from a TRC/TRB file
COpenSim::MarkerPair	A class for holding the names of a pair of markers (for making measurements on a model)
COpenSim::MarkerPlacer	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)
COpenSim::MarkerWeight
COpenSim::Measurement	A class implementing a measurement (the distance between one or more pairs of markers, used to scale a model)
►COpenSim::MocoBounds	Small struct-like class to handle bounds
COpenSim::MocoFinalBounds	Used for specifying the bounds on a variable at the end of a phase
COpenSim::MocoInitialBounds	Used for specifying the bounds on a variable at the start of a phase
COpenSim::MocoConstraintInfo	Information for a given constraint in the optimal control problem
COpenSim::MocoContactImpulseTrackingGoalGroup
COpenSim::MocoContactTrackingGoalGroup
COpenSim::MocoControlTrackingGoalReference	Associate a control variable with a column from the reference data
COpenSim::MocoFrameDistanceConstraintPair
►COpenSim::MocoGoal	A goal is a term in the cost functional to be minimized, or a set of endpoint constraints that must lie within provided bounds
COpenSim::MocoAccelerationTrackingGoal	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
COpenSim::MocoAngularVelocityTrackingGoal	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
COpenSim::MocoAverageSpeedGoal	This goal requires the average speed of the system to match a desired average speed
COpenSim::MocoContactImpulseTrackingGoal
COpenSim::MocoContactTrackingGoal
COpenSim::MocoControlGoal	Minimize the sum of the absolute value of the controls raised to a given exponent, integrated over the phase
COpenSim::MocoControlTrackingGoal
COpenSim::MocoFinalTimeGoal	Endpoint cost for final time
COpenSim::MocoInitialActivationGoal	For all muscles with activation dynamics, the initial activation and initial excitation should be the same
COpenSim::MocoInitialForceEquilibriumDGFGoal	For all DeGrooteFregly2016Muscles with explicit tendon compliance dynamics, constrain (or minimize) the error computed from the muscle-tendon force equilibrium equation
COpenSim::MocoInitialVelocityEquilibriumDGFGoal	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
COpenSim::MocoJointReactionGoal	Minimize the sum of squares of specified reaction moment and force measures for a given joint, integrated over the phase
COpenSim::MocoMarkerFinalGoal	The squared distance between a single model point location and reference location in the final state
COpenSim::MocoMarkerTrackingGoal
COpenSim::MocoOrientationTrackingGoal	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
►COpenSim::MocoOutputBase	This abstract base class provides convenience methods and common interfaces for all Output-related MocoGoal's
COpenSim::MocoFinalOutputGoal	This goal allows you to minimize or constrain a Model Output value at the end of a trajectory
COpenSim::MocoInitialOutputGoal	This goal allows you to minimize or constrain a Model Output value at the beginning of a trajectory
COpenSim::MocoOutputGoal	This goal allows you to use model Outputs of type double, SimTK::Vec3, and SimTK::SpatialVec in the integrand of a goal
COpenSim::MocoOutputPeriodicityGoal	This goal allows you to minimize or constrain the difference of values from a Model Output from the beginning and end of a trajectory
COpenSim::MocoOutputTrackingGoal	This goal allows you to minimize the squared difference between a Model Output value and a user-defined function
COpenSim::MocoPeriodicityGoal	This goal enforces equality between initial and final variable values in the optimal control problem
COpenSim::MocoStateTrackingGoal
COpenSim::MocoStepLengthAsymmetryGoal	Minimize the error between a model's step time asymmetry and a specified target asymmetry value over a gait cycle
COpenSim::MocoStepTimeAsymmetryGoal	Minimize the error between a model's step time asymmetry and a specified target asymmetry value over a gait cycle
COpenSim::MocoSumSquaredStateGoal	Minimize the sum of squared states, integrated over the phase
COpenSim::MocoTranslationTrackingGoal	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
COpenSim::MocoParameter	A MocoParameter allows you to optimize property values in an OpenSim Model
►COpenSim::MocoPathConstraint	A path constraint to be enforced in the optimal control problem
COpenSim::MocoControlBoundConstraint	This class constrains any number of control signals from ScalarActautors to be between two time-based functions
COpenSim::MocoFrameDistanceConstraint	This path constraint enforces that the distance between the origins of pairs of model frames is kept between minimum and maximum bounds
COpenSim::MocoOutputConstraint
COpenSim::MocoPeriodicityGoalPair	Create pair of variables for use with a MocoPeriodicityGoal
COpenSim::MocoPhase	The states, controls, dynamics, parameters, goals, and constraints for a phase of the problem
COpenSim::MocoProblem	A description of an optimal control problem, backed by OpenSim Models
►COpenSim::MocoSolver	Once the solver is created, you should not make any edits to the MocoProblem
►COpenSim::MocoDirectCollocationSolver	This is a base class for solvers that use direct collocation to convert an optimal control problem into a generic nonlinear programming problem
COpenSim::MocoCasADiSolver	This solver uses the CasADi library (https://casadi.org) to convert the MocoProblem into a generic nonlinear programming problem
COpenSim::MocoTropterSolver	Solve the MocoProblem using the tropter direct collocation library
COpenSim::MocoStepTimeAsymmetryGoalGroup	A contact group includes a list of contact force component paths in the model
COpenSim::MocoStudy	The top-level class for solving a custom optimal control problem
►COpenSim::MocoTool	This is a base class for solving problems that depend on an observed motion using Moco's optimal control methods
COpenSim::MocoInverse	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
COpenSim::MocoTrack
COpenSim::MocoVariableInfo	Bounds on continuous variables (states, controls, multipliers, etc)
COpenSim::MocoWeight	This class contains a single property that holds a weighting factor to be used in a MocoGoal
COpenSim::ModelDisplayHints	This class captures information indicating user or programmer preferences to guide automatic display geometry generation by a Model
►COpenSim::ModelOperator	This abstract base class describes any operation that modifies a Model as part of a ModelProcessor
COpenSim::ModOpAddExternalLoads	Add external loads (e.g., ground reaction forces) to the model from a XML file
COpenSim::ModOpAddReserves	Add reserve actuators to the model using ModelFactory::createReserveActuators
COpenSim::ModOpFiberDampingDGF	Set the fiber damping for all DeGrooteFregly2016Muscles in the model
COpenSim::ModOpIgnoreActivationDynamics	Turn off activation dynamics for all muscles in the model
COpenSim::ModOpIgnorePassiveFiberForcesDGF	Turn off passive fiber forces for all DeGrooteFregly2016Muscles in the model
COpenSim::ModOpIgnoreTendonCompliance	Turn off tendon compliance for all muscles in the model
COpenSim::ModOpPassiveFiberStrainAtOneNormForceDGF	Set passive fiber stiffness for all DeGrooteFregly2016Muscles in the model
COpenSim::ModOpRemoveMuscles	Remove all muscles contained in the model's ForceSet
COpenSim::ModOpReplaceJointsWithWelds
COpenSim::ModOpReplaceMusclesWithDeGrooteFregly2016	Invoke DeGrooteFregly2016Muscle::replaceMuscles() on the model
COpenSim::ModOpScaleActiveFiberForceCurveWidthDGF	Scale the active fiber force curve width for all DeGrooteFregly2016Muscles in the model
COpenSim::ModOpScaleMaxIsometricForce	Scale the max isometric force for all muscles in the model
COpenSim::ModOpTendonComplianceDynamicsModeDGF	For DeGrooteFregly2016Muscle muscles whose 'ignore_tendon_compliance' property is false, set the tendon compliance dynamics mode to either 'explicit' or 'implicit'
COpenSim::ModOpUseImplicitTendonComplianceDynamicsDGF	Set the tendon compliance dynamics mode to "implicit" for all DeGrooteFregly2016Muscles in the model
COpenSim::ModelProcessor	This class describes a workflow for processing a Model using ModelOperators
COpenSim::ModelScaler	A class for scaling a model
COpenSim::ModelVisualPreferences	A class that holds the Visual Preferences of a full OpenSim Model displayed in Visualizer
COpenSim::MuscleSecondOrderActivationDynamicModel	This function is a muscle modeling utility class that simulates dynamics of muscle force development as a function of input excitation
COpenSim::ObjectGroup	A class implementing an object group
COpenSim::OrientationWeight
►COpenSim::Reference_< T >	This base (abstract) class defines the interface for a Reference signals to be achieved/tracked via optimization and/or tracking controller
►COpenSim::StreamableReference_< SimTK::Rotation_< double > >
►COpenSim::OrientationsReference	Reference values for the Orientations of model frames that will be used to to compute tracking errors
COpenSim::BufferedOrientationsReference	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
COpenSim::StreamableReference_< T >
COpenSim::Scale
COpenSim::ScaleTool	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
►COpenSim::Set< T, C >	A class for holding a set of pointers to objects
►COpenSim::ModelComponentSet< Body >
COpenSim::BodySet	A class for holding a set of bodies
►COpenSim::ModelComponentSet< Constraint >
COpenSim::ConstraintSet	A class for holding a set of constraints
►COpenSim::ModelComponentSet< ContactGeometry >
COpenSim::ContactGeometrySet	A class for holding a set of ContactGeometry components
►COpenSim::ModelComponentSet< Controller >
COpenSim::ControllerSet	A class for holding and managing a set of controllers for a model
►COpenSim::ModelComponentSet< ExternalForce >
COpenSim::ExternalLoads	A convenience class for managing ExternaForce(s) to be applied to a model
►COpenSim::ModelComponentSet< Force >
COpenSim::ForceSet	A class for holding and managing a set of forces for a model
►COpenSim::ModelComponentSet< Joint >
COpenSim::JointSet	A class for holding a set of joints
►COpenSim::ModelComponentSet< Marker >
COpenSim::MarkerSet	A class for holding a set of markers
►COpenSim::ModelComponentSet< Probe >
COpenSim::ProbeSet	A class for holding a set of probes
►COpenSim::ModelComponentSet< WrapObject >
COpenSim::WrapObjectSet	A class for holding a set of wrap objects
COpenSim::SimbodyEngine	A wrapper class to use the SimTK Simbody dynamics engine as the underlying engine for OpenSim
►COpenSim::Solver	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
►COpenSim::AssemblySolver	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
COpenSim::InverseKinematicsSolver	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
COpenSim::InducedAccelerationsSolver	A Solver to compute the induced accelerations of an applied "force" acting on the model
COpenSim::InverseDynamicsSolver	Solve for the generalized coordinate forces (1 per degree-of- freedom) that satisfy the unconstrained equations of motion given kinematics: q, u, u_dot
COpenSim::MomentArmSolver	Solve for the effective moment arms at all degrees-of-freedom due to one or more point forces
COpenSim::SpatialTransform	A class encapsulating the spatial transformation between two bodies that defines the behavior of a custom joint
►COpenSim::StorageInterface
COpenSim::Storage	A class for storing an array of statevectors
COpenSim::SurfaceProperties	SurfaceProperties class holds the appearance properties of a piece of Geometry displayed in the OpenSim visualizer or GUI as a surface
►COpenSim::TableOperator	This abstract class describes any operation that consumes and modifies a TimeSeriesTable as part of a TableProcessor
COpenSim::TabOpConvertDegreesToRadians
COpenSim::TabOpLowPassFilter	Apply a low-pass filter to the trajectory
COpenSim::TabOpUseAbsoluteStateNames	Update table column labels to use post-4.0 state paths instead of pre-4.0 state names
COpenSim::TableProcessor	This class describes a workflow for processing a table using TableOperators
►COpenSim::Tool	A Tool is an OpenSim abstraction that encapsulates an analysis or series of modeling and analysis steps
►COpenSim::DynamicsTool	An abstract Tool for defining tools for performing a dynamics analysis with a given model
COpenSim::InverseDynamicsTool	A Tool that performs an Inverse Dynamics analysis with a given model
►COpenSim::InverseKinematicsToolBase	A Tool that performs an Inverse Kinematics analysis with a given model
COpenSim::IMUInverseKinematicsTool	A Study that performs an Inverse Kinematics analysis with a given model
COpenSim::InverseKinematicsTool	A Tool that performs an Inverse Kinematics analysis with a given model
►COpenSim::TrackingTask	An abstract base class for specifying a target for a tracking problem
►COpenSim::CMC_Task	An abstract base class for specifying a task objective for a dynamic simulation
►COpenSim::CMC_Joint	A class for specifying the tracking task for a joint
COpenSim::SMC_Joint	A class for specifying the tracking task for a joint
COpenSim::CMC_Orientation	A class for tracking the orientation of a body
COpenSim::CMC_Point	A class for specifying and computing parameters for tracking a point
►COpenSim::StateTrackingTask	A tracking task objective that corresponds to a state variable of a Force component (e.g
COpenSim::MuscleStateTrackingTask	A TrackingTask for that corresponds to a muscle state variable
COpenSim::TransformAxis	A class expressing a transformation of a child body in relation to a parent body along either a translation or about a rotation axis
COpenSim::Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameter	Documentation for this class has been provided with the documentation for the Umberger2010MuscleMetabolicsProbe class
►COpenSim::VectorFunction	An abstract class for representing a vector function
►COpenSim::VectorFunctionUncoupledNxN	An abstract class for representing a vector function
COpenSim::VectorFunctionForActuators	An abstract class for representing a vector function
COpenSim::XsensDataReaderSettings	XsensDataReaderSettings is a class that reads files produced by IMU manufacturer Xsens and produces datatables from them
COpenSim::Object_GetClassName< T >
COpenSim::Object_GetClassName< bool >
COpenSim::Object_GetClassName< char >
COpenSim::Object_GetClassName< double >
COpenSim::Object_GetClassName< float >
COpenSim::Object_GetClassName< int >
COpenSim::Object_GetClassName< long double >
COpenSim::Object_GetClassName< long int >
COpenSim::Object_GetClassName< long long int >
COpenSim::Object_GetClassName< short int >
COpenSim::Object_GetClassName< signed char >
COpenSim::Object_GetClassName< SimTK::Quaternion_< SimTK::Real > >
COpenSim::Object_GetClassName< SimTK::Rotation_< SimTK::Real > >
COpenSim::Object_GetClassName< SimTK::SpatialVec >
COpenSim::Object_GetClassName< SimTK::Transform >
COpenSim::Object_GetClassName< SimTK::Vec2 >
COpenSim::Object_GetClassName< SimTK::Vec3 >
COpenSim::Object_GetClassName< SimTK::Vec6 >
COpenSim::Object_GetClassName< SimTK::Vector_< SimTK::Real > >
COpenSim::Object_GetClassName< SimTK::Vector_< SimTK::SpatialVec > >
COpenSim::Object_GetClassName< SimTK::Vector_< SimTK::Vec3 > >
COpenSim::Object_GetClassName< SimTK::Vector_< SimTK::Vec6 > >
COpenSim::Object_GetClassName< std::string >
COpenSim::Object_GetClassName< unsigned char >
COpenSim::Object_GetClassName< unsigned int >
COpenSim::Object_GetClassName< unsigned long int >
COpenSim::Object_GetClassName< unsigned long long int >
COpenSim::Object_GetClassName< unsigned short int >
COpenSim::ObjectProperty< T >
COpenSim::OpenSenseUtilities
►CSimTK::OptimizerSystem
►COpenSim::OptimizationTarget	This class provides an interface specification for optimizing redundant systems
COpenSim::ActuatorForceTarget	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
COpenSim::ActuatorForceTargetFast	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
COpenSim::StaticOptimizationTarget	This class provides an interface specification for static optimization Objective Function
CosimInstantiator
CosimMocoInstantiator
COpenSim::PointForceDirection	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
COpenSim::MuscleAnalysis::private
►Ctropter::Problem
►COpenSim::MocoTropterSolver::TropterProblemBase< T >
COpenSim::MocoTropterSolver::ExplicitTropterProblem< T >
COpenSim::MocoTropterSolver::ImplicitTropterProblem< T >
COpenSim::PropertyGroup	A class implementing a property group
COpenSim::PropertySet	A property set is simply a set of properties
COpenSim::PropertyTable	A property table is the container that an OpenSim Object uses to hold its properties (each derived from base class AbstractProperty)
COpenSim::RootSolver	A class for finding the N roots of N one-dimensional non-linear equations
COpenSim::SegmentedQuinticBezierToolkit	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
COpenSim::Signal	A class for signal processing
COpenSim::SimpleProperty< T >
COpenSim::SmoothSegmentedFunctionFactory	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
COpenSim::StatesTrajectory
COpenSim::StateVector	A class which stores a vector of states or data at a specified time
COpenSim::Stopwatch	Record and report elapsed real time ("clock" or "wall" time) in seconds
COpenSim::StorageCreator
COpenSim::StorageFactory
COpenSim::TableUtilities
COpenSim::ThreadsafeJar< T >	This class lets you store objects of a single type for reuse by multiple threads, ensuring threadsafe access to each of those objects
COpenSim::Property< T >::TypeHelper	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
COpenSim::Units	A class implementing various units for measuring quantities
COpenSim::ValueArrayDictionary	ValueArrayDictionary represents an associative array mapping from a string to an AbstractValueArray
COpenSim::VisualizerUtilities