  OpenSim::AbstractProperty | An abstract property is a serializable (name,value) pair, for which we do not know the type of the value |
  OpenSim::Property< T > | A Property<T> is a serializable (name, list-of-values) pair, where each value is of type T |
 OpenSim::Property_Deprecated | |
 OpenSim::PropertyBool | |
| OpenSim::PropertyBoolArray | Class PropertyBoolArray extends class Property |
| OpenSim::PropertyDbl | |
| OpenSim::PropertyDblArray | |
 OpenSim::PropertyTransform | |
| OpenSim::PropertyDblVec_< M > | |
| OpenSim::PropertyInt | |
| OpenSim::PropertyIntArray | |
| OpenSim::PropertyObj | |
| OpenSim::PropertyObjArray< T > | |
| OpenSim::PropertyObjPtr< T > | |
| OpenSim::PropertyStr | |
| OpenSim::PropertyStrArray | |
| OpenSim::PropertyDblVec_< 2 > | |
| OpenSim::PropertyDblVec_< 3 > | |
| OpenSim::PropertyObjArray< Analysis > | |
| OpenSim::PropertyObjArray< Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameter > | |
| OpenSim::PropertyObjArray< Body > | |
| OpenSim::PropertyObjArray< BodyScale > | |
| OpenSim::PropertyObjArray< Constraint > | |
| OpenSim::PropertyObjArray< ContactGeometry > | |
| OpenSim::PropertyObjArray< Control > | |
| OpenSim::PropertyObjArray< Controller > | |
| OpenSim::PropertyObjArray< Coordinate > | |
| OpenSim::PropertyObjArray< DisplayGeometry > | |
| OpenSim::PropertyObjArray< ExternalForce > | |
| OpenSim::PropertyObjArray< Force > | |
| OpenSim::PropertyObjArray< Function > | |
| OpenSim::PropertyObjArray< IKTask > | |
| OpenSim::PropertyObjArray< Joint > | |
| OpenSim::PropertyObjArray< Marker > | |
| OpenSim::PropertyObjArray< MarkerPair > | |
| OpenSim::PropertyObjArray< Measurement > | |
| OpenSim::PropertyObjArray< ModelComponent > | |
| OpenSim::PropertyObjArray< OpenSim::Actuator > | |
| OpenSim::PropertyObjArray< OpenSim::Constraint > | |
| OpenSim::PropertyObjArray< OpenSim::ControlLinearNode > | |
| OpenSim::PropertyObjArray< OpenSim::Force > | |
| OpenSim::PropertyObjArray< OpenSim::MarkerWeight > | |
| OpenSim::PropertyObjArray< OpenSim::Muscle > | |
| OpenSim::PropertyObjArray< OpenSim::ObjectGroup > | |
| OpenSim::PropertyObjArray< PathPoint > | |
| OpenSim::PropertyObjArray< Probe > | |
| OpenSim::PropertyObjArray< Scale > | |
| OpenSim::PropertyObjArray< TrackingTask > | |
| OpenSim::PropertyObjArray< Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameter > | |
| OpenSim::PropertyObjPtr< OpenSim::Function > | |
| OpenSim::PropertyObjPtr< OpenSim::Joint > | |
| OpenSim::PropertyObjPtr< OpenSim::OpenSim::Function > | |
| OpenSim::Array< T > | |
| OpenSim::Array< bool > | |
| OpenSim::Array< double > | |
| OpenSim::Array< int > | |
| OpenSim::Array< JointReactionKey > | |
| OpenSim::Array< OpenSim::Array< double > * > | |
| OpenSim::Array< OpenSim::ExternalForce * > | |
| OpenSim::Array< OpenSim::Geometry * > | |
| OpenSim::Array< OpenSim::Object * > | |
| OpenSim::Array< OpenSim::Property_Deprecated * > | |
| OpenSim::Array< OpenSim::StateVector > | |
| OpenSim::Array< OpenSim::Storage * > | |
| OpenSim::Array< SimTK::SystemYIndex > | |
| OpenSim::Array< std::string > | |
| ContactParameters public Object | |
| OpenSim::HuntCrossleyForce | This force subclass implements a Hunt-Crossley contact model |
| ContactParameterspublic Object | |
| OpenSim::ElasticFoundationForce | This Force subclass implements an elastic foundation contact model |
| ContactParametersSetpublic Set | |
| OpenSim::ElasticFoundationForce | This Force subclass implements an elastic foundation contact model |
| OpenSim::HuntCrossleyForce | This force subclass implements a Hunt-Crossley contact model |
| DecorationGenerator | |
| SimTK::DefaultGeometry | |
| Document | |
| OpenSim::XMLDocument | |
| exception | |
| OpenSim::Exception | |
| OpenSim::MuscleActivationDynamics::ExcitationGetter | The ExcitationGetter abstract class defines a standard interface for supplying muscle excitation to activation models |
| OpenSim::Muscle::FiberVelocityInfo | FiberVelocityInfo contains velocity quantities related to the velocity of the muscle (fiber + tendon) complex |
| Function_ | |
| OpenSim::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 |
| OpenSim::Geometry | Class Geometry is intended to be used as the base class for all geometry that needs to be represented in the system, both as vtk files, or analytic |
| OpenSim::AnalyticGeometry | Utility class used to abstract anayltic geometry |
| OpenSim::AnalyticCylinder | |
| OpenSim::AnalyticEllipsoid | |
| OpenSim::AnalyticSphere | |
| OpenSim::AnalyticTorus | |
| OpenSim::LineGeometry | |
| OpenSim::ArrowGeometry | |
| OpenSim::PolyhedralGeometry | |
| Implementation | |
| OpenSim::ForceAdapter | This acts as an adapter to allow a Force or Actuator to be used as a SimTK::Force |
| OpenSim::IO | A class for performing input and output with OpenSim API |
| OpenSim::Manager | A class that manages the execution of a simulation |
| OpenSim::ModelDisplayHints | This class captures information indicating user or programmer preferences to guide automatic display geometry generation by a Model |
| OpenSim::ModelVisualizer | This class manages runtime visualization of a Model that is being manipulated through the OpenSim API |
| OpenSim::Muscle::MuscleDynamicsInfo | MuscleDynamicsInfo contains quantities that are related to the forces that the muscle generates |
| OpenSim::Muscle::MuscleLengthInfo | The MuscleLengthInfo struct contains information about the muscle that is strictly a function of the length of the fiber and the tendon, and the orientation of the muscle fiber |
| OpenSim::Muscle::MusclePotentialEnergyInfo | MusclePotentialEnergyInfo contains quantities related to the potential energy of the muscle (fiber + tendon) complex |
| OpenSim::Object | This is the base class for all OpenSim objects that are serializable (meaning they can be written to and read back from files) |
| OpenSim::AbstractTool | An abstract class for specifying the interface for an investigation |
| OpenSim::AnalyzeTool | An abstract class for specifying the interface for an investigation |
| OpenSim::CMCTool | An abstract class for specifying the interface for an investigation |
| OpenSim::ForwardTool | A concrete tool for perfroming forward dynamics simulations |
| OpenSim::RRATool | An abstract class for specifying the interface for an investigation |
| OpenSim::Analysis | An abstract class for specifying the interface for an analysis plugin |
| OpenSim::Actuation | A class for recording the basic actuator information for a model during a simulation |
| OpenSim::BodyKinematics | A class for recording the kinematics of the bodies of a model during a simulation |
| OpenSim::ForceReporter | A class for recording the Forces applied to a model during a simulation |
| OpenSim::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 |
| OpenSim::JointReaction | An analysis for reporting the joint reaction loads from a model |
| OpenSim::Kinematics | A class for recording the kinematics of the generalized coordinates of a model during a simulation |
| OpenSim::MuscleAnalysis | A class for recording and computting basic quantities (length, shortening velocity, tendon length, ...) for muscles during a simulation |
| OpenSim::PointKinematics | A class for recording the kinematics of a point on a body of a model during a simulation |
| OpenSim::ProbeReporter | A class for reporting the outputs of all model-connected Probes to file during a simulation |
| OpenSim::StatesReporter | A class for recording the states of a model during a simulation |
| OpenSim::StaticOptimization | This class implements static optimization to compute Muscle Forces and activations |
| OpenSim::Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameter | |
| OpenSim::BodyScale | A class implementing a set of parameters describing how to scale a body segment |
| OpenSim::Condition | A parent class for implementing an OpenSim Condition |
| OpenSim::FunctionThresholdCondition | FunctionThresholdCondition is a concrete implementation of a Condition |
| OpenSim::Control | |
| OpenSim::ControlConstant | A class that represents a constant control curve |
| OpenSim::ControlLinear | A class that represents a piece-wise linear control curve |
| OpenSim::ControlLinearNode | |
| OpenSim::DisplayGeometry | A class for representing the DisplayGeometry properties of an object |
| OpenSim::Function | |
| OpenSim::ActiveForceLengthCurve | This class serves as a serializable ActiveForceLengthCurve, commonly used to model the active element in muscle models |
| OpenSim::Constant | A class for representing a constant value |
| OpenSim::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 |
| OpenSim::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 |
| OpenSim::FiberForceLengthCurve | This class serves as a serializable FiberForceLengthCurve, commonly used to model the parallel elastic element in muscle models |
| OpenSim::ForceVelocityCurve | This class serves as a serializable ForceVelocityCurve for use in muscle models |
| OpenSim::ForceVelocityInverseCurve | This class serves as a serializable ForceVelocityInverseCurve for use in equilibrium muscle models |
| OpenSim::GCVSpline | |
| OpenSim::LinearFunction | A class for representing a LinearFunction |
| OpenSim::MultiplierFunction | |
| OpenSim::PiecewiseConstantFunction | |
| OpenSim::PiecewiseLinearFunction | |
| OpenSim::PolynomialFunction | A class for representing a Polynomial of x |
| OpenSim::SimmSpline | |
| OpenSim::Sine | A class for representing a Sine function |
| OpenSim::StepFunction | A class for representing a StepFunction |
| OpenSim::TendonForceLengthCurve | This class serves as a serializable TendonForceLengthCurve for use in muscle models |
| OpenSim::GenericModelMaker | A class implementing a set of parameters describing a generic musculoskeletal model |
| OpenSim::IKTask | |
| OpenSim::IKCoordinateTask | |
| OpenSim::IKMarkerTask | |
| OpenSim::Marker | A class implementing a SIMM [mocap] marker |
| OpenSim::MarkerData | A class implementing a sequence of marker frames from a TRC/TRB file |
| OpenSim::MarkerFrame | A class implementing a frame of marker data from a TRC/TRB file |
| OpenSim::MarkerPair | |
| OpenSim::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) |
| OpenSim::MarkerWeight | |
| OpenSim::Measurement | A class implementing a measurement (the distance between one or more pairs of markers, used to scale a model) |
| OpenSim::ModelComponent | This defines the abstract ModelComponent class, which is used to add computational components to the underlying SimTK::System (MultibodySystem) |
| OpenSim::Body | A class implementing a Simbody rigid body |
| OpenSim::Constraint | A parent class for implementing a Simbody Constraint |
| OpenSim::ConstantDistanceConstraint | A class implementing a constraint that maintains a constant distance between between two points |
| OpenSim::CoordinateCouplerConstraint | |
| OpenSim::PointConstraint | A class implementing a Point Constraint |
| OpenSim::PointOnLineConstraint | A class implementing a Point On Line Constraint |
| OpenSim::UnilateralConstraint | An abstract class defining an OpenSim UnilateralConstraint |
| OpenSim::RollingOnSurfaceConstraint | A class implementing a collection of rolling-without-slipping and non-penetration constraints on a surface |
| OpenSim::WeldConstraint | A class implementing a Weld Constraint |
| OpenSim::ContactGeometry | This class represents the physical shape of an object for use in contact modeling |
| OpenSim::ContactHalfSpace | This class represents a half space (that is, everything to one side of an infinite plane) for use in contact modeling |
| OpenSim::ContactMesh | This class represents a polygonal mesh for use in contact modeling |
| OpenSim::ContactSphere | This class represents a spherical object for use in contact modeling |
| OpenSim::Controller | Controller is an abstract ModelComponent that defines the interface for an OpenSim Controller |
| OpenSim::ControlSetController | |
| OpenSim::PrescribedController | PrescribedController is a concrete Controller that specifies functions that prescribe the control values of its actuators as a function of time |
| OpenSim::ToyReflexController | ToyReflexController is a concrete controller that excites muscles in response to muscle lengthening to simulate a simple stretch reflex |
| OpenSim::TrackingController | |
| OpenSim::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 goverened by differential equaitions (as so have delays in force production) |
| OpenSim::CorrectionController | This is a simple feedback controller to be used in generating a forward dynamic simulation |
| OpenSim::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) |
| OpenSim::Force | This abstract class represents a force applied to bodies or generalized coordinates during a simulation |
| OpenSim::Actuator_ | Base class for an actuator (e.g., a torque motor, muscle, ...) that requires external input (controls) to generate force |
| OpenSim::Actuator | Derived class for an 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 |
| OpenSim::CoordinateActuator | An actuator that applies a generalized force to along a generalized a generalized coordinate, which is proportional to its input control |
| OpenSim::PathActuator | This is the base class for actuators that apply controllable tension along a geometry path |
| OpenSim::ClutchedPathSpring | The ClutchedPathSpring is an actuator that has passive path spring behavior only when the clutch is engaged |
| OpenSim::Muscle | A base class for modeling a muscle-tendon actuator |
| OpenSim::ActivationFiberLengthMuscle | A base class representing a two-state muscle-tendon actuator |
| OpenSim::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 |
| OpenSim::ActivationFiberLengthMuscle_Deprecated | A base class representing a muscle-tendon actuator |
| OpenSim::ContDerivMuscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Delp1990Muscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Schutte1993Muscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::Thelen2003Muscle_Deprecated | A class implementing a SIMM muscle |
| OpenSim::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 velocites) curves can be employed |
| OpenSim::Millard2012EquilibriumMuscle | This class implements a configurable equilibrium muscle model, as described in Millard et al. (2013) |
| OpenSim::RigidTendonMuscle | A class implementing a RigidTendonMuscle actuator with no states |
| OpenSim::PointActuator | A class that implements a point actuator acting on the model |
| OpenSim::PointToPointActuator | A class that implements a force actuator acting between two points on two bodies |
| OpenSim::TorqueActuator | A TorqueActuatorr applies equal and opposite torques on the two bodies (bodyA and B) that it connects |
| OpenSim::BushingForce | A class implementing a Bushing Force |
| OpenSim::CoordinateLimitForce | |
| OpenSim::ElasticFoundationForce | This Force subclass implements an elastic foundation contact model |
| OpenSim::ExpressionBasedBushingForce | A class implementing a bushing force driven by expressions relating forces to deviations |
| OpenSim::ExpressionBasedCoordinateForce | |
| OpenSim::ExpressionBasedPointToPointForce | |
| OpenSim::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 |
| OpenSim::FunctionBasedBushingForce | A class implementing a bushing force driven by functions relating forces to deviations |
| OpenSim::HuntCrossleyForce | This force subclass implements a Hunt-Crossley contact model |
| OpenSim::Ligament | A class implementing a ligament |
| OpenSim::PathSpring | A class implementing a PathSpring |
| OpenSim::PointToPointSpring | |
| OpenSim::PrescribedForce | This applies to a body a force and/or torque that is fully specified as a function of time |
| OpenSim::SpringGeneralizedForce | |
| OpenSim::GeometryPath | A base class representing a path (muscle, ligament, etc.) |
| OpenSim::Joint | A class implementing an OpenSim Joint |
| OpenSim::BallJoint | A class implementing an Ball joint |
| OpenSim::CustomJoint | A class implementing a custom joint |
| OpenSim::EllipsoidJoint | A class implementing an Ellipsoid joint |
| OpenSim::FreeJoint | A class implementing a Free joint |
| OpenSim::GimbalJoint | A class implementing an Gimbal joint |
| OpenSim::PinJoint | A class implementing an Pin joint |
| OpenSim::PlanarJoint | A PlanarJoint provides three DoFs: rotation about the the common Z of the parent and child joint frames, X and Y translation in the parent body's joint frame |
| OpenSim::SliderJoint | A class implementing an Slider joint |
| OpenSim::UniversalJoint | A class implementing a Universal joint |
| OpenSim::WeldJoint | A class implementing an Weld joint |
| OpenSim::Model | A concrete class that specifies the interface to a musculoskeletal model |
| OpenSim::MuscleActivationDynamics | An abstract class for modeling muscle activation dynamics |
| OpenSim::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 |
| OpenSim::FirstOrderMuscleActivationDynamics | Computes muscle activation using a modified version of the first-order dynamic models used by Thelen (2003) and Winters (1995) |
| OpenSim::ZerothOrderMuscleActivationDynamics | This zeroth-order muscle activation dynamic model simply sets activation to excitation, and can be used when activation dynamics are being ignored |
| OpenSim::Probe | This class represents a Probe which is designed to query a Vector of model values given system state |
| OpenSim::ActuatorForceProbe | ActuatorForceProbe is a ModelComponent Probe for computing an operation on a force or sum of forces in the model during a simulation |
| OpenSim::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 |
| OpenSim::Bhargava2004MuscleMetabolicsProbe | Bhargava2004MuscleMetabolicsProbe is a Probe ModelComponent for computing the net metabolic energy rate of a set of Muscles in the model during a simulation |
| OpenSim::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 |
| OpenSim::MuscleActiveFiberPowerProbe | MuscleActiveFiberPowerProbe is a ModelComponent probe for computing an operation on the active fiber power of a muscle |
| OpenSim::SystemEnergyProbe | SystemEnergyProbe is a ModelComponent Probe for computing an operation on a total system energy during a simulation |
| OpenSim::Umberger2010MuscleMetabolicsProbe | Umberger2010MuscleMetabolicsProbe is a Probe ModelComponent for computing the net metabolic energy rate of a set of Muscles in the model during a simulation |
| OpenSim::ModelScaler | A class for scaling a model |
| OpenSim::MuscleFirstOrderActivationDynamicModel | This is a muscle modeling utility class that computes the time derivative of activation using a first-order dynamic model |
| OpenSim::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 |
| OpenSim::MuscleSecondOrderActivationDynamicModel | This function is a muscle modeling utility class that simulates dynamics of muscle force development as a function of input excitation |
| OpenSim::ObjectGroup | A class implementing an object group |
| OpenSim::PathPoint | A class implementing a path point |
| OpenSim::ConditionalPathPoint | A class implementing a conditional path point, which is a point that is active only for a specified range of a coordinate |
| OpenSim::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 |
| OpenSim::Reference_< T > | This base (abstract) class defines the interface for objects repsonsible in identifying a model output and its Reference value to be achieved via optimization and/or tracking |
| OpenSim::Scale | |
| OpenSim::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 |
| OpenSim::Set< T > | A class for holding a set of pointers to objects |
| OpenSim::ModelComponentSet< T > | This is the base class for sets of ModelComponent subclasses |
| OpenSim::SimbodyEngine | A wrapper class to use the SimTK Simbody dynamics engine as the underlying engine for OpenSim |
| OpenSim::Solver | The base (abstract) class for a family of objects repsonsible for solving system equations (statics, dynamic, kinematics, muscle, etc...) given by a model for values of interest |
| OpenSim::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 |
| OpenSim::InverseKinematicsSolver | 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 |
| OpenSim::InducedAccelerationsSolver | A Solver to compute the induced accelerations of an applied "force" acting on the model |
| OpenSim::InverseDynamicsSolver | Solve for the generalized coordinate coordinate forces (1 per degree-of-freedom) that satisfy the unconstrained equations of motion given kinemtics: q, u, u_dot |
| OpenSim::MomentArmSolver | Solve for the effective moment arms at all degrees-of-freedom due to one or more point forces |
| OpenSim::SpatialTransform | A class encapsulating the spatial transformation between two bodies that defines the behaviour of a custom joint |
| OpenSim::StorageInterface | |
| OpenSim::Storage | |
| OpenSim::Tool | A Tool is an OpenSim abstraction that encapsulates an analysis or series of modeling and analysis steps |
| OpenSim::DynamicsTool | An abstract Tool for defining tools for perfroming a dynamics analysis with a given model |
| OpenSim::InverseDynamicsTool | A Tool that performs an Inverse Dynamics analysis with a given model |
| OpenSim::InverseKinematicsTool | A Tool that performs an Inverse Kinematics analysis with a given model |
| OpenSim::TrackingTask | An abstract base class for specifying a target for a tracking problem |
| OpenSim::CMC_Task | An abstract base class for specifying a task objective for a dynamic simulation |
| OpenSim::CMC_Joint | A class for specifying the tracking task for a joint |
| OpenSim::SMC_Joint | A class for specifying the tracking task for a joint |
| OpenSim::CMC_Orientation | A class for tracking the orientation of a body |
| OpenSim::CMC_Point | A class for specifying and computing parameters for tracking a point |
| OpenSim::StateTrackingTask | A target for a tracking problem that corresponds to a state variable |
| OpenSim::MuscleStateTrackingTask | A TrackingTask for that corresponds to a muscle state variable |
| OpenSim::TransformAxis | A class expressing a transformation of a child body in relation to a parent body along either a translation or rotation axis |
| OpenSim::Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameter | |
| OpenSim::VectorFunction | |
| OpenSim::VectorFunctionUncoupledNxN | |
| OpenSim::VectorFunctionForActuators | |
| OpenSim::VisibleObject | Class VisibleObject is intended to be used as the base class for all Visible objects that subclass Object |
| OpenSim::Reference_< double > | |
| OpenSim::CoordinateReference | Reference value to be achieved for a specified coordinate that will be used via optimization and/or tracking |
| OpenSim::Reference_< SimTK::Vec3 > | |
| OpenSim::MarkersReference | |
| OpenSim::Set< Analysis > | |
| OpenSim::AnalysisSet | |
| OpenSim::Set< Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameter > | |
| OpenSim::Bhargava2004MuscleMetabolicsProbe_MetabolicMuscleParameterSet | MetabolicMuscleParameterSet is a class that holds the set of MetabolicMuscleParameters for each muscle |
| OpenSim::Set< Body > | |
| OpenSim::ModelComponentSet< Body > | |
| OpenSim::BodySet | A class for holding a set of bodies |
| OpenSim::Set< BodyScale > | |
| OpenSim::BodyScaleSet | A class for holding a set of body scales |
| OpenSim::Set< Constraint > | |
| OpenSim::ModelComponentSet< Constraint > | |
| OpenSim::ConstraintSet | A class for holding a set of constraints |
| OpenSim::Set< ContactGeometry > | |
| OpenSim::ModelComponentSet< ContactGeometry > | |
| OpenSim::ContactGeometrySet | A class for holding a set of ContactGeometry objects |
| OpenSim::Set< Control > | |
| OpenSim::ControlSet | |
| OpenSim::Set< Controller > | |
| OpenSim::ModelComponentSet< Controller > | |
| OpenSim::ControllerSet | A class for holding and managing a set of controllers for a model |
| OpenSim::Set< Coordinate > | |
| OpenSim::ModelComponentSet< Coordinate > | |
| OpenSim::CoordinateSet | A class for holding a set of coordinates |
| OpenSim::Set< DisplayGeometry > | |
| OpenSim::GeometrySet | |
| OpenSim::Set< ExternalForce > | |
| OpenSim::ModelComponentSet< ExternalForce > | |
| OpenSim::ExternalLoads | A convenience class for managing ExternaForce(s) to be applied to a model |
| OpenSim::Set< Force > | |
| OpenSim::ModelComponentSet< Force > | |
| OpenSim::ForceSet | A class for holding and managing a set of forces for a model |
| OpenSim::Set< Function > | |
| OpenSim::FunctionSet | |
| OpenSim::GCVSplineSet | |
| OpenSim::Set< IKTask > | |
| OpenSim::IKTaskSet | |
| OpenSim::Set< Joint > | |
| OpenSim::ModelComponentSet< Joint > | |
| OpenSim::JointSet | A class for holding a set of joints |
| OpenSim::Set< Marker > | |
| OpenSim::MarkerSet | A class for holding a set of markers for inverse kinematics |
| OpenSim::Set< MarkerPair > | |
| OpenSim::MarkerPairSet | A class for holding a set of SimmMarkerPairs |
| OpenSim::Set< Measurement > | |
| OpenSim::MeasurementSet | A class for holding a set of measurements |
| OpenSim::Set< ModelComponent > | |
| OpenSim::ModelComponentSet< ModelComponent > | |
| OpenSim::ComponentSet | A class for holding a set of miscellaneous model components |
| OpenSim::Set< OpenSim::Actuator > | |
| OpenSim::Set< OpenSim::Constraint > | |
| OpenSim::Set< OpenSim::Force > | |
| OpenSim::Set< OpenSim::MarkerWeight > | |
| OpenSim::Set< OpenSim::Muscle > | |
| OpenSim::Set< PathPoint > | |
| OpenSim::PathPointSet | A class for holding a set of muscle points |
| OpenSim::Set< Probe > | |
| OpenSim::ModelComponentSet< Probe > | |
| OpenSim::ProbeSet | A class for holding a set of probes |
| OpenSim::Set< Scale > | |
| OpenSim::ScaleSet | |
| OpenSim::Set< TrackingTask > | |
| OpenSim::CMC_TaskSet | An class for holding and managing a set of tasks |
| OpenSim::Set< Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameter > | |
| OpenSim::Umberger2010MuscleMetabolicsProbe_MetabolicMuscleParameterSet | MetabolicMuscleParameterSet is an internal container class containing the set of MetabolicMuscleParameters for each muscle that is probed |
| OpenSim::ObjectProperty< T > | |
| OptimizerSystem | |
| OpenSim::OptimizationTarget | This class provides an interface specification for optimizing redundant systems |
| OpenSim::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 |
| OpenSim::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 |
| OpenSim::StaticOptimizationTarget | This class provides an interface specification for static optimization Objective Function |
| osimInstantiator | |
| OpenSim::PointForceDirection | Convenience class for a generic representation of geometery of a complex Force (or any other object) with multiple points of contact through which forces are applied to bodies |
| OpenSim::MuscleAnalysis::private | |
| OpenSim::PropertyGroup | A class implementing a property group |
| OpenSim::PropertySet | A property set is simply a set of properties |
| OpenSim::PropertyTable | A property table is the container that an OpenSim Object uses to hold its properties (each derived from base class AbstractProperty) |
| OpenSim::RootSolver | A class for finding the N roots of N one-dimensional non-linear equations |
| OpenSim::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 |
| OpenSim::Signal | A class for signal processing |
| OpenSim::SimpleProperty< T > | |
| OpenSim::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 |
| OpenSim::StateVector | A class which stores a vector of states or data at a specified time |
| OpenSim::StorageCreator | |
| OpenSim::StorageFactory | |
| OpenSim::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 |
| OpenSim::Units | A class implementing various units for measuring quantities |
1.8.4 
