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)
	Read a MocoTrajectory from an STO file (see STOFileAdapter). More...
virtual	~MocoTrajectory ()=default
virtual MocoTrajectory *	clone () 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)
	Add additional state columns. More...
void	insertControlsTrajectory (const TimeSeriesTable &subsetOfControls, bool overwrite=false)
	Add additional control columns. More...
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...

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...

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.

Constructor & Destructor Documentation

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

Read a MocoTrajectory from an STO file (see STOFileAdapter).

See output of write() for the correct format.

~MocoTrajectory()

virtual OpenSim::MocoTrajectory::~MocoTrajectory ( )

virtualdefault

Member Typedef Documentation

NamesAndData

template<typename T >

using OpenSim::MocoTrajectory::NamesAndData = std::pair<std::vector<std::string>, 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.

Member Function Documentation

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.

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.

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_<double> OpenSim::MocoTrajectory::getControl

(

const std::string &

name

)

const

getControlNames()

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

inline

getControlsTrajectory()

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

inline

getDerivative()

SimTK::VectorView_<double> OpenSim::MocoTrajectory::getDerivative

(

const std::string &

name

)

const

getDerivativeNames()

const std::vector<std::string>& 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_<double> OpenSim::MocoTrajectory::getMultiplier

(

const std::string &

name

)

const

getMultiplierNames()

const std::vector<std::string>& 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<std::string>& OpenSim::MocoTrajectory::getParameterNames ( ) const

inline

getParameters()

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

inline

getState()

SimTK::VectorView_<double> OpenSim::MocoTrajectory::getState

(

const std::string &

name

)

const

getStateNames()

const std::vector<std::string>& 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
	)

Add additional control columns.

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
	)

Add additional state columns.

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

Referenced by OpenSim::MocoSolution::isSealed().

randomizeAdd()

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.

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

Referenced by OpenSim::MocoSolution::seal(), and OpenSim::MocoSolution::unseal().

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.

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.

See also

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.

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.

---

The documentation for this class was generated from the following file:

• OpenSim/Moco/MocoTrajectory.h