OpenSim::Storage Class Reference

#include <Storage.h>

Inheritance diagram for OpenSim::Storage:

Public Member Functions
	Storage (int aCapacity=Storage_DEFAULT_CAPACITY, const std::string &aName="UNKNOWN")
	Storage (const std::string &aFileName) SWIG_DECLARE_EXCEPTION
	Storage (const Storage &aStorage, bool aCopyData=true)
	Copy constructor.
	Storage (const Storage &aStorage, int aStateIndex, int aN, const char *aDelimiter="\t")
	Construct a copy of a specified storage taking only a subset of the states.
virtual Object *	copy () const
	Copy this object.
virtual	~Storage ()
	Destructor.
int	getSize () const
int	getSmallestNumberOfStates () const
	Get the smallest number of states.
StateVector *	getStateVector (int aTimeIndex) const
	Get the StateVector at a spcified time index.
StateVector *	getLastStateVector () const
	Get the last states stored.
double	getFirstTime () const
	Get the time of the first stored states.
double	getLastTime () const
	Get the time of the last states.
double	getMinTimeStep () const
	Get the smallest time step.
bool	getTime (int aTimeIndex, double &rTime, int aStateIndex=-1) const
	Get the time at a specified time index for a specified state.
int	getTimeColumn (double *&rTimes, int aStateIndex=-1) const
	Get the times for a specified state.
int	getTimeColumn (Array< double > &rTimes, int aStateIndex=-1) const
void	getTimeColumnWithStartTime (Array< double > &rTimes, double startTime=0.0) const
	Get the time column starting at aTime.
void	addKeyValuePair (const std::string &aKey, const std::string &aValue)
	Processing of special reserved words used by SIMM and corresponding values The keys and their corresponding values are maintained in _keyValueMap.
void	getValueForKey (const std::string &aKey, std::string &rValue) const
bool	hasKey (const std::string &aKey) const
int	getData (int aTimeIndex, int aStateIndex, double &rValue) const
	Get a data value of a specified state at a specified time index.
int	getData (int aTimeIndex, int aStateIndex, int aN, double **rData) const
	Helper function for getData.
int	getData (int aTimeIndex, int aStateIndex, int aN, double *rData) const
	At a specified time index, get a number of state values starting at a specified state.
int	getData (int aTimeIndex, int aN, double **rData) const
	At a specified time index, get a number of state values starting at a specified state.
int	getData (int aTimeIndex, int aN, double *rData) const
	Get the first aN states at a specified time index.
int	getDataAtTime (double aTime, int aN, double **rData) const
	Get the first aN states at a specified time.
int	getDataAtTime (double aTime, int aN, double *rData) const
	Get the first aN states at a specified time.
int	getDataAtTime (double aTime, int aN, Array< double > &rData) const
int	getDataColumn (int aStateIndex, double *&rData) const
	Get the data corresponding to a specified state.
int	getDataColumn (int aStateIndex, Array< double > &rData) const
void	setDataColumn (int aStateIndex, const Array< double > &aData)
	Set the data corresponding to a specified state.
int	getDataColumn (const std::string &columnName, double *&rData) const
	Get the data corresponding to a state specified by name.
void	getDataColumn (const std::string &columnName, Array< double > &data, double startTime=0.0)
	Get the data column starting at aTime.
void	setStepInterval (int aStepInterval)
	Set the step interval.
int	getStepInterval () const
	Get the step interval.
void	setCapacityIncrement (int aIncrement)
	Set the capacity increment of this storage object.
int	getCapacityIncrement () const
	Get the capacity increment of this storage object.
void	setWriteSIMMHeader (bool aTrueFalse)
	Set the whether or not to write a header appropriate for a SIMM motion file.
bool	getWriteSIMMHeader () const
	Get the whether or not to write a header appropriate for a SIMM motion file.
void	setHeaderToken (const std::string &aToken)
	Set the header token.
const std::string &	getHeaderToken () const
	Get the header token of this storage.
const int	getStateIndex (const std::string &aColumnName, int startIndex=0) const
	Get the column index corresponding to specified column name.
void	setColumnLabels (const Array< std::string > &aColumnLabels)
	Set column labels array.
const Array< std::string > &	getColumnLabels () const
	Get column labels array.
int	reset (int aIndex=0)
	Reset the storage to start storing at a specified index.
int	reset (double aTime)
	Reset the storage to start storing after a specified time.
void	purge ()
void	crop (const double newStartTime, const double newFinalTime)
	Crop the storage object to the specified start and final time.
virtual int	append (const StateVector &aVec, bool aCheckForDuplicateTime=true)
	Append an StateVector.
virtual int	append (const Array< StateVector > &aArray)
	Append copies of all state vectors in an Storage object.
virtual int	append (double aT, int aN, const double *aY, bool aCheckForDuplicateTime=true)
	Append an array of data that occured at a specified time.
int	append (double aT, const SimTK::Vec3 &aY, bool aCheckForDuplicateTime=true)
virtual int	store (int aStep, double aT, int aN, const double *aY)
	Store a simulation vector.
void	shiftTime (double aValue)
	Shift the times of all state vectors.
void	scaleTime (double aValue)
	Scale the times of all state vectors.
void	add (double aValue)
	Add a value to all state vectors in this storage instance.
void	add (int aN, double aY[])
	Add an array to all state vectors in this storage instance.
void	add (int aN, double aValue)
	Add a value to all entries in one column of the storage.
void	add (StateVector *aStateVector)
	Add a state vector to the all state vectors in this storage instance.
void	add (Storage *aStorage)
	Add a storage instance to this storage instance.
void	subtract (double aValue)
	Subtract a value from all state vectors in this storage instance.
void	subtract (int aN, double aY[])
	Subtract an array from all state vectors in this storage instance.
void	subtract (StateVector *aStateVector)
	Subtract a state vector from all state vectors in this storage instance.
void	subtract (Storage *aStorage)
	Subtract a storage instance to this storage instance.
void	multiply (double aValue)
	Multiply all state vectors in this storage instance by a value.
void	multiplyColumn (int aIndex, double aValue)
	Multiply entries at column aIndex by a value.
void	multiply (int aN, double aY[])
	Multiply all state vectors in this storage instance by an array.
void	multiply (StateVector *aStateVector)
	Multiply all state vectors in this storage instance by a state vector.
void	multiply (Storage *aStorage)
	Multipy this storage instance by a storage instance.
void	divide (double aValue)
	Divide all state vectors in this storage instance by a value.
void	divide (int aN, double aY[])
	Divide all state vectors in this storage instance by an array.
void	divide (StateVector *aStateVector)
	Divide all state vectors in this storage instance by a state vector.
void	divide (Storage *aStorage)
	Divide this storage instance by a storage instance.
Storage *	integrate (int aI1=-2, int aI2=-1) const
	Integrate the state vectors between aI1 and aI2.
Storage *	integrate (double aT1, double aT2) const
	Integrate the state vectors between times aTI and aTF.
int	computeArea (int aN, double *aArea) const
	Compute the area of the first aN states stored for all state vectors stored in this storage instance.
int	computeArea (double aTI, double aTF, int aN, double *aArea) const
	Compute the area of the first aN states stored between the times aTI and aTF.
int	computeAverage (int aN, double *aAve) const
	Compute the average value of the first aN states stored for all state vectors stored in this storage instance.
int	computeAverage (double aTI, double aTF, int aN, double *aAve) const
	Compute the average value of the first aN states stored between the times aTI and aTF.
void	pad (int aPadSize)
	Pad each of the columns in a statevector by a specified amount.
void	smoothSpline (int aOrder, double aCutoffFrequency)
	Smooth spline each of the columns in the storage.
void	lowpassIIR (double aCutoffFequency)
	Lowpass filter each of the columns in the storage.
void	lowpassFIR (int aOrder, double aCutoffFequency)
	Lowpass filter each of the columns in the storage.
void	addToRdStorage (Storage &rStorage, double aStartTime, double aEndTime)
int	findIndex (double aT) const
	Find the index of the storage element that occured immediately before or at a specified time ( getTime(index) <= aT ).
int	findIndex (int aI, double aT) const
	Find the index of the storage element that occured immediately before or at time aT ( aT <= getTime(index) ).
void	findFrameRange (double aStartTime, double aEndTime, int &oStartFrame, int &oEndFrame) const
	Find the range of frames that is between start time and end time (inclusive).
double	resample (double aDT, int aDegree)
	Resample Storage columns to specified rate.
double	resampleLinear (double aDT)
	Resample using linear interpolation.
double	compareColumn (Storage &aOtherStorage, std::string &aColumnName, double startTime, double endTime=-1.0)
	Compare column named "aColumnName" in two storage objects If endTime is not specified the comparison goes to the end of the file.
void	print () const
	Print the contents of this storage instance to standard output.
bool	print (const std::string &aFileName, const std::string &aMode="w", const std::string &aComment="") const
int	print (const std::string &aFileName, double aDT, const std::string &aMode="w") const
void	interpolateAt (const Array< double > &targetTimes)
	interpolateAt passed in list of time values.
Static Public Member Functions
static void	printResult (const Storage *aStorage, const std::string &aName, const std::string &aDir, double aDT, const std::string &aExtension)
Static Public Attributes
static const double	LARGE_NEGATIVE = -1.0e-30
	Large negative number.
static const double	LARGE_POSITIVE = 1.0e-30
	Large positive number.
static const char *	DEFAULT_HEADER_TOKEN = "endheader"
	Default token used to mark the end of the storage description in a file.
static const char *	DEFAULT_HEADER_SEPARATOR = " \t\r\n"
static const int	MAX_RESAMPLE_SIZE = 100000
Protected Attributes
Array< StateVector >	_storage
	Array of StateVectors.
std::string	_headerToken
	Token used to mark the end of the description in a file.
Array< std::string >	_columnLabels
	Column labels.
int	_stepInterval
	Step interval at which states in a simulation are stored.
int	_lastI
	Last index at which a search was started.
bool	_writeSIMMHeader
	Flag for whether or not to insert a SIMM style header.
Units	_units
	Units in which the data is represented.
MapKeysToValues	_keyValueMap
	Map between keys in file header and values.
Static Protected Attributes
static std::string	simmReservedKeys []

Constructor & Destructor Documentation

OpenSim::Storage::Storage	(	int	aCapacity = `Storage_DEFAULT_CAPACITY`,
		const std::string &	aName = `"UNKNOWN"`
	)			`[explicit]`

OpenSim::Storage::Storage ( const std::string & aFileName )

Storage::Storage	(	const Storage &	aStorage,
		bool	aCopyData = `true`
	)

Copy constructor.

Storage::Storage	(	const Storage &	aStorage,
		int	aStateIndex,
		int	aN,
		const char *	aDelimiter = `"\t"`
	)

Construct a copy of a specified storage taking only a subset of the states.

Parameters:

	aStorage	Storage to be copied.
	aStateIndex	Index of the state (column) at which to start the copy.
	aN	Number of states to copy.
	aDelimiter	Delimiter used to separate state labels (i.e., column labels). The delimiter is assumed to be a tab by default.

Storage::~Storage ( ) [virtual]

Destructor.

The stored StateVectors are deleted during destruction.

Member Function Documentation

void Storage::add ( Storage * aStorage )

Add a storage instance to this storage instance.

Linear interpolation or extrapolation is used to get the values of the states that correspond in time to the states held in this storage instance.

Parameters:

aStorage

Storage to add to this storage. s

void Storage::add ( StateVector * aStateVector )

Add a state vector to the all state vectors in this storage instance.

Parameters:

aStateVector

State vector to add to the state vectors.

See also:: StateVector::add(int,double[])

void Storage::add	(	int	aN,
		double	aValue
	)

Add a value to all entries in one column of the storage.

Parameters:

	aN	Index of the column that the value is to be added to.
	aValue	Value to add to the column.

See also:: StateVector::add(int,double)

void Storage::add	(	int	aN,
		double	aY[]
	)

Add an array to all state vectors in this storage instance.

Only the first aN states of each state vector are altered.

Parameters:

	aN	Length of aY
	aY	Array of values to add to the state vectors.

See also:: StateVector::add(int,double[])

void Storage::add ( double aValue )

Add a value to all state vectors in this storage instance.

Parameters:

aValue

Value to add to the state vectors.

See also:: StateVector::add(double)

void Storage::addKeyValuePair	(	const std::string &	aKey,
		const std::string &	aValue
	)

Processing of special reserved words used by SIMM and corresponding values The keys and their corresponding values are maintained in _keyValueMap.

void Storage::addToRdStorage	(	Storage &	rStorage,
		double	aStartTime,
		double	aEndTime
	)

int OpenSim::Storage::append	(	double	aT,
		const SimTK::Vec3 &	aY,
		bool	aCheckForDuplicateTime = `true`
	)			`[inline]`

int Storage::append	(	double	aT,
		int	aN,
		const double *	aY,
		bool	aCheckForDuplicateTime = `true`
	)			`[virtual]`

Append an array of data that occured at a specified time.

Parameters:

	aT	Time stamp of the data.
	aN	Length of the array.
	aY	Array.

Returns:: Index of the first empty storage element.

int Storage::append ( const Array< StateVector > & aStorage ) [virtual]

Append copies of all state vectors in an Storage object.

This method overrides Array::append(Array). Currently, there is no difference. The override is done for completeness.

Parameters:

aStorage

Storage to be appended.

Returns:: The index of the first empty storage element.

int Storage::append	(	const StateVector &	aStateVector,
		bool	aCheckForDuplicateTime = `true`
	)			`[virtual]`

Append an StateVector.

Parameters:

aStateVector

Statevector to be appended.

Returns:: Size of the storage after the append.

double Storage::compareColumn	(	Storage &	aOtherStorage,
		std::string &	aColumnName,
		double	startTime,
		double	endTime = `-1.0`
	)

Compare column named "aColumnName" in two storage objects If endTime is not specified the comparison goes to the end of the file.

Returns:: the difference or SimTK::Infinity if times do not match up.

NOTE: This assumes same time sampling between both Storages.

int Storage::computeArea	(	double	aTI,
		double	aTF,
		int	aN,
		double *	aArea
	)			const

Compute the area of the first aN states stored between the times aTI and aTF.

It is assumed that there is enough memory at aArea to hold aN states. If aN exceeds the number of states held in storage, aN is disregarded.

The number of valid states in aArea is returned.

Note that if aTI and aTF do not fall exactly on the time stamp of a stored state, the states are linearly interpolated to provide an estimate of the state at aTI or at aTF.

int Storage::computeArea	(	int	aN,
		double *	aArea
	)			const

Compute the area of the first aN states stored for all state vectors stored in this storage instance.

It is assumed that there is enough memory at aArea to hold aN states. If aN exceeds the number of states held in storage, aN is disregarded.

The number of valid states in aArea is returned.

int Storage::computeAverage	(	double	aTI,
		double	aTF,
		int	aN,
		double *	aAve
	)			const

Compute the average value of the first aN states stored between the times aTI and aTF.

This method uses computeArea() to compute the area (integral) of each state on the interval [aTI,aTF] and then simply divides by the (aTF-aTI).

It is assumed that there is enough memory at aAve to hold aN states. If aN exceeds the number of states held in storage, aN is disregarded.

The number of valid states in aAve is returned.

Note that if aTI and aTF do not fall exactly on the time stamp of a stored state, the states are linearly interpolated to provide an estimate of the state at aTI or at aTF.

int Storage::computeAverage	(	int	aN,
		double *	aAve
	)			const

Compute the average value of the first aN states stored for all state vectors stored in this storage instance.

This method uses computeArea() to compute the area (integral) and then simply divides by the the time interval (tf-ti).

It is assumed that there is enough memory at aAve to hold aN states. If aN exceeds the number of states held in storage, aN is disregarded.

The number of valid states in aAve is returned.

Object * Storage::copy ( ) const [virtual]

Copy this object.

Returns:: Pointer to a copy of this object.

Reimplemented from OpenSim::Object.

void Storage::crop	(	const double	newStartTime,
		const double	newFinalTime
	)

Crop the storage object to the specified start and final time.

void Storage::divide ( Storage * aStorage )

Divide this storage instance by a storage instance.

Linear interpolation or extrapolation is used to get the values of the states that correspond in time to the states held in this storage instance.

Parameters:

aStorage

Storage instance by which to divide. s

void Storage::divide ( StateVector * aStateVector )

Divide all state vectors in this storage instance by a state vector.

Parameters:

aStateVector

State vector by which to divide the state vectors.

void Storage::divide	(	int	aN,
		double	aY[]
	)

Divide all state vectors in this storage instance by an array.

Only the first aN states of each state vector are altered.

Parameters:

	aN	Length of aY
	aY	Array of values the states are to be divided by.

void Storage::divide ( double aValue )

Divide all state vectors in this storage instance by a value.

Parameters:

aValue

Value by which to divide the state vectors.

void Storage::findFrameRange	(	double	aStartTime,
		double	aEndTime,
		int &	oStartFrame,
		int &	oEndFrame
	)			const

Find the range of frames that is between start time and end time (inclusive).

Return the indices of the bounding frames.

int Storage::findIndex	(	int	aI,
		double	aT
	)			const

Find the index of the storage element that occured immediately before or at time aT ( aT <= getTime(index) ).

This method can be much more efficient than findIndex(aT) if a good guess is made for aI. If aI corresponds to a state which occured later than aT, an exhaustive search is performed by calling findIndex(aT).

Parameters:

	aI	Index at which to start searching.
	aT	Time.

Returns:: Index preceding or at time aT. If aT is less than the earliest time, 0 is returned.

int Storage::findIndex ( double aT ) const

Find the index of the storage element that occured immediately before or at a specified time ( getTime(index) <= aT ).

This method is not very efficient because it always starts its search with the first stored state.

Parameters:

aT

Time.

Returns:: Index preceding or at time aT. If aT is less than the earliest time, 0 is returned.

int Storage::getCapacityIncrement ( ) const

Get the capacity increment of this storage object.

Returns:: Capacity increment of this storage. For details on what the capacity increment does see Array::setCapacityIncrement().

const Array< string > & Storage::getColumnLabels ( ) const

Get column labels array.

Returns:: Character string of column labels.

int Storage::getData	(	int	aTimeIndex,
		int	aN,
		double *	rData
	)			const

Get the first aN states at a specified time index.

Parameters:

	aTimeIndex	Time index at which to get the states.
	aN	Number of states to get.
	rData	Array where the returned data will be set. The size of rData is assumed to be at least aN.

Returns:: Number of states that were set.

int Storage::getData	(	int	aTimeIndex,
		int	aN,
		double **	rData
	)			const

At a specified time index, get a number of state values starting at a specified state.

The method simply gets part of a row of data from adjacent columns in the storage object.

Parameters:

	aTimeIndex	Time index at which to get the states.
	aStateIndex	Index of the state (column) at which to start getting the data.
	aN	Number of states to get.
	rData	Pointer to an array where the returned data will be set. The size of *rData is assumed to be at least aN. If rData comes in as NULL, memory is allocated.

Returns:: Number of states.

int Storage::getData	(	int	aTimeIndex,
		int	aStateIndex,
		int	aN,
		double *	rData
	)			const

At a specified time index, get a number of state values starting at a specified state.

The method simply gets part of a row of data from adjacent columns in the storage object.

Parameters:

	aTimeIndex	Index that identifies the time (row) at which to get the data value: 0 <= aTimeIndex < _storage.getSize().
	aStateIndex	Index of the state (column) at which to start getting the data.
	aN	Number of states (columns) to get.
	rData	Data values. rData should be able to hold at least N values.

Returns:: Number of states that were gotten.

int Storage::getData	(	int	aTimeIndex,
		int	aStateIndex,
		int	aN,
		double **	rData
	)			const

Helper function for getData.

int Storage::getData	(	int	aTimeIndex,
		int	aStateIndex,
		double &	rValue
	)			const

Get a data value of a specified state at a specified time index.

Parameters:

	aTimeIndex	Index that identifies the time (row) at which to get the data value: 0 <= aTimeIndex < _storage.getSize().
	aStateIndex	Index of the state (column) for which to get the value.
	rValue	Value of the state.

Returns:: 1 on success, 0 on failure.

int Storage::getDataAtTime	(	double	aTime,
		int	aN,
		Array< double > &	rData
	)			const

int Storage::getDataAtTime	(	double	aT,
		int	aN,
		double *	rData
	)			const

Get the first aN states at a specified time.

The values of the states are determined by linear interpolation.

Parameters:

	aT	Time at which to get the states.
	aN	Number of states to get.
	rData	Array where the returned data will be set. The size of rData is assumed to be at least aN.

Returns:: Number of states that were set.

int Storage::getDataAtTime	(	double	aT,
		int	aN,
		double **	rData
	)			const

Get the first aN states at a specified time.

The values of the states are determined by linear interpolation.

Parameters:

	aT	Time at which to get the states.
	aN	Number of states to get.
	rData	Pointer to an array where the returned data will be set. The size of *rData is assumed to be at least aN. If rData comes in as NULL, memory is allocated.

Returns:: Number of states that were set.

void Storage::getDataColumn	(	const std::string &	columnName,
		Array< double > &	rData,
		double	aStartTime = `0.0`
	)

Get the data column starting at aTime.

Return it in rData rData is preallocated by the caller.

int Storage::getDataColumn	(	const std::string &	aColumnName,
		double *&	rData
	)			const

Get the data corresponding to a state specified by name.

This call is equivalent to getting a column of data from the storage file.

Parameters:

	aColumnName	name in header of column for which to get the data.
	rData	Array containing the desired data. If rData is sent in as NULL, memory is allocated. However, if rData is sent in as a non-NULL, it is assumed that rData points to a memory block that is large enough to hold getSize() doubles.

Returns:: Number of values set in rData. The number of values set may be less than getSize() because not all stored state vectors are required to have the same number of states.

int Storage::getDataColumn	(	int	aStateIndex,
		Array< double > &	rData
	)			const

int Storage::getDataColumn	(	int	aStateIndex,
		double *&	rData
	)			const

Get the data corresponding to a specified state.

This call is equivalent to getting a column of data from the storage file.

Parameters:

	aStateIndex	Index of the state (column) for which to get the data.
	rData	Array containing the desired data. If rData is sent in as NULL, memory is allocated. However, if rData is sent in as a non-NULL, it is assumed that rData points to a memory block that is large enough to hold getSize() doubles.

Returns:: Number of values set in rData. The number of values set may be less than getSize() because not all stored state vectors are required to have the same number of states.

double Storage::getFirstTime ( ) const

Get the time of the first stored states.

Returns:: Time of the first stored states. If there is no stored state, the constant SimTK::NaN (not a number) is returned.

const string & Storage::getHeaderToken ( ) const

Get the header token of this storage.

Returns:: Header token.

See also:: setHeaderToken()

StateVector * Storage::getLastStateVector ( ) const

Get the last states stored.

Returns:: Statevector. If no state vector is stored, NULL is returned.

double Storage::getLastTime ( ) const

Get the time of the last states.

Returns:: Time of the first stored states. If there is no stored state, the constant SimTK::NaN (not a number) is returned.

double Storage::getMinTimeStep ( ) const

Get the smallest time step.

Returns:: Smallest time step. If there are less than 2 state vectors, SimTK::Infinity is returned.

int OpenSim::Storage::getSize ( ) const [inline]

int Storage::getSmallestNumberOfStates ( ) const

Get the smallest number of states.

Ordinarily, the number of states is the same in each state vector; however, this is not required.

Returns:: Smallest number of states.

const int Storage::getStateIndex	(	const std::string &	aColumnName,
		int	startIndex = `0`
	)			const

Get the column index corresponding to specified column name.

Returns:: State index of column or -1. Note that the returned index is equivalent to the state index. For example, for the first column in a storage (usually time) -1 would be returned. For the second colunn in a storage (the first state) 0 would be returned.

added a default Parameter for startIndex. -Ayman

StateVector * Storage::getStateVector ( int aTimeIndex ) const

Get the StateVector at a spcified time index.

Parameters:

aTimeIndex

Time index at which to get the state vector: 0 <= aTimeIndex < _storage.getSize().

Returns:: Statevector. If no valid statevector exists at aTimeIndex, NULL is returned.

int Storage::getStepInterval ( ) const

Get the step interval.

bool Storage::getTime	(	int	aTimeIndex,
		double &	rTime,
		int	aStateIndex = `-1`
	)			const

Get the time at a specified time index for a specified state.

Parameters:

	aTimeIndex	Time index (row) for which to get the time.
	rTime	Time value.
	aStateIndex	Index of the state for which to get the time. By default, aStateIndex has a value of -1, which means disregard whether or not there is a valid state- just get the time at aTimeIndex. If aStateIndex is non-negative, the time is returned only if there is a valid state at aStateIndex.

Returns:: true when the time was set, false when there was no valid state.

int Storage::getTimeColumn	(	Array< double > &	rTimes,
		int	aStateIndex = `-1`
	)			const

int Storage::getTimeColumn	(	double *&	rTimes,
		int	aStateIndex = `-1`
	)			const

Get the times for a specified state.

Parameters:

	rTime	Array where times are set. If rTime is sent in as NULL, memory is allocated. If rTime is setn in as non-NULL, it is assumed that enough memory has been allocated at rTime to hold _storage.getSize() doubles.
	aStateIndex	Index of the state for which to get the times. By default, aStateIndex has a value of -1, which means disregard whether or not there is a valid state- just get the times. If aStateIndex is non-negative, the time is set only if there is a valid state at aStateIndex.

Returns:: Number of times set. This can be less than _storage.getSize() if a state does not exist for all or a subset of the stored statevectors.

void Storage::getTimeColumnWithStartTime	(	Array< double > &	rTimes,
		double	aStartTime = `0.0`
	)			const

Get the time column starting at aTime.

Return it in rTimes rTimes is preallocated by the caller.

void Storage::getValueForKey	(	const std::string &	aKey,
		std::string &	rValue
	)			const

bool Storage::getWriteSIMMHeader ( ) const

Get the whether or not to write a header appropriate for a SIMM motion file.

Parameters:

aTrueFalse

Whether (true) or not (false) to write a SIMM header.

bool Storage::hasKey ( const std::string & aKey ) const

Storage * Storage::integrate	(	double	aTI,
		double	aTF
	)			const

Integrate the state vectors between times aTI and aTF.

The integration results are returned in an Storage instance that is a copy of this instance except the name has been appended with "_integrated" and, of course, the state vectors have been integrated. The caller is responsible for deleting the returned storage instance.

Note that if aTI and aTF do not fall exactly on the time stamp of a stored state, the states are linearly interpolated or extrapolated to provide an estimate of the state at aTI or at aTF.

Parameters:

	aTI	Time at which to start the integration.
	aTF	Time at which to stop the integration.

Returns:: Storage instance of integrated results. NULL is returned if an error is encountered.

Storage * Storage::integrate	(	int	aI1 = `-2`,
		int	aI2 = `-1`
	)			const

Integrate the state vectors between aI1 and aI2.

The integration results are returned in an Storage instance that is a copy of this instance except the name has been appended with "_integrated" and, of course, the state vectors have been integrated. The caller is responsible for deleting the returned storage instance.

If aI1 is negative, integrations starts at the first StateVector held by this Storage instance. If aI2 is negative, integration starts at the last StateVector held by this Storage instance.

Note that aI1 and aI2 have negative default values, so that this method may be called without arguments to integrate all StateVectors held by this Storage instance.

Parameters:

	aI1	Index of state vector at which to start integration.
	aI2	Index of state vector at which to stop integration.

Returns:: Storage instance of integrated results. NULL is returned if an error is encountered.

void Storage::interpolateAt ( const Array< double > & targetTimes )

interpolateAt passed in list of time values.

Tries to check if there is a data row at the specified times to avoid introducing duplicates.

void Storage::lowpassFIR	(	int	aOrder,
		double	aCutoffFrequency
	)

Lowpass filter each of the columns in the storage.

Note that as a part of this operation, the storage is resampled so that the statevectors are at equal spacing.

Parameters:

	aOrder	Order of the FIR filter.
	aCutoffFrequency	Cutoff frequency.

void Storage::lowpassIIR ( double aCutoffFrequency )

Lowpass filter each of the columns in the storage.

Note that as a part of this operation, the storage is resampled so that the statevectors are at equal spacing.

Parameters:

	aOrder	Order of the FIR filter.
	aCutoffFrequency	Cutoff frequency.

void Storage::multiply ( Storage * aStorage )

Multipy this storage instance by a storage instance.

Linear interpolation or extrapolation is used to get the values of the states that correspond in time to the states held in this storage instance.

Parameters:

aStorage

Storage instance by which to multiply. s

void Storage::multiply ( StateVector * aStateVector )

Multiply all state vectors in this storage instance by a state vector.

Parameters:

aStateVector

State vector by which to multiply the state vectors.

See also:: StateVector::multiply(StateVector)

void Storage::multiply	(	int	aN,
		double	aY[]
	)

Multiply all state vectors in this storage instance by an array.

Only the first aN states of each state vector are altered.

Parameters:

	aN	Length of aY
	aY	Array of values the states are to be multiplied by.

See also:: StateVector::multiply(int,double[])

void Storage::multiply ( double aValue )

Multiply all state vectors in this storage instance by a value.

Parameters:

aValue

Value by which to mutiply the state vectors.

See also:: StateVector::multiply(double)

void Storage::multiplyColumn	(	int	aIndex,
		double	aValue
	)

Multiply entries at column aIndex by a value.

Parameters:

	aIndex	is the index of the column to multiply
	aValue	Value by which to mutiply the column.

void Storage::pad ( int aPadSize )

Pad each of the columns in a statevector by a specified amount.

Data is both prepended and appended by reflecting and negating.

Parameters:

aPadSize

Number of data points to prepend and append.

int OpenSim::Storage::print	(	const std::string &	aFileName,
		double	aDT,
		const std::string &	aMode = `"w"`
	)			const

bool OpenSim::Storage::print	(	const std::string &	aFileName,
		const std::string &	aMode = `"w"`,
		const std::string &	aComment = `""`
	)			const

void Storage::print ( ) const

Print the contents of this storage instance to standard output.

void Storage::printResult	(	const Storage *	aStorage,
		const std::string &	aName,
		const std::string &	aDir,
		double	aDT,
		const std::string &	aExtension
	)			`[static]`

void OpenSim::Storage::purge ( ) [inline]

double Storage::resample	(	double	aDT,
		int	aDegree
	)

Resample Storage columns to specified rate.

This's done by fitting splines to Storage columns and resampling

Parameters:

aDT

Time interval between adjacent statevectors.

Returns:: Actual sampling time step (may be clamped)

double Storage::resampleLinear ( double aDT )

Resample using linear interpolation.

int Storage::reset ( double aTime )

Reset the storage to start storing after a specified time.

If no valid statevector exists at that specified time, the storage is set to occur after the first valid statevector that immediately precedes the specified time.

Parameters:

aT

Time after which to start storing states. If aT doesn't exist exactly in the storage, the time is rounded down to the first valid time.

Returns:: Index at which the next appended statevector will be stored.

int Storage::reset ( int aIndex = 0 )

Reset the storage to start storing at a specified index.

All statevectors at and following the specified index are discarded.

If aIndex is less than or equal to zero, the storage object is emptied (i.e., its size is set to 0).

If aIndex is larger than the current size of the storage object, no action is taken.

Parameters:

aIndex

Index at which to start storing new statevectors.

Returns:: Index at which the next appended statevector will be stored.

void Storage::scaleTime ( double aValue )

Scale the times of all state vectors.

Parameters:

aValue

Value by which to scale the times.

void Storage::setCapacityIncrement ( int aIncrement )

Set the capacity increment of this storage object.

For details on what the capacity increment does see Array::setCapacityIncrement().

Parameters:

aIncrement

Capacity increment.

See also:: Array

void Storage::setColumnLabels ( const Array< std::string > & aColumnLabels )

Set column labels array.

void Storage::setDataColumn	(	int	aStateIndex,
		const Array< double > &	aData
	)

Set the data corresponding to a specified state.

This call is equivalent to setting a column of data from the storage file.

Parameters:

	aStateIndex	Index of the state (column) for which to get the data.
	aData	Array containing the new data.

Returns:: Number of values set in rData. The number of values set may be less than getSize() because not all stored state vectors are required to have the same number of states.

void Storage::setHeaderToken ( const std::string & aToken )

Set the header token.

The header token is used to mark the end of the header portion of an Storage when an Storage is saved in a file.

If the header token is NULL, a default header token is used.

Parameters:

aToken

Header token.

void Storage::setStepInterval ( int aStepInterval )

Set the step interval.

void Storage::setWriteSIMMHeader ( bool aTrueFalse )

Set the whether or not to write a header appropriate for a SIMM motion file.

Parameters:

aTrueFalse

Whether (true) or not (false) to write a SIMM header.

void Storage::shiftTime ( double aValue )

Shift the times of all state vectors.

Parameters:

aValue

Value by which to shift the times.

void Storage::smoothSpline	(	int	aOrder,
		double	aCutoffFrequency
	)

Smooth spline each of the columns in the storage.

Note that as a part of this operation, the storage is resampled so that the statevectors are at equal spacing.

Parameters:

	aOrder	Order of the spline.
	aCutoffFrequency	Cutoff frequency.

int Storage::store	(	int	aStep,
		double	aT,
		int	aN,
		const double *	aY
	)			`[virtual]`

Store a simulation vector.

This method differs from append in that, if the integration step of a simulation is not a multiple of the step interval of this Storage class, the state is not appended. Note that if the step storage interval is 0, storage is turned off.

The first empty storage location is returned.

void Storage::subtract ( Storage * aStorage )

Subtract a storage instance to this storage instance.

Linear interpolation or extrapolation is used to get the values of the states that correspond in time to the states held in this storage instance.

Parameters:

aStorage

Storage to subtract from this storage. s

void Storage::subtract ( StateVector * aStateVector )

Subtract a state vector from all state vectors in this storage instance.

Parameters:

aStateVector

State vector to subtract from the state vectors.

See also:: StateVector::subtract(int,double[])

void Storage::subtract	(	int	aN,
		double	aY[]
	)

Subtract an array from all state vectors in this storage instance.

Only the first aN states of each state vector are altered.

Parameters:

	aN	Length of aY
	aY	Array of values to subtract from the state vectors.

See also:: StateVector::subtract(int,double[])

void Storage::subtract ( double aValue )

Subtract a value from all state vectors in this storage instance.

Parameters:

aValue

Value to subtract from the state vectors.

See also:: StateVector::subtract(double)

Member Data Documentation

Array<std::string> OpenSim::Storage::_columnLabels [protected]

Column labels.

std::string OpenSim::Storage::_headerToken [protected]

Token used to mark the end of the description in a file.

MapKeysToValues OpenSim::Storage::_keyValueMap [protected]

Map between keys in file header and values.

int OpenSim::Storage::_lastI [mutable, protected]

Last index at which a search was started.

int OpenSim::Storage::_stepInterval [protected]

Step interval at which states in a simulation are stored.

See store().

Array<StateVector> OpenSim::Storage::_storage [protected]

Array of StateVectors.

Units OpenSim::Storage::_units [protected]

Units in which the data is represented.

bool OpenSim::Storage::_writeSIMMHeader [protected]

Flag for whether or not to insert a SIMM style header.

const char * Storage::DEFAULT_HEADER_SEPARATOR = " \t\r\n" [static]

const char * Storage::DEFAULT_HEADER_TOKEN = "endheader" [static]

Default token used to mark the end of the storage description in a file.

const double Storage::LARGE_NEGATIVE = -1.0e-30 [static]

Large negative number.

const double Storage::LARGE_POSITIVE = 1.0e-30 [static]

Large positive number.

const int Storage::MAX_RESAMPLE_SIZE = 100000 [static]

string Storage::simmReservedKeys [static, protected]

Initial value:

 {
                                                                  "#",
                                                                  "range", "Range",
                                                                  "wrap", "Wrap", "WRAP",
                                                                  "event",
                                                                  "enforce_loops",
                                                                  "enforce_constraints",
                                                                  "calc_derivatives"}

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

OpenSim/Common/Storage.h
OpenSim/Common/Storage.cpp

OpenSim::Storage Class Reference

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Static Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation