API  4.2 For C++ developers
OpenSim::MocoTrajectory Class Reference

The values of the variables in an optimal control problem. More...

Inheritance diagram for OpenSim::MocoTrajectory:

## Public Member Functions

MocoTrajectory ()=default

MocoTrajectory (std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > parameter_names)
Create a trajectory with no data. More...

MocoTrajectory (std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > derivative_names, std::vector< std::string > parameter_names)
Create a trajectory (including columns for derivatives) with no data. More...

MocoTrajectory (const SimTK::Vector &time, std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > parameter_names, const SimTK::Matrix &statesTrajectory, const SimTK::Matrix &controlsTrajectory, const SimTK::Matrix &multipliersTrajectory, const SimTK::RowVector &parameters)

MocoTrajectory (const SimTK::Vector &time, std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > derivative_names, std::vector< std::string > parameter_names, const SimTK::Matrix &statesTrajectory, const SimTK::Matrix &controlsTrajectory, const SimTK::Matrix &multipliersTrajectory, const SimTK::Matrix &derivativesTrajectory, const SimTK::RowVector &parameters)
This constructor is for use with the implicit dynamics mode, and allows specifying a derivativesTrajectory. More...

MocoTrajectory (const SimTK::Vector &time, const std::map< std::string, NamesAndData< SimTK::Matrix >> &continuousVars, const NamesAndData< SimTK::RowVector > &parameters={})

MocoTrajectory (const std::string &filepath)

virtual ~MocoTrajectory ()=default

virtual MocoTrajectoryclone () const
Returns a dynamically-allocated copy of this trajectory. More...

bool empty () const

bool hasCoordinateStates () const

Change the length of the trajectory
void setNumTimes (int numTimes)
Resize the time vector and the time dimension of the states, controls, multipliers, and derivatives trajectories, and set all times, states, controls, multipliers, and derivatives to NaN. More...

double resampleWithNumTimes (int numTimes)
Uniformly resample (interpolate) the trajectory so that it retains the same initial and final times but now has the provided number of time points. More...

double resampleWithInterval (double desiredTimeInterval)
Uniformly resample (interpolate) the trajectory to try to achieve the provided time interval between mesh points, while preserving the initial and final times. More...

double resampleWithFrequency (double desiredNumTimePointsPerSecond)
Uniformly resample (interpolate) the trajectory to try to achieve the provided frequency of time points per second of the trajectory, while preserving the initial and final times. More...

void resample (SimTK::Vector newTime)
Resample (interpolate) the data in this trajectory at the provided times. More...

Set the data
void setTime (const SimTK::Vector &time)
Set the time vector. More...

void setState (const std::string &name, const SimTK::Vector &trajectory)
Set the value of a single state variable across time. More...

void setControl (const std::string &name, const SimTK::Vector &trajectory)
Set the value of a single control variable across time. More...

void setMultiplier (const std::string &name, const SimTK::Vector &trajectory)
Set the value of a single Lagrange multiplier variable across time. More...

void setDerivative (const std::string &name, const SimTK::Vector &trajectory)
Set the value of a single state derivative variable across time. More...

void setParameter (const std::string &name, const SimTK::Real &value)
Set the value of a single parameter variable. More...

void setTime (std::initializer_list< double > time)
Set the time vector. More...

void setState (const std::string &name, std::initializer_list< double > trajectory)
Set the value of a single state variable across time. More...

void setControl (const std::string &name, std::initializer_list< double > trajectory)
Set the value of a single control variable across time. More...

void setMultiplier (const std::string &name, std::initializer_list< double > trajectory)
Set the value of a single Lagrange multiplier variable across time. More...

void setDerivative (const std::string &name, std::initializer_list< double > trajectory)
Set the value of a single state derivative variable across time. More...

void setStatesTrajectory (const TimeSeriesTable &states, bool allowMissingColumns=false, bool allowExtraColumns=false)
Set the states trajectory. More...

void insertStatesTrajectory (const TimeSeriesTable &subsetOfStates, bool overwrite=false)

void insertControlsTrajectory (const TimeSeriesTable &subsetOfControls, bool overwrite=false)

void generateSpeedsFromValues ()
Compute coordinate speeds based on coordinate position values and append to the trajectory. More...

void generateAccelerationsFromValues ()
Compute coordinate accelerations based on coordinate position values and append to the trajectory. More...

void generateAccelerationsFromSpeeds ()
Compute coordinate accelerations based on coordinate speeds and append to the trajectory. More...

Accessors
int getNumTimes () const

const SimTK::Vector & getTime () const

double getInitialTime () const
The first time in the time vector. More...

double getFinalTime () const
The last time in the time vector. More...

int getNumStates () const

int getNumControls () const

int getNumMultipliers () const

int getNumDerivatives () const

int getNumParameters () const

const std::vector< std::string > & getStateNames () const

const std::vector< std::string > & getControlNames () const

const std::vector< std::string > & getMultiplierNames () const

const std::vector< std::string > & getDerivativeNames () const

const std::vector< std::string > & getParameterNames () const

SimTK::VectorView_< double > getState (const std::string &name) const

SimTK::VectorView_< double > getControl (const std::string &name) const

SimTK::VectorView_< double > getMultiplier (const std::string &name) const

SimTK::VectorView_< double > getDerivative (const std::string &name) const

const SimTK::Real & getParameter (const std::string &name) const

const SimTK::Matrix & getStatesTrajectory () const

const SimTK::Matrix & getControlsTrajectory () const

const SimTK::Matrix & getMultipliersTrajectory () const

const SimTK::Matrix & getDerivativesTrajectory () const

const SimTK::RowVector & getParameters () const

Comparisons
bool isCompatible (const MocoProblemRep &, bool requireAccelerations=false, bool throwOnError=false) const
Do the state, control, multiplier, derivative, and parameter names in this trajectory match those in the problem? This may not catch all possible incompatibilities. More...

bool isNumericallyEqual (const MocoTrajectory &other, double tol=SimTK::NTraits< SimTK::Real >::getDefaultTolerance()) const
Check if this trajectory is numerically equal to another trajectory. More...

double compareContinuousVariablesRMS (const MocoTrajectory &other, std::map< std::string, std::vector< std::string >> columnsToUse={}) const
Compute the root-mean-square error between the continuous variables of this trajectory and another. More...

double compareContinuousVariablesRMSPattern (const MocoTrajectory &other, std::string columnType, std::string pattern) const
This is an alternative interface for compareContinuousVariablesRMS() that uses regular expression patterns to select columns. More...

double compareParametersRMS (const MocoTrajectory &other, std::vector< std::string > parameterNames={}) const
Compute the root-mean-square error between the parameters in this trajectory and another. More...

Convert to other formats
void write (const std::string &filepath) const
Save the trajectory to a STO file. Use the ."sto" file extension. More...

TimeSeriesTable exportToStatesTable () const
This table can be saved as a Storage file that can be used in the OpenSim GUI to visualize a motion, or as input to OpenSim's conventional tools (e.g., AnalyzeTool). More...

TimeSeriesTable exportToControlsTable () const
Export the controls trajectory to a TimeSeriesTable. More...

StatesTrajectory exportToStatesTrajectory (const MocoProblem &) const
Controls are not carried over to the StatesTrajectory. More...

StatesTrajectory exportToStatesTrajectory (const Model &) const
This is similar to the above function but requires only a model, not a MocoProblem. More...

Modify the data
void randomizeReplace (const SimTK::Random &randGen=SimTK::Random::Uniform(-0.1, 0.1))
Randomize all data except time using the provided random number generator. More...

void randomizeAdd (const SimTK::Random &randGen=SimTK::Random::Uniform(-0.1, 0.1))
Randomize all data except time using the provided random number generator. More...

## Public Types

template<typename T >
using NamesAndData = std::pair< std::vector< std::string >, T >
This constructor allows you to control which data you provide for the trajectory. More...

## Static Public Member Functions

Convert from other formats
static MocoTrajectory createFromStatesControlsTables (const MocoProblemRep &, const TimeSeriesTable &statesTrajectory, const TimeSeriesTable &controlsTrajectory)
(Experimental) Create a trajectory from a states trajectory and controls trajectory (i.e, from Manager::getStatesTable() and Model::getControlsTable()). More...

## Protected Member Functions

void setSealed (bool sealed)

bool isSealed () const

void ensureUnsealed () const

## Detailed Description

The values of the variables in an optimal control problem.

This can be used for specifying an initial guess, or holding the solution returned by a solver.

A MocoTrajectory can be written to and read from an STO (".sto") file. The file format is comprised of a file header followed by a row of column names and the stored data. The file header contains the number of states, controls, Lagrange multipliers (for kinematic constraints), derivatives (non-zero if the dynamics mode is implicit), slacks (for special solver implementations), and parameters (order does not matter). Order does matter for the column names and corresponding data columns. The columns must follow this order: time, states, controls, multipliers, derivatives, slacks, parameters.

Note
Slack columns may contain real number or NaN values, depending on their use. For example, values for velocity correction variables used in problems with model kinematic constraints are defined only at the midpoint of a Hermite- Simpson mesh interval. The non-midpoint variables are returned as NaN in the slack variable data structure.
For parameter columns, the value of the parameter is stored in the first row of the column, while the rest of the rows are filled with NaNs. ^^Sample file:^^
^^
num_controls=<number-of-control-variables>
num_derivatives=<number-of-derivative-variables>
num_multipliers=<number-of-multiplier-variables>
num_parameters=<number-of-parameter-variables>
num_slacks=<number-of-slack-variables>
num_states=<number-of-state-variables>
time,<state-0-name>,...,<control-0-name>,...,<multiplier-0-name>,..., \
<derivative-0-name>,...,<slack-0-name>,...,<parameter-0-name>,...
<#>,<#>,...,<#>,...,<#>,...,<#>,...,<#-or-NaN>,...,<#>  ,...
<#>,<#>,...,<#>,...,<#>,...,<#>,...,<#-or-NaN>,...,<NaN>,...
: , : ,..., : ,..., : ,..., : ,...,    :     ,...,  :  ,...
<#>,<#>,...,<#>,...,<#>,...,<#>,...,<#-or-NaN>,...,<NaN>,...


Column labels starting with "lambda" are Lagrange multipliers, and columns starting with "gamma" are slack variables (probably velocity corrections at certain collocation points).

Matlab and Python
Many of the functions in this class have variants ending with "Mat" that provide convenient access to the data directly in Matlab or Python (NumPy). In Python, the constructors can also accept NumPy matrices in addition to arguments of type SimTK::Matrix.
trajectory.getStateMat("<state-name>")
trajectory.getStatesTrajectoryMat()
Implicit dynamics model
If the solver uses an implicit dynamics mode, then there are "control" variables ("adjunct" variables in tropter's terminology) for the generalized accelerations. These are stored in the trajectory as derivative variables.
Sealed trajectories
If the trajectory is obtained as the failed solution to a problem, the trajectory will be sealed (MocoTrajectory::isSealed()), which means that you cannot do anything with the trajectory (read, edit, or write) until you call MocoTrajectory::unseal(). The sealing forces you to acknowledge that the solver failed.
Examples:

## ◆ NamesAndData

template<typename T >
 using OpenSim::MocoTrajectory::NamesAndData = std::pair, T>

This constructor allows you to control which data you provide for the trajectory.

The possible keys for continuousVars are "states", "controls", "multipliers", and "derivatives". The names and data are grouped together, and you can leave out any of the keys.

## ◆ MocoTrajectory() [1/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( )
default

## ◆ MocoTrajectory() [2/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > parameter_names )

Create a trajectory with no data.

To add data, use setNumTimes(), setTime(), and the other setters.

## ◆ MocoTrajectory() [3/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > derivative_names, std::vector< std::string > parameter_names )

Create a trajectory (including columns for derivatives) with no data.

To add data, use setNumTimes(), setTime(), and the other setters.

## ◆ MocoTrajectory() [4/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( const SimTK::Vector & time, std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > parameter_names, const SimTK::Matrix & statesTrajectory, const SimTK::Matrix & controlsTrajectory, const SimTK::Matrix & multipliersTrajectory, const SimTK::RowVector & parameters )

## ◆ MocoTrajectory() [5/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( const SimTK::Vector & time, std::vector< std::string > state_names, std::vector< std::string > control_names, std::vector< std::string > multiplier_names, std::vector< std::string > derivative_names, std::vector< std::string > parameter_names, const SimTK::Matrix & statesTrajectory, const SimTK::Matrix & controlsTrajectory, const SimTK::Matrix & multipliersTrajectory, const SimTK::Matrix & derivativesTrajectory, const SimTK::RowVector & parameters )

This constructor is for use with the implicit dynamics mode, and allows specifying a derivativesTrajectory.

## ◆ MocoTrajectory() [6/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( const SimTK::Vector & time, const std::map< std::string, NamesAndData< SimTK::Matrix >> & continuousVars, const NamesAndData< SimTK::RowVector > & parameters = {} )

## ◆ MocoTrajectory() [7/7]

 OpenSim::MocoTrajectory::MocoTrajectory ( const std::string & filepath )
explicit

See output of write() for the correct format.

## ◆ ~MocoTrajectory()

 virtual OpenSim::MocoTrajectory::~MocoTrajectory ( )
virtualdefault

## ◆ clone()

 virtual MocoTrajectory* OpenSim::MocoTrajectory::clone ( ) const
inlinevirtual

Returns a dynamically-allocated copy of this trajectory.

You must manage the memory for return value.

Note
This works even if the trajectory is sealed.

Reimplemented in OpenSim::MocoSolution.

## ◆ compareContinuousVariablesRMS()

 double OpenSim::MocoTrajectory::compareContinuousVariablesRMS ( const MocoTrajectory & other, std::map< std::string, std::vector< std::string >> columnsToUse = {} ) const

Compute the root-mean-square error between the continuous variables of this trajectory and another.

The RMS is computed by numerically integrating the sum of squared error across states, controls, Lagrange multipliers, and derivatives and dividing by the number of columns and the time duration. The calculation can be expressed as follows:

$\epsilon_{\textrm{RMS}} = \sqrt{\frac{1}{N(t_f - t_i)} \int_{t_i}^{t_f} \left( \sum_{ i \in \textrm{states} } \epsilon_i(t)^2 + \sum_{ i \in \textrm{controls} } \epsilon_i(t)^2 + \sum_{ i \in \textrm{mult} } \epsilon_i(t)^2 + \sum_{ i \in \textrm{deriv} } \epsilon_i(t)^2 \right) dt },$

where $$N$$ is the number of columns, $$t_i$$ is the minimum of the two initial times, $$t_f$$ is the maximum of the two final times, and $$\epsilon$$ indicates an error.

When the two trajectories do not cover the same time range, we assume values of 0 for the trajectory with "missing" time (we do NOT assume that the error is 0 over the non-overlapping time range).

First, the trajectories are splined and sampled. The number of sampling points is taken to be the number of times in the trajectory with the greater number of times. Numerical integration is performed on the sampled points using the trapezoidal rule.

By default, all states, controls, and multipliers are compared, and it is expected that both trajectories have the same states, controls, and multipliers. Alternatively, you can specify the specific states, controls, multipliers, and derivatives to compare as keys for columnsToUse. Values are an empty vector to compare all columns for that key, {"none"} (single-entry vector with value "none") to compare none of the columns for that key, or a vector of column labels to compare for that key. Leaving out a key means no columns for that key are compared. Both trajectories must have at least 6 time nodes. If the number of columns to compare is 0, this returns 0.

## ◆ compareContinuousVariablesRMSPattern()

 double OpenSim::MocoTrajectory::compareContinuousVariablesRMSPattern ( const MocoTrajectory & other, std::string columnType, std::string pattern ) const

This is an alternative interface for compareContinuousVariablesRMS() that uses regular expression patterns to select columns.

The parameter columnType is "states", "controls", "multipliers", or "derivatives". All columns for the provided column type whose entire name matches the provided regular expression are included in the root-mean-square.

## ◆ compareParametersRMS()

 double OpenSim::MocoTrajectory::compareParametersRMS ( const MocoTrajectory & other, std::vector< std::string > parameterNames = {} ) const

Compute the root-mean-square error between the parameters in this trajectory and another.

The RMS is computed by dividing the sum of the squared errors between corresponding parameters and then dividing by the number of parameters compared. By default, all parameters are compared, and it is expected that both trajectories have the same parameters. Alternatively, you can specify the specific parameters to compare.

## ◆ createFromStatesControlsTables()

 static MocoTrajectory OpenSim::MocoTrajectory::createFromStatesControlsTables ( const MocoProblemRep & , const TimeSeriesTable & statesTrajectory, const TimeSeriesTable & controlsTrajectory )
static

(Experimental) Create a trajectory from a states trajectory and controls trajectory (i.e, from Manager::getStatesTable() and Model::getControlsTable()).

The time columns from the two tables must match exactly. The times in the trajectory will be those from the tables. This does not (yet) handle parameters.

## ◆ empty()

 bool OpenSim::MocoTrajectory::empty ( ) const
inline

## ◆ ensureUnsealed()

 void OpenSim::MocoTrajectory::ensureUnsealed ( ) const
protected
Exceptions
 MocoTrajectoryIsSealed if the trajectory is sealed.

## ◆ exportToControlsTable()

 TimeSeriesTable OpenSim::MocoTrajectory::exportToControlsTable ( ) const

Export the controls trajectory to a TimeSeriesTable.

Examples:
exampleHangingMuscle.cpp.

Referenced by OpenSim::analyzeMocoTrajectory().

## ◆ exportToStatesTable()

 TimeSeriesTable OpenSim::MocoTrajectory::exportToStatesTable ( ) const

This table can be saved as a Storage file that can be used in the OpenSim GUI to visualize a motion, or as input to OpenSim's conventional tools (e.g., AnalyzeTool).

Controls are not carried over to the states storage.

Examples:
exampleHangingMuscle.cpp.

Referenced by OpenSim::analyzeMocoTrajectory().

## ◆ exportToStatesTrajectory() [1/2]

 StatesTrajectory OpenSim::MocoTrajectory::exportToStatesTrajectory ( const MocoProblem & ) const

Controls are not carried over to the StatesTrajectory.

The MocoProblem is necessary because we need the underlying Model to order the state variables correctly.

## ◆ exportToStatesTrajectory() [2/2]

 StatesTrajectory OpenSim::MocoTrajectory::exportToStatesTrajectory ( const Model & ) const

This is similar to the above function but requires only a model, not a MocoProblem.

## ◆ generateAccelerationsFromSpeeds()

 void OpenSim::MocoTrajectory::generateAccelerationsFromSpeeds ( )

Compute coordinate accelerations based on coordinate speeds and append to the trajectory.

Coordinate speeds must exist in the original trajectory.

Note
Overrides any existing acceleration values in the trajectory.

## ◆ generateAccelerationsFromValues()

 void OpenSim::MocoTrajectory::generateAccelerationsFromValues ( )

Compute coordinate accelerations based on coordinate position values and append to the trajectory.

Coordinate values must exist in the original trajectory.

Note
Overrides any existing acceleration values in the trajectory.

## ◆ generateSpeedsFromValues()

 void OpenSim::MocoTrajectory::generateSpeedsFromValues ( )

Compute coordinate speeds based on coordinate position values and append to the trajectory.

Coordinate values must exist in the original trajectory.

Note
Overrides any existing speed values in the trajectory.

## ◆ getControl()

 SimTK::VectorView_ OpenSim::MocoTrajectory::getControl ( const std::string & name ) const

## ◆ getControlNames()

 const std::vector& OpenSim::MocoTrajectory::getControlNames ( ) const
inline

## ◆ getControlsTrajectory()

 const SimTK::Matrix& OpenSim::MocoTrajectory::getControlsTrajectory ( ) const
inline

## ◆ getDerivative()

 SimTK::VectorView_ OpenSim::MocoTrajectory::getDerivative ( const std::string & name ) const

## ◆ getDerivativeNames()

 const std::vector& OpenSim::MocoTrajectory::getDerivativeNames ( ) const
inline

## ◆ getDerivativesTrajectory()

 const SimTK::Matrix& OpenSim::MocoTrajectory::getDerivativesTrajectory ( ) const
inline

## ◆ getFinalTime()

 double OpenSim::MocoTrajectory::getFinalTime ( ) const

The last time in the time vector.

Exceptions
 Exception If numTimes is 0.

## ◆ getInitialTime()

 double OpenSim::MocoTrajectory::getInitialTime ( ) const

The first time in the time vector.

Exceptions
 Exception If numTimes is 0.

## ◆ getMultiplier()

 SimTK::VectorView_ OpenSim::MocoTrajectory::getMultiplier ( const std::string & name ) const

## ◆ getMultiplierNames()

 const std::vector& OpenSim::MocoTrajectory::getMultiplierNames ( ) const
inline

## ◆ getMultipliersTrajectory()

 const SimTK::Matrix& OpenSim::MocoTrajectory::getMultipliersTrajectory ( ) const
inline

## ◆ getNumControls()

 int OpenSim::MocoTrajectory::getNumControls ( ) const
inline

## ◆ getNumDerivatives()

 int OpenSim::MocoTrajectory::getNumDerivatives ( ) const
inline

## ◆ getNumMultipliers()

 int OpenSim::MocoTrajectory::getNumMultipliers ( ) const
inline

## ◆ getNumParameters()

 int OpenSim::MocoTrajectory::getNumParameters ( ) const
inline

## ◆ getNumStates()

 int OpenSim::MocoTrajectory::getNumStates ( ) const
inline

## ◆ getNumTimes()

 int OpenSim::MocoTrajectory::getNumTimes ( ) const
inline

## ◆ getParameter()

 const SimTK::Real& OpenSim::MocoTrajectory::getParameter ( const std::string & name ) const

## ◆ getParameterNames()

 const std::vector& OpenSim::MocoTrajectory::getParameterNames ( ) const
inline

## ◆ getParameters()

 const SimTK::RowVector& OpenSim::MocoTrajectory::getParameters ( ) const
inline

## ◆ getState()

 SimTK::VectorView_ OpenSim::MocoTrajectory::getState ( const std::string & name ) const

## ◆ getStateNames()

 const std::vector& OpenSim::MocoTrajectory::getStateNames ( ) const
inline

## ◆ getStatesTrajectory()

 const SimTK::Matrix& OpenSim::MocoTrajectory::getStatesTrajectory ( ) const
inline

## ◆ getTime()

 const SimTK::Vector& OpenSim::MocoTrajectory::getTime ( ) const
inline

## ◆ hasCoordinateStates()

 bool OpenSim::MocoTrajectory::hasCoordinateStates ( ) const
inline

## ◆ insertControlsTrajectory()

 void OpenSim::MocoTrajectory::insertControlsTrajectory ( const TimeSeriesTable & subsetOfControls, bool overwrite = false )

The provided data are interpolated using GCV splines to match the times in this trajectory. By default, we do not overwrite data for controls that already exist in the trajectory; you can change this behavior with overwrite.

## ◆ insertStatesTrajectory()

 void OpenSim::MocoTrajectory::insertStatesTrajectory ( const TimeSeriesTable & subsetOfStates, bool overwrite = false )

The provided data are interpolated using GCV splines to match the times in this trajectory. By default, we do not overwrite data for states that already exist in the trajectory; you can change this behavior with overwrite.

## ◆ isCompatible()

 bool OpenSim::MocoTrajectory::isCompatible ( const MocoProblemRep & , bool requireAccelerations = false, bool throwOnError = false ) const

Do the state, control, multiplier, derivative, and parameter names in this trajectory match those in the problem? This may not catch all possible incompatibilities.

If the trajectory should have generalized accelerations (for implicit multibody dynamics mode), set requireAccelerations to true. To throw an exception with a detailed message if the problem is not compatible, pass throwOnError as true. To get the detailed message without an exception, set the Logger level to Debug or a more verbose setting (e.g., Logger::setLevel(Logger::Level::Debug) in C++, and Logger.setLevel(Logger.Level_Debug) in MATLAB/Python).

## ◆ isNumericallyEqual()

 bool OpenSim::MocoTrajectory::isNumericallyEqual ( const MocoTrajectory & other, double tol = SimTK::NTraits< SimTK::Real >::getDefaultTolerance() ) const

Check if this trajectory is numerically equal to another trajectory.

This uses SimTK::Test::numericallyEqual() internally. Accordingly, the tolerance is both a relative and absolute tolerance (depending on the magnitude of quantities being compared).

## ◆ isSealed()

 bool OpenSim::MocoTrajectory::isSealed ( ) const
inlineprotected

 void OpenSim::MocoTrajectory::randomizeAdd ( const SimTK::Random & randGen = SimTK::Random::Uniform(-0.1, 0.1) )
inline

Randomize all data except time using the provided random number generator.

The random numbers are added to the existing data. Use this to perturb an existing solution, probably for a MocoSolver guess. The default random number generator samples uniformly within [-0.1, 0.1].

## ◆ randomizeReplace()

 void OpenSim::MocoTrajectory::randomizeReplace ( const SimTK::Random & randGen = SimTK::Random::Uniform(-0.1, 0.1) )
inline

Randomize all data except time using the provided random number generator.

All data is replaced with the random numbers. Use this to create a completely (pseudo-)random trajectory, probably for a MocoSolver guess. The default random number generator samples uniformly within [-0.1, 0.1].

## ◆ resample()

 void OpenSim::MocoTrajectory::resample ( SimTK::Vector newTime )

Resample (interpolate) the data in this trajectory at the provided times.

If all times have the same value (e.g., 0.0), then the value of each variable for all time is its previous value at the initial time.

Exceptions
 Exception if new times are not within existing initial and final times, if the new times are decreasing, or if getNumTimes() < 2.

## ◆ resampleWithFrequency()

 double OpenSim::MocoTrajectory::resampleWithFrequency ( double desiredNumTimePointsPerSecond )

Uniformly resample (interpolate) the trajectory to try to achieve the provided frequency of time points per second of the trajectory, while preserving the initial and final times.

The resulting frequency may be higher than what you request (in order to preserve initial and final times), and is returned by this function. Resampling is done by creating a 5-th degree GCV spline of the states and controls and evaluating the spline at the new time points. The degree is reduced as necessary if getNumTimes() < 6, and resampling is not possible if getNumTimes() < 2.

## ◆ resampleWithInterval()

 double OpenSim::MocoTrajectory::resampleWithInterval ( double desiredTimeInterval )

Uniformly resample (interpolate) the trajectory to try to achieve the provided time interval between mesh points, while preserving the initial and final times.

The resulting time interval may be shorter than what you request (in order to preserve initial and final times), and is returned by this function. Resampling is done by creating a 5-th degree GCV spline of the states and controls and evaluating the spline at the new time points. The degree is reduced as necessary if getNumTimes() < 6, and resampling is not possible if getNumTimes() < 2.

## ◆ resampleWithNumTimes()

 double OpenSim::MocoTrajectory::resampleWithNumTimes ( int numTimes )

Uniformly resample (interpolate) the trajectory so that it retains the same initial and final times but now has the provided number of time points.

Resampling is done by creating a 5-th degree GCV spline of the states and controls and evaluating the spline at the numTimes time points. The degree is reduced as necessary if getNumTimes() < 6, and resampling is not possible if getNumTimes() < 2.

Returns
the resulting time interval between time points.
Examples:

## ◆ setControl() [1/2]

 void OpenSim::MocoTrajectory::setControl ( const std::string & name, const SimTK::Vector & trajectory )

Set the value of a single control variable across time.

The provided vector must have length getNumTimes().

Note
Using setControl(name, {5, 10}) uses the initializer list overload below; it does not construct a 5-element vector with the value 10.

## ◆ setControl() [2/2]

 void OpenSim::MocoTrajectory::setControl ( const std::string & name, std::initializer_list< double > trajectory )
inline

Set the value of a single control variable across time.

The provided vector must have length getNumTimes(). This variant supports use of an initializer list:

trajectory.setControl("/forceset/soleus", {0, 0.5, 1.0});

## ◆ setDerivative() [1/2]

 void OpenSim::MocoTrajectory::setDerivative ( const std::string & name, const SimTK::Vector & trajectory )

Set the value of a single state derivative variable across time.

The provided vector must have length getNumTimes().

Note
Using setDerivative(name, {5, 10}) uses the initializer list overload below; it does not construct a 5-element vector with the value 10.

## ◆ setDerivative() [2/2]

 void OpenSim::MocoTrajectory::setDerivative ( const std::string & name, std::initializer_list< double > trajectory )
inline

Set the value of a single state derivative variable across time.

The provided vector must have length getNumTimes(). This variant supports use of an initializer list:

trajectory.setDerivative("/jointset/joint/coord/accel", {0, 0.5, 1.0});

## ◆ setMultiplier() [1/2]

 void OpenSim::MocoTrajectory::setMultiplier ( const std::string & name, const SimTK::Vector & trajectory )

Set the value of a single Lagrange multiplier variable across time.

The provided vector must have length getNumTimes().

Note
Using setMultiplier(name, {5, 10}) uses the initializer list overload below; it does not construct a 5-element vector with the value 10.

## ◆ setMultiplier() [2/2]

 void OpenSim::MocoTrajectory::setMultiplier ( const std::string & name, std::initializer_list< double > trajectory )
inline

Set the value of a single Lagrange multiplier variable across time.

The provided vector must have length getNumTimes(). This variant supports use of an initializer list:

trajectory.setMultiplier("lambda_cid0_p0", {0, 0.5, 1.0});

## ◆ setNumTimes()

 void OpenSim::MocoTrajectory::setNumTimes ( int numTimes )
inline

Resize the time vector and the time dimension of the states, controls, multipliers, and derivatives trajectories, and set all times, states, controls, multipliers, and derivatives to NaN.

Note
Parameters are NOT set to NaN.

## ◆ setParameter()

 void OpenSim::MocoTrajectory::setParameter ( const std::string & name, const SimTK::Real & value )

Set the value of a single parameter variable.

This value is invariant across time.

## ◆ setSealed()

 void OpenSim::MocoTrajectory::setSealed ( bool sealed )
inlineprotected

## ◆ setState() [1/2]

 void OpenSim::MocoTrajectory::setState ( const std::string & name, const SimTK::Vector & trajectory )

Set the value of a single state variable across time.

The provided vector must have length getNumTimes().

Note
Using setState(name, {5, 10}) uses the initializer list overload below; it does not construct a 5-element vector with the value 10.
Examples:

## ◆ setState() [2/2]

 void OpenSim::MocoTrajectory::setState ( const std::string & name, std::initializer_list< double > trajectory )
inline

Set the value of a single state variable across time.

The provided vector must have length getNumTimes(). This variant supports use of an initializer list:

trajectory.setState("/jointset/knee/flexion/value", {0, 0.5, 1.0});

## ◆ setStatesTrajectory()

 void OpenSim::MocoTrajectory::setStatesTrajectory ( const TimeSeriesTable & states, bool allowMissingColumns = false, bool allowExtraColumns = false )

Set the states trajectory.

The provided data is interpolated at the times contained within this trajectory. The controls trajectory is not altered. If the table only contains a subset of the states in the trajectory (and allowMissingColumns is true), the unspecified states preserve their pre-existing values.

This function might be helpful if you generate a guess using a forward simulation; you can access the forward simulation's states trajectory using Manager::getStateStorage() or Manager::getStatesTable().

Parameters
 states The column labels of the table should match the state names (see getStateNames()). By default, the table must provide all state variables. Any data outside the time range of this guess's times are ignored. allowMissingColumns If false, an exception is thrown if there are states in the trajectory that are not in the table. allowExtraColumns If false, an exception is thrown if there are states in the table that are not in the trajectory.
createFromStatesControlsTables.

## ◆ setTime() [1/2]

 void OpenSim::MocoTrajectory::setTime ( const SimTK::Vector & time )

Set the time vector.

The provided vector must have the same number of elements as the pre-existing time vector; use setNumTimes() or the "resample..." functions to change the number of times.

Note
Using setTime({5, 10}) uses the initializer list overload below; it does not construct a 5-element vector with the value 10.
Examples:

## ◆ setTime() [2/2]

 void OpenSim::MocoTrajectory::setTime ( std::initializer_list< double > time )
inline

Set the time vector.

The provided vector must have the same number of elements as the pre-existing time vector; use setNumTimes() or the "resample..." functions to change the number of times. This variant supports use of an initializer list. Example:

trajectory.setTime({0, 0.5, 1.0});

## ◆ write()

 void OpenSim::MocoTrajectory::write ( const std::string & filepath ) const

Save the trajectory to a STO file. Use the ."sto" file extension.

Examples:
exampleMarkerTracking.cpp, exampleMocoInverse.cpp, and exampleTracking.cpp.

The documentation for this class was generated from the following file:
• OpenSim/Moco/MocoTrajectory.h