|
OpenSim
OpenSim 3.0
|
|
OpenSim
OpenSim 3.0
|
Generate a force that acts to limit the range of motion of a coordinate. More...
Namespaces | |
| namespace | DebugUtilities |
Classes | |
| class | ActiveForceLengthCurve |
| This class serves as a serializable ActiveForceLengthCurve, for use in muscle models. More... | |
| class | ContDerivMuscle_Deprecated |
| A class implementing a SIMM muscle. More... | |
| class | CoordinateActuator |
| An actuator that applies a generalized force to along a generalized a generalized coordinate, which is proportional to its input control. More... | |
| class | CoordinateLimitForce |
| class | Delp1990Muscle_Deprecated |
| A class implementing a SIMM muscle. More... | |
| class | 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. More... | |
| class | 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. More... | |
| class | FiberForceLengthCurve |
| This class serves as a serializable FiberForceLengthCurve, commonly used to model the parallel elastic element, for use in muscle models. More... | |
| class | ForceVelocityCurve |
| This class serves as a serializable ForceVelocityCurve, for use in muscle models. More... | |
| class | ForceVelocityInverseCurve |
| This class serves as a serializable ForceVelocityInverseCurve, for use in equilibrium muscle models. More... | |
| class | 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. More... | |
| class | Millard2012EquilibriumMuscle |
This class implements a 2 state (activation and fiber length) equilibrium muscle model that uses a unilateral constraint to ensure that the singularity conditions typical of equilibrium models (when  ,  , and  ) are prevented. More... | |
| class | MuscleFirstOrderActivationDynamicModel |
| This function is a muscle modeling utility class that computes the derivative of activation with respect to time time using a modification of the activation model presented in Thelen 2003. More... | |
| class | MuscleFixedWidthPennationModel |
| This is a class that acts as a utility class that contains all of the necessary kinematic equations required to use a fixed width parallelogram pennation model to compute the way the muscle fibers deform as the muscle contracts. More... | |
| class | PointActuator |
| A class that implements a point actuator acting on the model. More... | |
| class | PointToPointActuator |
| A class that implements a force actuator acting between two points on two bodies. More... | |
| class | RigidTendonMuscle |
| A class implementing a RigidTendonMuscle actuator with no states. More... | |
| class | Schutte1993Muscle_Deprecated |
| A class implementing a SIMM muscle. More... | |
| class | SpringGeneralizedForce |
| class | TendonForceLengthCurve |
| This class serves as a serializable TendonForceLengthCurve, for use in muscle models. More... | |
| class | 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. More... | |
| class | Thelen2003Muscle_Deprecated |
| A class implementing a SIMM muscle. More... | |
| class | TorqueActuator |
| A class that implements a torque actuator acting on a body. More... | |
| class | Actuation |
| A class for recording the basic actuator information for a model during a simulation. More... | |
| class | BodyKinematics |
| A class for recording the kinematics of the bodies of a model during a simulation. More... | |
| class | ForceReporter |
| A class for recording the Forces applied to a model during a simulation. More... | |
| class | 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. More... | |
| class | JointReaction |
| An analysis for reporting the joint reaction loads from a model. More... | |
| class | Kinematics |
| A class for recording the kinematics of the generalized coordinates of a model during a simulation. More... | |
| class | MuscleAnalysis |
| A class for recording and computting basic quantities (length, shortening velocity, tendon length, ...) for muscles during a simulation. More... | |
| class | PointKinematics |
| A class for recording the kinematics of a point on a body of a model during a simulation. More... | |
| class | ProbeReporter |
| A class for reporting the outputs of all model-connected Probes to file during a simulation. More... | |
| class | StatesReporter |
| A class for recording the states of a model during a simulation. More... | |
| class | StaticOptimization |
| This class implements static optimization to compute Muscle Forces and activations. More... | |
| class | StaticOptimizationTarget |
| This class provides an interface specification for static optimization Objective Function. More... | |
| class | AbstractProperty |
An abstract property is a serializable (name,value) pair, for which we do not know the type of the value. More... | |
| class | Array |
| class | Constant |
| A class for representing a constant value. More... | |
| class | DisplayGeometry |
| A class for representing the DisplayGeometry properties of an object. More... | |
| class | Exception |
| class | Function |
| class | FunctionScaler |
| This is a SimTK::Function that multiplies the value of another function by a constant. More... | |
| class | FunctionSet |
| class | GCVSpline |
| class | GCVSplineSet |
| class | 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. More... | |
| class | LineGeometry |
| class | ArrowGeometry |
| class | AnalyticGeometry |
| Utility class used to abstract anayltic geometry. More... | |
| class | AnalyticSphere |
| class | AnalyticEllipsoid |
| class | AnalyticCylinder |
| class | AnalyticTorus |
| class | PolyhedralGeometry |
| class | GeometrySet |
| class | InterruptedException |
| class | IO |
| A class for performing input and output with OpenSim API. More... | |
| class | LinearFunction |
| A class for representing a LinearFunction. More... | |
| class | MarkerData |
| A class implementing a sequence of marker frames from a TRC/TRB file. More... | |
| class | MarkerFrame |
| A class implementing a frame of marker data from a TRC/TRB file. More... | |
| class | MultiplierFunction |
| class | Object |
This is the base class for all %OpenSim objects that are serializable (meaning they can be written to and read back from files). More... | |
| class | ObjectGroup |
| A class implementing an object group. More... | |
| class | OptimizationTarget |
| This class provides an interface specification for optimizing redundant systems. More... | |
| class | PiecewiseConstantFunction |
| class | PiecewiseLinearFunction |
| class | Property |
A %Property\<T> is a serializable (name, list-of-values) pair, where each value is of type T. More... | |
| class | Property_Deprecated |
| class | PropertyBool |
| class | PropertyBoolArray |
| Class PropertyBoolArray extends class Property. More... | |
| class | PropertyDbl |
| class | PropertyDblArray |
| class | PropertyDblVec_ |
| class | PropertyGroup |
| A class implementing a property group. More... | |
| class | PropertyInt |
| class | PropertyIntArray |
| class | PropertyObj |
| class | PropertyObjArray |
| class | PropertyObjPtr |
| class | PropertySet |
| A property set is simply a set of properties. More... | |
| class | PropertyStr |
| class | PropertyStrArray |
| class | PropertyTable |
| A property table is the container that an OpenSim Object uses to hold its properties (each derived from base class AbstractProperty). More... | |
| class | PropertyTransform |
| class | RootSolver |
| A class for finding the N roots of N one-dimensional non-linear equations. More... | |
| class | Scale |
| class | ScaleSet |
| class | 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. More... | |
| class | Set |
| A class for holding a set of pointers to objects. More... | |
| class | Signal |
| A class for signal processing. More... | |
| class | SimmSpline |
| class | Sine |
| A class for representing a Sine function. More... | |
| class | 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. More... | |
| class | 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. More... | |
| class | StateVector |
| A class which stores a vector of states or data at a specified time. More... | |
| class | StepFunction |
| A class for representing a StepFunction. More... | |
| class | Storage |
| class | StorageCreator |
| class | StorageFactory |
| class | StorageInterface |
| class | Units |
| A class implementing various units for measuring quantities. More... | |
| class | VectorFunction |
| class | VectorFunctionUncoupledNxN |
| class | VisibleObject |
| Class VisibleObject is intended to be used as the base class for all Visible objects that subclass Object. More... | |
| class | XMLDocument |
| class | OpenSimContext |
Class intended to keep the SimTK::State under an OpenSim model to make it possible to get/set values in the SimTK::State without exposing the SimTK::State class itself. More... | |
| class | OpenSimJavaObject |
| In some cases, the GUI ad/or scripting language needs to create objects that derive from OpenSim::Object The class OpenSim::Object however is not a concrete class, so we introduce OpenSimJavaObject for this purpose. More... | |
| class | AnalysisWrapper |
| Class used as base class for Java classes deriving from Analysis (used to be callback) It lives on the C++ side so that it gets access to SimTK::State, but it returns quantities in Java data types. More... | |
| class | InterruptCallback |
| Class used to handle interrupts (synchronously). More... | |
| class | PropertyHelper |
| This class allows access to property values using template-free methods. More... | |
| class | AnalysisPlugin_Template |
| class | BodyDrag |
| class | 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. More... | |
| class | Control |
| class | ControlConstant |
| class | Controller |
| Controller is an abstract ModelComponent that defines the interface for an OpenSim Controller. More... | |
| class | ControlLinear |
| class | ControlLinearNode |
| class | ControlSet |
| class | ControlSetController |
| class | PrescribedController |
| class | TrackingController |
| class | CoordinateReference |
| Reference value to be achieved for a specified coordinate that will be used via optimization and/or tracking. More... | |
| class | 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. More... | |
| class | 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. More... | |
| class | Manager |
| A class that manages the execution of a simulation. More... | |
| class | MarkerWeight |
| class | MarkersReference |
| class | AbstractTool |
| An abstract class for specifying the interface for an investigation. More... | |
| class | ActivationFiberLengthMuscle |
| A base class representing a two-state muscle-tendon actuator. More... | |
| class | ActivationFiberLengthMuscle_Deprecated |
| A base class representing a muscle-tendon actuator. More... | |
| class | Actuator_ |
| Base class for an actuator (e.g., a torque motor, muscle, ...) that requires external input (controls) to generate force. More... | |
| class | 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. More... | |
| class | ActuatorForceProbe |
| ActuatorForceProbe is a ModelComponent Probe for computing an operation on a force or sum of forces in the model during a simulation. More... | |
| class | 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. More... | |
| class | Analysis |
| An abstract class for specifying the interface for an analysis plugin. More... | |
| class | AnalysisSet |
| class | BodyScale |
| A class implementing a set of parameters describing how to scale a body segment. More... | |
| class | BodyScaleSet |
| A class for holding a set of body scales. More... | |
| class | BodySet |
| A class for holding a set of bodies. More... | |
| class | BushingForce |
| A class implementing a Bushing Force. More... | |
| class | ComponentSet |
| A class for holding a set of miscellaneous model components. More... | |
| class | Condition |
| A parent class for implementing an OpenSim Condition. More... | |
| class | ConditionalPathPoint |
| A class implementing a conditional path point, which is a point that is active only for a specified range of a coordinate. More... | |
| class | ConstraintSet |
| A class for holding a set of constraints. More... | |
| class | ContactGeometry |
| This class represents the physical shape of an object for use in contact modeling. More... | |
| class | ContactGeometrySet |
| A class for holding a set of ContactGeometry objects. More... | |
| class | ContactHalfSpace |
| This class represents a half space (that is, everything to one side of an infinite plane) for use in contact modeling. More... | |
| class | ContactMesh |
| This class represents a polygonal mesh for use in contact modeling. More... | |
| class | ContactSphere |
| This class represents a spherical object for use in contact modeling. More... | |
| class | ControllerSet |
| A class for holding and managing a set of controllers for a model. More... | |
| class | CoordinateSet |
| A class for holding a set of coordinates. More... | |
| class | ElasticFoundationForce |
| This Force subclass implements an elastic foundation contact model. More... | |
| class | ExternalForce |
| This applies a force and/or torque to a body according describe by arrays contained in a Storage The source of the Storage may be experimental sensor recording or user generated data. More... | |
| class | ExternalLoads |
| A convenience class for managing ExternaForce(s) to be applied to a model. More... | |
| class | Force |
| This abstract class represents a force applied to bodies or generalized coordinates during a simulation. More... | |
| class | ForceAdapter |
| This acts as an adapter to allow a Force or Actuator to be used as a SimTK::Force. More... | |
| class | ForceSet |
| A class for holding and managing a set of forces for a model. More... | |
| class | FunctionThresholdCondition |
| FunctionThresholdCondition is a concrete implementation of a Condition. More... | |
| class | GeometryPath |
| A base class representing a path (muscle, ligament, etc.). More... | |
| class | HuntCrossleyForce |
| This force subclass implements a Hunt-Crossley contact model. More... | |
| class | 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. More... | |
| class | JointSet |
| A class for holding a set of joints. More... | |
| class | Ligament |
| A class implementing a ligament. More... | |
| class | Marker |
| A class implementing a SIMM [mocap] marker. More... | |
| class | MarkerSet |
| A class for holding a set of markers for inverse kinematics. More... | |
| class | Model |
| A concrete class that specifies the interface to a musculoskeletal model. More... | |
| class | ModelComponent |
| This defines the abstract ModelComponent class, which is used to add computational components to the underlying SimTK::System (MultibodySystem). More... | |
| class | ModelComponentSet |
| This is the base class for sets of ModelComponent subclasses. More... | |
| class | ModelDisplayHints |
This class captures information indicating user or programmer preferences to guide automatic display geometry generation by a Model. More... | |
| class | ModelVisualizer |
This class manages runtime visualization of a Model that is being | |
| class | 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. More... | |
| class | Muscle |
| A base class for modeling a muscle-tendon actuator. More... | |
| class | PathActuator |
| This is the base class for actuators that apply controllable tension along a geometry path. More... | |
| class | PathPoint |
| A class implementing a path point. More... | |
| class | PathPointSet |
| A class for holding a set of muscle points. More... | |
| class | PointForceDirection |
| Convenience class for a generic representation of geomtery of a complex Force (or any other object) with multiple points of contact through which forces are applied to bodies. More... | |
| class | PointToPointSpring |
| class | PrescribedForce |
This applies to a body a force and/or torque that is fully specified as a function of time. More... | |
| class | Probe |
| This class represents a Probe which is designed to query a Vector of model values given system state. More... | |
| class | ProbeSet |
| A class for holding a set of probes. More... | |
| class | SystemEnergyProbe |
| SystemEnergyProbe is a ModelComponent Probe for computing an operation on a total system energy during a simulation. More... | |
| class | MomentArmSolver |
| Solve for the effective moment arms at all degrees-of-freedom due to one or more point forces. More... | |
| class | Reference_ |
| 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. More... | |
| class | BallJoint |
| A class implementing an Ball joint. More... | |
| class | Body |
| A class implementing a Simbody rigid body. More... | |
| class | ConstantDistanceConstraint |
| A class implementing a constraint that maintains a constant distance between between two points. More... | |
| class | Constraint |
| A parent class for implementing a Simbody Constraint. More... | |
| class | 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). More... | |
| class | CoordinateCouplerConstraint |
| class | CustomJoint |
| A class implementing a custom joint. More... | |
| class | EllipsoidJoint |
| A class implementing an Ellipsoid joint. More... | |
| class | FreeJoint |
| A class implementing a Free joint. More... | |
| class | Joint |
| A class implementing an OpenSim Joint. More... | |
| class | PinJoint |
| A class implementing an Pin joint. More... | |
| class | PointConstraint |
| A class implementing a Point Constraint. More... | |
| class | PointOnLineConstraint |
| A class implementing a Point On Line Constraint. More... | |
| class | RollingOnSurfaceConstraint |
| A class implementing a collection of rolling-without-slipping and non-penetration constraints on a surface. More... | |
| class | SimbodyEngine |
| A wrapper class to use the SimTK Simbody dynamics engine as the underlying engine for OpenSim. More... | |
| class | SliderJoint |
| A class implementing an Slider joint. More... | |
| class | SpatialTransform |
| A class encapsulating the spatial transformation bewteen two bodies that defines the behaviour of a custom joint. More... | |
| class | TransformAxis |
| A class expressing a transformation of a child body in relation to a parent body along either a translation or rotation axis. More... | |
| class | UnilateralConstraint |
| An abstract class defining an OpenSim UnilateralConstraint. More... | |
| class | UniversalJoint |
| A class implementing a Universal joint. More... | |
| class | WeldConstraint |
| A class implementing a Weld Constraint. More... | |
| class | WeldJoint |
| A class implementing an Weld joint. More... | |
| class | 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. More... | |
| class | 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. More... | |
| class | 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. More... | |
| class | AnalyzeTool |
| An abstract class for specifying the interface for an investigation. More... | |
| class | 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 goverend by differential equaitions (as so have delays in force production). More... | |
| class | CMC_Joint |
| A class for specifying the tracking task for a joint. More... | |
| class | CMC_Orientation |
| A class for tracking the orientation of a body. More... | |
| class | CMC_Point |
| A class for specifying and computing parameters for tracking a point. More... | |
| class | CMC_Task |
| An abstract base class for specifying a task objective for a dynamic simulation. More... | |
| class | CMC_TaskSet |
| An class for holding and managing a set of tasks. More... | |
| class | CMCTool |
| An abstract class for specifying the interface for an investigation. More... | |
| class | CorrectionController |
| This is a simple feedback controller to be used in generating a forward dynamic simulation. More... | |
| class | DynamicsTool |
| An abstract Tool for defining tools for perfroming a dynamics analysis with a given model. More... | |
| class | ForwardTool |
| A concrete tool for perfroming forward dynamics simulations. More... | |
| class | GenericModelMaker |
| A class implementing a set of parameters describing a generic musculoskeletal model. More... | |
| class | IKCoordinateTask |
| class | IKMarkerTask |
| class | IKTask |
| class | IKTaskSet |
| class | InverseDynamicsTool |
| A Tool that performs an Inverse Dynamics analysis with a given model. More... | |
| class | InverseKinematicsTool |
| A Tool that performs an Inverse Kinematics analysis with a given model. More... | |
| class | MarkerPair |
| class | MarkerPairSet |
| A class for holding a set of SimmMarkerPairs. More... | |
| class | 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). More... | |
| class | Measurement |
| A class implementing a measurement (the distance between one or more pairs of markers, used to scale a model). More... | |
| class | MeasurementSet |
| A class for holding a set of measurements. More... | |
| class | ModelScaler |
| A class for scaling a model. More... | |
| class | MuscleStateTrackingTask |
| A TrackingTask for that corresponds to a muscle state variable. More... | |
| class | RRATool |
| An abstract class for specifying the interface for an investigation. More... | |
| class | 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. More... | |
| class | SMC_Joint |
| A class for specifying the tracking task for a joint. More... | |
| class | StateTrackingTask |
| A target for a tracking problem that corresponds to a state variable. More... | |
| class | Tool |
| A Tool is an OpenSim abstraction that encapsulates an analysis or series of modeling and analysis steps. More... | |
| class | TrackingTask |
| An abstract base class for specifying a target for a tracking problem. More... | |
| class | VectorFunctionForActuators |
Typedefs | |
| typedef PropertyDblVec_< 2 > | PropertyDblVec2 |
| typedef PropertyDblVec_< 3 > | PropertyDblVec3 |
| typedef PropertyDblVec_< 4 > | PropertyDblVec4 |
| typedef PropertyDblVec_< 5 > | PropertyDblVec5 |
| typedef PropertyDblVec_< 6 > | PropertyDblVec6 |
| typedef std::map< std::string, std::string, std::less < std::string > > | MapKeysToValues |
| typedef std::map< std::string, OpenSim::StorageCreator *, std::less< std::string > > | mapExtensionsToCreators |
Functions | |
| OSIMCOMMON_API OPENSIM_PORTABLE_HMODULE WINAPI | LoadOpenSimLibrary (const std::string &lpLibFileName, bool verbose) |
| OSIMCOMMON_API void | LoadOpenSimLibrary (const std::string &aLibraryName) |
| OSIMCOMMON_API void | LoadOpenSimLibraries (int argc, char **argv) |
| bool OSIMCOMMON_API | readNonCommentStringFromStream (std::istream &aStream, std::string &rBuffer) |
| bool OSIMCOMMON_API | readStringFromStream (std::istream &aStream, std::string &rBuffer) |
| bool OSIMCOMMON_API | readStringFromString (std::string &aString, std::string &rBuffer) |
| bool OSIMCOMMON_API | readTabDelimitedStringFromString (std::string &aString, std::string &rBuffer) |
| bool OSIMCOMMON_API | readIntegerFromString (std::string &aString, int *rNumber) |
| bool OSIMCOMMON_API | readDoubleFromString (std::string &aString, double *rNumber, bool allowNaNs=false) |
| bool OSIMCOMMON_API | readVectorFromString (std::string &aString, SimTK::Vec3 &rVec) |
| bool OSIMCOMMON_API | readVectorFromString (std::string &aString, double *rVX, double *rVY, double *rVZ) |
| bool OSIMCOMMON_API | readCoordinatesFromString (std::string &aString, double rVec[3], bool allowNaNs=false) |
| int OSIMCOMMON_API | findFirstNonWhiteSpace (std::string &aString) |
| int OSIMCOMMON_API | findFirstWhiteSpace (std::string &aString) |
| void OSIMCOMMON_API | convertString (std::string &aString, bool aPrependUnderscore) |
| std::string OSIMCOMMON_API | getCurrentTimeString () |
Variables | |
| const char | ObjectDEFAULT_NAME [] = "default" |
Generate a force that acts to limit the range of motion of a coordinate.
A class for holding the names of a pair of markers (for making measurements on a model).
A simple point to point spring with a resting length and stiffness.
A class for holding and managing a set of integration callbacks for a model.
TrackingController is an abstract class from which all tracking type of controllers should be derived.
PrescribedController is a concrete class that uses functions to prescribe control values to actuators in its set of actuators.
ControllerSetController that simply assigns controls from a ControlSet.
A class for holding and managing a set of controls for a dynamic simulation.
A control node used to reconstruct a piecewise linear control.
A class that represents a piece-wise linear control curve.
A class that represents a constant control curve.
A class that represents a control in a dynamic simulation.
An abstract class for representing a vector function.
A class for storing an array of statevectors.
A class for representing smooth functions with b-splines.
A class implementing a smooth function with a cubic spline as implemented in SIMM.
Class PropertyTransform extends class Property.
Class PropertyStrArray extends class Property.
Class PropertyObjPtr extends class Property.
Class PropertyObjArray extends class Property.
Class PropertyObj extends class Property.
Class PropertyIntArray extends class Property.
Class PropertyInt extends class Property.
Class PropertyDblVec_ extends class Property.
Class PropertyDblArray extends class Property.
Class PropertyDbl extends class Property.
Class PropertyBool extends class Property.
A class implementing a linear function.
A class implementing a step function.
A class implementing a Function and a scale factor for the function's value.
Typically used by the GUI to stop long computations (e.g.
A class for holding a set of generalized cross-validated splines.
A class for representing a smooth function with a generalized cross-validation spline.
A class for holding a set of functions.
This is a SimTK::Function that acts as a wrapper around an OpenMM::Function.
An abstract class for representing a function.
A class for basic exception functionality.
A class for storing an array of values of type T.
An force that exerts a generalized force based on spring-like characteristics (stiffness and viscosity).
Force is experienced at upper and lower limits of the coordinate value according to a constant siffneses K_upper and K_lower, with a C2 continuous transition from 0 to K. The transition parameter defines how far beyond the limit the stiffness becomes constant. The integrator will like smoother (i.e. larger transition regions).
Damping factor is also phased in through the transiton region from 0 to the value provided.
Limiting force is guaranteed to be zero within the upper and lower limits.
The potential energy stored in the spring component of the force is accessible as well as the power (nd optionally energy) dissipated.
The capacity of the class grows as needed. To use this template for a class of type T, class T should implement the following methods: default constructor, copy constructor, assignment operator (=), equality operator (==), and less than operator (<).
A function is a relation between independent variables and a dependent value such that for any particular set of independent variables there is only one unique dependent value. Values of the function and its derivatives are obtained by calling the evaluate() method. The curve may or may not be finite or diferentiable; the evaluate method returns values between -SimTK::Infinity and SimTK::Infinity, or it returns SimTK::NaN (not a number) if the curve is not defined. Currently, functions of up to 3 variables (x,y,z) are supported.
Linear, cubic, qunitic, and heptic splines are supported:
m (half-order) order degree description 1 2 1 linear 2 4 3 cubic 3 6 5 quintic 4 8 7 heptic
This class wraps the gcvspl.c source code written by D. Twisk in 1994, which is based on the GCVSPL code written in Fortran by Woltring in 1985_07_04. This class was initially based on a spline class authored by Darryl Thelen and Victor Ng; it has been rewritten to fit into the Realistic Dynamics, Inc. software framework.
See the following source for details on how the GCV spline is fit: Woltring, H.J. (1986). A Fortran package for generalized, cross-validatory spline smoothing and differentiation. Advances in Engineering Software, Vol. 8, No. 2, 104-113.
This class inherits from Function and so can be used as input to any class requiring an Fuction as input.
IK, CMC, etc.)
This class inherits from Function and so can be used as input to any class requiring a Fuction as input.
This class inherits from Function and so can be used as input to any class requiring a Function as input.
It consists of a boolean value and the methods for accessing and modifying this value.
It consists of a double value and the methods for accessing and modifying this value.
It consists of an array of doubles (i.e., Array<double>) and the methods for accessing and modifying this array.
It consists of a small vector of doubles (i.e., SimTK::Vec<M>) and the methods for accessing and modifying this Vec<M>.
It consists of an integer value and the methods for accessing and modifying this value.
It consists of an array of integers (i.e., Array<int>) and the methods for accessing and modifying this array.
It consists of a pointer to an object and the methods for accessing and modifying this object.
Assumes template T is a class derived from Object.
It differs from ProprtyObj in that PropertyObj looks for an XML element with a specific tag name (matching the object type), PropertyObjPtr accepts any recognized object type. It's essentially like a singleton PropertyObjArray.
Note: Class owns its Object _value (so it is deleted as appropriate).
It consists of a string value and the methods for accessing and modifying this value.
It consists of an array of strings (i.e., Array<string>) and the methods for accessing and modifying this array.
It consists of a Transform (i.e., SimTK::Transform) and the methods for accessing and modifying this Transform.
Use a SIMM Spline if you want to reproduce the behavior of a joint function created in SIMM.
This class inherits from Function and so can be used as input to any class requiring a Fuction as input.
A statevector is an array of data that has an associated time stamp (see StateVector). Generally, it is used to store the time histories of the states during an integration, but may be used for a variety of applications. Note that it is assumed by several methods in this class that the time stamps of stored statevectors are monotonically increasing.
When stored as a file, the statevectors are stored in rows. This first value in a row is the time stamp at which the states occured. The rest of the elements in a row are the states. Therefore, each column of data in a file corresponds to a particular state.
In an Storage object, statevectors (or rows) are indexed by the TimeIndex, and a particular state (or column) is indexed by the StateIndex.
A vector function is a relation between some number of independent variables and some number of dependent values such that for any particular set of independent variables the correct number of dependent variables is returned. Values of the function and its derivatives are obtained by calling the evaluate() method. The curve may or may not be finite or diferentiable; the evaluate method returns values between -SimTK::Infinity and SimTK::Infinity, or it returns SimTK::NaN (not a number) if the curve is not defined. Currently, functions of up to 3 variables (x,y,z) are supported.
A vector function is a relation between some number of independent variables and some number of dependent values such that for any particular set of independent variables the correct number of dependent variables is returned. Values of the function and its derivatives are obtained by calling the evaluate() method. The curve may or may not be finite or diferentiable; the evaluate method returns values between -SimTK::Infinity and SimTK::Infinity , or it returns SimTK::NaN (not a number) if the curve is not defined. Currently, functions of up to 3 variables (x,y,z) are supported.
This class is intended to be the base class for different types of controls, so many of its methods are virtual.
In general, a control consists of a set of parameters. These parameters are used to reconstruct a control curve. For example, a control may be represented by a consant, a series of step functions, a set of linearly interpolated values, a set of spline control points, coefficients in a Fourier series, etc.
Because there is not necessarily a 1-to-1 correspondence between the parameters used to represent a control curve and the value of the control curve, there are two basic ways to access the content of a control: getParameter() gets the value of a parameter, and getValue() gets the value at a particular time.
A distinction is also made between controls that control a model and controls that control some other aspect of a simulation. For example, a control for the excitation level of a muscle is a "model" control. The value of this type of control is querried during the course of a simualtion. On the other hand, a control for the final time of a simulation is not usually a "model" control. Nor is a control for the initial value of a state variable, even if that state variable is the initial value of a muscle activation. These "non-model" controls are used to set things before a simulation ever begins and are not querried during the cours of a simulation. The number of model controls can be querried by a call to Model::getNumControls().
That is, the value of the control curve is the same at any value of time.
The curve is specified by an array of control nodes (see class ControlLinearNode) that occur at monotonically increasing times. The value of the control curve is computed by linearly interpolating the values of the appropriate control nodes.
The member variables consist of a time, a value, a minimum value, and a maximum value. So that an Array<T> can be instantiated for ControlLinearNode, this class implements a default constructor, a copy constructor, the assignment operator (=), the equality operator (==), and the less than operator (<). The time at which a control node occurs is used to determine the results of the operators == and <.
This class implements convenience methods to construct dsired trajectories of desired model state values, like joint angles, from Storage (file) or user-supplied functions and provides methods for obtaining the error between model and desired state values.
Derive classes need only to implement the tracking control law based on the error signals computed by this base class.
Points are connected to bodies and are defined in the body frame.
A vector function is a relation between some number of independent variables and some number of dependent values such that for any particular set of independent variables the correct number of dependent variables is returned. Values of the function and its derivatives are obtained by calling the evaluate() method. The curve may or may not be finite or diferentiable; the evaluate method returns values between -SimTK::Infinity and SimTK::Infinity, or it returns SimTK::NaN (not a number) if the curve is not defined. Currently, functions of up to 3 variables (x,y,z) are supported.
| typedef std::map<std::string, OpenSim::StorageCreator*, std::less<std::string> > OpenSim::mapExtensionsToCreators |
| typedef std::map<std::string, std::string, std::less<std::string> > OpenSim::MapKeysToValues |
| typedef PropertyDblVec_<2> OpenSim::PropertyDblVec2 |
| typedef PropertyDblVec_<3> OpenSim::PropertyDblVec3 |
| typedef PropertyDblVec_<4> OpenSim::PropertyDblVec4 |
| typedef PropertyDblVec_<5> OpenSim::PropertyDblVec5 |
| typedef PropertyDblVec_<6> OpenSim::PropertyDblVec6 |
| void OSIMCOMMON_API OpenSim::convertString | ( | std::string & | aString, |
| bool | aPrependUnderscore | ||
| ) |
| int OSIMCOMMON_API OpenSim::findFirstNonWhiteSpace | ( | std::string & | aString | ) |
| int OSIMCOMMON_API OpenSim::findFirstWhiteSpace | ( | std::string & | aString | ) |
| std::string OSIMCOMMON_API OpenSim::getCurrentTimeString | ( | ) |
| OSIMCOMMON_API void OpenSim::LoadOpenSimLibraries | ( | int | argc, |
| char ** | argv | ||
| ) |
| OSIMCOMMON_API OPENSIM_PORTABLE_HMODULE WINAPI OpenSim::LoadOpenSimLibrary | ( | const std::string & | lpLibFileName, |
| bool | verbose | ||
| ) |
| OSIMCOMMON_API void OpenSim::LoadOpenSimLibrary | ( | const std::string & | aLibraryName | ) |
| bool OSIMCOMMON_API OpenSim::readCoordinatesFromString | ( | std::string & | aString, |
| double | rVec[3], | ||
| bool | allowNaNs = false |
||
| ) |
| bool OSIMCOMMON_API OpenSim::readDoubleFromString | ( | std::string & | aString, |
| double * | rNumber, | ||
| bool | allowNaNs = false |
||
| ) |
| bool OSIMCOMMON_API OpenSim::readIntegerFromString | ( | std::string & | aString, |
| int * | rNumber | ||
| ) |
| bool OSIMCOMMON_API OpenSim::readNonCommentStringFromStream | ( | std::istream & | aStream, |
| std::string & | rBuffer | ||
| ) |
| bool OSIMCOMMON_API OpenSim::readStringFromStream | ( | std::istream & | aStream, |
| std::string & | rBuffer | ||
| ) |
| bool OSIMCOMMON_API OpenSim::readStringFromString | ( | std::string & | aString, |
| std::string & | rBuffer | ||
| ) |
| bool OSIMCOMMON_API OpenSim::readTabDelimitedStringFromString | ( | std::string & | aString, |
| std::string & | rBuffer | ||
| ) |
| bool OSIMCOMMON_API OpenSim::readVectorFromString | ( | std::string & | aString, |
| SimTK::Vec3 & | rVec | ||
| ) |
| bool OSIMCOMMON_API OpenSim::readVectorFromString | ( | std::string & | aString, |
| double * | rVX, | ||
| double * | rVY, | ||
| double * | rVZ | ||
| ) |
| const char OpenSim::ObjectDEFAULT_NAME[] = "default" |
1.8.1.2 
