RMLOutputParameters.h

Go to the documentation of this file.

//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
//   For a convenient reading of this file's source code,
//   please use a tab width of four characters.
//  ----------------------------------------------------------


#ifndef __RMLOutputParameters__
#define __RMLOutputParameters__


#include "RMLVector.h"
#include <string.h>


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
class RMLOutputParameters
{
public:


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    enum ReturnValue
    {
        RETURN_SUCCESS  =   0,
        RETURN_ERROR    =   -1
    };


protected:

//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLOutputParameters(const unsigned int DegreesOfFreedom)
    {
        unsigned int    i                           =   0                                       ;

        this->TrajectoryIsPhaseSynchronized         =   false                                   ;

        this->NumberOfDOFs                          =   DegreesOfFreedom                        ;

        this->SynchronizationTime                   =   0.0                                     ;

        this->ANewCalculationWasPerformed           =   false                                   ;

        this->DOFWithTheGreatestExecutionTime       =   0                                       ;

        this->NewPositionVector                     =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->NewVelocityVector                     =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->NewAccelerationVector                 =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->MinExtremaTimesVector                 =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->MaxExtremaTimesVector                 =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->MinPosExtremaPositionVectorOnly       =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->MaxPosExtremaPositionVectorOnly       =   new RMLDoubleVector(DegreesOfFreedom)   ;
        this->ExecutionTimes                        =   new RMLDoubleVector(DegreesOfFreedom)   ;

        memset(this->NewPositionVector->VecData                 ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->NewVelocityVector->VecData                 ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->NewAccelerationVector->VecData             ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->MinExtremaTimesVector->VecData             ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->MaxExtremaTimesVector->VecData             ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->MinPosExtremaPositionVectorOnly->VecData   ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->MaxPosExtremaPositionVectorOnly->VecData   ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->ExecutionTimes->VecData                    ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;

        this->MinPosExtremaPositionVectorArray      =   new RMLDoubleVector*[DegreesOfFreedom]  ;
        this->MinPosExtremaVelocityVectorArray      =   new RMLDoubleVector*[DegreesOfFreedom]  ;
        this->MinPosExtremaAccelerationVectorArray  =   new RMLDoubleVector*[DegreesOfFreedom]  ;
        this->MaxPosExtremaPositionVectorArray      =   new RMLDoubleVector*[DegreesOfFreedom]  ;
        this->MaxPosExtremaVelocityVectorArray      =   new RMLDoubleVector*[DegreesOfFreedom]  ;
        this->MaxPosExtremaAccelerationVectorArray  =   new RMLDoubleVector*[DegreesOfFreedom]  ;

        for (i = 0; i < DegreesOfFreedom; i++)
        {
            (this->MinPosExtremaPositionVectorArray)        [i] =   new RMLDoubleVector(DegreesOfFreedom);
            (this->MinPosExtremaVelocityVectorArray)        [i] =   new RMLDoubleVector(DegreesOfFreedom);
            (this->MinPosExtremaAccelerationVectorArray)    [i] =   new RMLDoubleVector(DegreesOfFreedom);
            (this->MaxPosExtremaPositionVectorArray)        [i] =   new RMLDoubleVector(DegreesOfFreedom);
            (this->MaxPosExtremaVelocityVectorArray)        [i] =   new RMLDoubleVector(DegreesOfFreedom);
            (this->MaxPosExtremaAccelerationVectorArray)    [i] =   new RMLDoubleVector(DegreesOfFreedom);

            memset(((this->MinPosExtremaPositionVectorArray)            [i])->VecData       ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
            memset(((this->MinPosExtremaVelocityVectorArray)            [i])->VecData       ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
            memset(((this->MinPosExtremaAccelerationVectorArray)        [i])->VecData       ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
            memset(((this->MaxPosExtremaPositionVectorArray)            [i])->VecData       ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
            memset(((this->MaxPosExtremaVelocityVectorArray)            [i])->VecData       ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
            memset(((this->MaxPosExtremaAccelerationVectorArray)        [i])->VecData       ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        }

    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLOutputParameters(const RMLOutputParameters &OP)
    {
        unsigned int    i                           =   0                                                       ;

        this->TrajectoryIsPhaseSynchronized         =   OP.IsTrajectoryPhaseSynchronized()                      ;

        this->NumberOfDOFs                          =   OP.GetNumberOfDOFs()                                    ;

        this->SynchronizationTime                   =   OP.GetSynchronizationTime()                             ;

        this->ANewCalculationWasPerformed           =   OP.WasACompleteComputationPerformedDuringTheLastCycle() ;

        this->DOFWithTheGreatestExecutionTime       =   OP.GetDOFWithTheGreatestExecutionTime()                 ;

        this->NewPositionVector                     =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->NewVelocityVector                     =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->NewAccelerationVector                 =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->MinExtremaTimesVector                 =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->MaxExtremaTimesVector                 =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->MinPosExtremaPositionVectorOnly       =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->MaxPosExtremaPositionVectorOnly       =   new RMLDoubleVector(this->NumberOfDOFs)                 ;
        this->ExecutionTimes                        =   new RMLDoubleVector(this->NumberOfDOFs)                 ;

        this->MinPosExtremaPositionVectorArray      =   new RMLDoubleVector *[this->NumberOfDOFs]               ;
        this->MinPosExtremaVelocityVectorArray      =   new RMLDoubleVector *[this->NumberOfDOFs]               ;
        this->MinPosExtremaAccelerationVectorArray  =   new RMLDoubleVector *[this->NumberOfDOFs]               ;
        this->MaxPosExtremaPositionVectorArray      =   new RMLDoubleVector *[this->NumberOfDOFs]               ;
        this->MaxPosExtremaVelocityVectorArray      =   new RMLDoubleVector *[this->NumberOfDOFs]               ;
        this->MaxPosExtremaAccelerationVectorArray  =   new RMLDoubleVector *[this->NumberOfDOFs]               ;

        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            (this->MinPosExtremaPositionVectorArray)        [i] =   new RMLDoubleVector(this->NumberOfDOFs)     ;
            (this->MinPosExtremaVelocityVectorArray)        [i] =   new RMLDoubleVector(this->NumberOfDOFs)     ;
            (this->MinPosExtremaAccelerationVectorArray)    [i] =   new RMLDoubleVector(this->NumberOfDOFs)     ;
            (this->MaxPosExtremaPositionVectorArray)        [i] =   new RMLDoubleVector(this->NumberOfDOFs)     ;
            (this->MaxPosExtremaVelocityVectorArray)        [i] =   new RMLDoubleVector(this->NumberOfDOFs)     ;
            (this->MaxPosExtremaAccelerationVectorArray)    [i] =   new RMLDoubleVector(this->NumberOfDOFs)     ;
        }

        *this               =   OP                                                                              ;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    void Echo(FILE* FileHandler = stdout) const
    {
        unsigned int        i   =   0;

        if (FileHandler == NULL)
        {
            return;
        }

        fprintf(FileHandler,   "New position vector        : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->NewPositionVector->VecData[i]);
        }
        fprintf(FileHandler, "\nNew velocity vector        : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->NewVelocityVector->VecData[i]);
        }
        fprintf(FileHandler, "\nNew acceleration vector    : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->NewAccelerationVector->VecData[i]);
        }
        fprintf(FileHandler, "\n");
        return;
    }


public:

//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    ~RMLOutputParameters(void)
    {
        unsigned int        i   =   0;

        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            delete ((this->MinPosExtremaPositionVectorArray)        [i])    ;
            delete ((this->MinPosExtremaVelocityVectorArray)        [i])    ;
            delete ((this->MinPosExtremaAccelerationVectorArray)    [i])    ;
            delete ((this->MaxPosExtremaPositionVectorArray)        [i])    ;
            delete ((this->MaxPosExtremaVelocityVectorArray)        [i])    ;
            delete ((this->MaxPosExtremaAccelerationVectorArray)    [i])    ;
        }

        delete this->NewPositionVector                                      ;
        delete this->NewVelocityVector                                      ;
        delete this->NewAccelerationVector                                  ;
        delete this->MinPosExtremaPositionVectorArray                       ;
        delete this->MinPosExtremaVelocityVectorArray                       ;
        delete this->MinPosExtremaAccelerationVectorArray                   ;
        delete this->MaxPosExtremaPositionVectorArray                       ;
        delete this->MaxPosExtremaVelocityVectorArray                       ;
        delete this->MaxPosExtremaAccelerationVectorArray                   ;
        delete this->MinExtremaTimesVector                                  ;
        delete this->MaxExtremaTimesVector                                  ;
        delete this->MinPosExtremaPositionVectorOnly                        ;
        delete this->MaxPosExtremaPositionVectorOnly                        ;
        delete this->ExecutionTimes                                         ;

        this->NewPositionVector                     =   NULL                ;
        this->NewVelocityVector                     =   NULL                ;
        this->NewAccelerationVector                 =   NULL                ;
        this->MinPosExtremaPositionVectorArray      =   NULL                ;
        this->MinPosExtremaVelocityVectorArray      =   NULL                ;
        this->MinPosExtremaAccelerationVectorArray  =   NULL                ;
        this->MaxPosExtremaPositionVectorArray      =   NULL                ;
        this->MaxPosExtremaVelocityVectorArray      =   NULL                ;
        this->MaxPosExtremaAccelerationVectorArray  =   NULL                ;
        this->MinExtremaTimesVector                 =   NULL                ;
        this->MaxExtremaTimesVector                 =   NULL                ;
        this->MinPosExtremaPositionVectorOnly       =   NULL                ;
        this->MaxPosExtremaPositionVectorOnly       =   NULL                ;
        this->ExecutionTimes                        =   NULL                ;

        this->NumberOfDOFs                          =   0                   ;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLOutputParameters &operator = (const RMLOutputParameters &OP)
    {
        unsigned int        i                   =   0                                   ;

        this->NumberOfDOFs                      =   OP.NumberOfDOFs                     ;
        this->TrajectoryIsPhaseSynchronized     =   OP.TrajectoryIsPhaseSynchronized    ;
        this->ANewCalculationWasPerformed       =   OP.ANewCalculationWasPerformed      ;
        this->SynchronizationTime               =   OP.SynchronizationTime              ;
        this->DOFWithTheGreatestExecutionTime   =   OP.DOFWithTheGreatestExecutionTime  ;

        OP.GetNewPositionVector     (this->NewPositionVector                    )       ;
        OP.GetNewVelocityVector     (this->NewVelocityVector                    )       ;
        OP.GetNewAccelerationVector (this->NewAccelerationVector                )       ;
        OP.GetTimesAtMinPosition    (this->MinExtremaTimesVector                )       ;
        OP.GetTimesAtMaxPosition    (this->MaxExtremaTimesVector                )       ;
        OP.GetExecutionTimes        (this->ExecutionTimes                       )       ;

        OP.GetPositionalExtrema(    this->MinPosExtremaPositionVectorOnly
                                ,   this->MaxPosExtremaPositionVectorOnly       )       ;

        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            OP.GetMotionStateAtMinPosForOneDOF(     i
                                                ,   (this->MinPosExtremaPositionVectorArray)[i]
                                                ,   (this->MinPosExtremaVelocityVectorArray)[i]
                                                ,   (this->MinPosExtremaAccelerationVectorArray)[i]);

            OP.GetMotionStateAtMaxPosForOneDOF(     i
                                                ,   (this->MaxPosExtremaPositionVectorArray)[i]
                                                ,   (this->MaxPosExtremaVelocityVectorArray)[i]
                                                ,   (this->MaxPosExtremaAccelerationVectorArray)[i]);
        }

        return(*this);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewPositionVector(RMLDoubleVector *OutputVector) const
    {
        *OutputVector   =   *(this->NewPositionVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewPositionVector(       double              *OutputVector
                                        ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)OutputVector
                ,   (void*)this->NewPositionVector->VecData
                ,   SizeInBytes );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewPositionVectorElement(    double              *OutputValue
                                            ,   const unsigned int  &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->NewPositionVector->GetVecDim() ) )
        {
            *OutputValue    =   0.0;
        }
        else
        {
            *OutputValue    =   (*this->NewPositionVector)[Index];
        }
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline double GetNewPositionVectorElement(const unsigned int &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->NewPositionVector->GetVecDim() ) )
        {
            return(0.0);
        }
        else
        {
            return( (*this->NewPositionVector)[Index] );
        }
    }


// #############################################################################


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewVelocityVector(RMLDoubleVector *OutputVector) const
    {
        *OutputVector   =   *(this->NewVelocityVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewVelocityVector(       double              *OutputVector
                                        ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)OutputVector
                ,   (void*)this->NewVelocityVector->VecData
                ,   SizeInBytes );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewVelocityVectorElement(    double              *OutputValue
                                            ,   const unsigned int  &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->NewVelocityVector->GetVecDim() ) )
        {
            *OutputValue    =   0.0;
        }
        else
        {
            *OutputValue    =   (*this->NewVelocityVector)[Index];
        }
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline double GetNewVelocityVectorElement(const unsigned int &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->NewVelocityVector->GetVecDim() ) )
        {
            return(0.0);
        }
        else
        {
            return( (*this->NewVelocityVector)[Index] );
        }
    }


// #############################################################################


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewAccelerationVector(RMLDoubleVector *OutputVector) const
    {
        *OutputVector   =   *(this->NewAccelerationVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewAccelerationVector(       double              *OutputVector
                                            ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)OutputVector
                ,   (void*)this->NewAccelerationVector->VecData
                ,   SizeInBytes );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetNewAccelerationVectorElement(    double              *OutputValue
                                                ,   const unsigned int  &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->NewAccelerationVector->GetVecDim() ) )
        {
            *OutputValue    =   0.0;
        }
        else
        {
            *OutputValue    =   (*this->NewAccelerationVector)[Index];
        }
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline double GetNewAccelerationVectorElement(const unsigned int &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->NewAccelerationVector->GetVecDim() ) )
        {
            return(0.0);
        }
        else
        {
            return( (*this->NewAccelerationVector)[Index] );
        }
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetPositionalExtrema(       RMLDoubleVector     *MinimumPositionVector
                                        ,   RMLDoubleVector     *MaximumPositionVector) const
    {
        *MinimumPositionVector  =   *(this->MinPosExtremaPositionVectorOnly);
        *MaximumPositionVector  =   *(this->MaxPosExtremaPositionVectorOnly);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetPositionalExtrema(       double              *MinimumPositionVector
                                        ,   double              *MaximumPositionVector
                                        ,   const unsigned int  &SizeInBytes)  const
    {
        memcpy(     (void*)MinimumPositionVector
                ,   (void*)(this->MinPosExtremaPositionVectorOnly->VecData)
                ,   SizeInBytes                                                     );

        memcpy(     (void*)MaximumPositionVector
                ,   (void*)(this->MaxPosExtremaPositionVectorOnly->VecData)
                ,   SizeInBytes                                                     );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetTimesAtMinPosition(RMLDoubleVector *ExtremaTimes) const
    {
        *ExtremaTimes   =   *(this->MinExtremaTimesVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetTimesAtMaxPosition(RMLDoubleVector *ExtremaTimes) const
    {
        *ExtremaTimes   =   *(this->MaxExtremaTimesVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetTimesAtMinPosition(      double              *ExtremaTimes
                                        ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)ExtremaTimes
                ,   (void*)(this->MinExtremaTimesVector->VecData)
                ,   SizeInBytes                                         );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetTimesAtMaxPosition(      double              *ExtremaTimes
                                        ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)ExtremaTimes
                ,   (void*)(this->MaxExtremaTimesVector->VecData)
                ,   SizeInBytes                                         );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline int GetMotionStateAtMinPosForOneDOF(     const unsigned int  &DOF
                                                ,   RMLDoubleVector     *PositionVector
                                                ,   RMLDoubleVector     *VelocityVector
                                                ,   RMLDoubleVector     *AccelerationVector) const
    {
        if (DOF >= this->NumberOfDOFs)
        {
            return(RMLOutputParameters::RETURN_ERROR);
        }

        *PositionVector     =   *((this->MinPosExtremaPositionVectorArray       )[DOF]) ;
        *VelocityVector     =   *((this->MinPosExtremaVelocityVectorArray       )[DOF]) ;
        *AccelerationVector =   *((this->MinPosExtremaAccelerationVectorArray   )[DOF]) ;

        return(RMLOutputParameters::RETURN_SUCCESS);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline int GetMotionStateAtMinPosForOneDOF(     const unsigned int  &DOF
                                                ,   double              *PositionVector
                                                ,   double              *VelocityVector
                                                ,   double              *AccelerationVector
                                                ,   const unsigned int  &SizeInBytes) const
    {
        if (DOF >= this->NumberOfDOFs)
        {
            return(RMLOutputParameters::RETURN_ERROR);
        }

        memcpy(     (void*)PositionVector
                ,   (void*)(((this->MinPosExtremaPositionVectorArray)[DOF])->VecData)
                ,   SizeInBytes                                                             );

        memcpy(     (void*)VelocityVector
                ,   (void*)(((this->MinPosExtremaVelocityVectorArray)[DOF])->VecData)
                ,   SizeInBytes                                                             );

        memcpy(     (void*)AccelerationVector
                ,   (void*)(((this->MinPosExtremaAccelerationVectorArray)[DOF])->VecData)
                ,   SizeInBytes                                                                 );

        return(RMLOutputParameters::RETURN_SUCCESS);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline int GetMotionStateAtMaxPosForOneDOF(     const unsigned int  &DOF
                                                ,   RMLDoubleVector     *PositionVector
                                                ,   RMLDoubleVector     *VelocityVector
                                                ,   RMLDoubleVector     *AccelerationVector) const
    {
        if (DOF >= this->NumberOfDOFs)
        {
            return(RMLOutputParameters::RETURN_ERROR);
        }

        *PositionVector     =   *((this->MaxPosExtremaPositionVectorArray       )[DOF]) ;
        *VelocityVector     =   *((this->MaxPosExtremaVelocityVectorArray       )[DOF]) ;
        *AccelerationVector =   *((this->MaxPosExtremaAccelerationVectorArray   )[DOF]) ;

        return(RMLOutputParameters::RETURN_SUCCESS);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline int GetMotionStateAtMaxPosForOneDOF(     const unsigned int  &DOF
                                                ,   double              *PositionVector
                                                ,   double              *VelocityVector
                                                ,   double              *AccelerationVector
                                                ,   const unsigned int  &SizeInBytes) const
    {
        if (DOF >= this->NumberOfDOFs)
        {
            return(RMLOutputParameters::RETURN_ERROR);
        }

        memcpy(     (void*)PositionVector
                ,   (void*)(((this->MaxPosExtremaPositionVectorArray)[DOF])->VecData)
                ,   SizeInBytes                                                             );

        memcpy(     (void*)VelocityVector
                ,   (void*)(((this->MaxPosExtremaVelocityVectorArray)[DOF])->VecData)
                ,   SizeInBytes                                                             );

        memcpy(     (void*)AccelerationVector
                ,   (void*)(((this->MaxPosExtremaAccelerationVectorArray)[DOF])->VecData)
                ,   SizeInBytes                                                                 );

        return(RMLOutputParameters::RETURN_SUCCESS);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline unsigned int GetNumberOfDOFs(void) const
    {
        return(this->NumberOfDOFs);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline bool WasACompleteComputationPerformedDuringTheLastCycle(void) const
    {
        return(this->ANewCalculationWasPerformed);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline bool IsTrajectoryPhaseSynchronized(void) const
    {
        return(this->TrajectoryIsPhaseSynchronized);
    }

//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline double GetSynchronizationTime(void) const
    {
        return(this->SynchronizationTime);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline unsigned int GetDOFWithTheGreatestExecutionTime(void) const
    {
        return(this->DOFWithTheGreatestExecutionTime);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetExecutionTimes(RMLDoubleVector *OutputVector) const
    {
        *OutputVector   =   *(this->ExecutionTimes);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetExecutionTimes(      double              *OutputVector
                                    ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)OutputVector
                ,   (void*)this->ExecutionTimes->VecData
                ,   SizeInBytes );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetExecutionTimesElement(       double              *OutputValue
                                            ,   const unsigned int  &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->ExecutionTimes->GetVecDim() ) )
        {
            *OutputValue    =   0.0;
        }
        else
        {
            *OutputValue    =   (*this->ExecutionTimes)[Index];
        }
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline double GetExecutionTimesElement(const unsigned int &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->ExecutionTimes->GetVecDim() ) )
        {
            return(0.0);
        }
        else
        {
            return( (*this->ExecutionTimes)[Index] );
        }
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline double GetGreatestExecutionTime(void) const
    {
        return((this->ExecutionTimes->VecData)[this->DOFWithTheGreatestExecutionTime]);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    bool                    ANewCalculationWasPerformed;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    bool                    TrajectoryIsPhaseSynchronized;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    unsigned int            NumberOfDOFs;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    unsigned int            DOFWithTheGreatestExecutionTime;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    double                  SynchronizationTime;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *NewPositionVector                      ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *NewVelocityVector                      ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *NewAccelerationVector                  ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *MinExtremaTimesVector                  ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *MaxExtremaTimesVector                  ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *MinPosExtremaPositionVectorOnly        ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *MaxPosExtremaPositionVectorOnly        ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *ExecutionTimes;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         **MinPosExtremaPositionVectorArray      ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         **MinPosExtremaVelocityVectorArray      ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         **MinPosExtremaAccelerationVectorArray  ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         **MaxPosExtremaPositionVectorArray      ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         **MaxPosExtremaVelocityVectorArray      ;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         **MaxPosExtremaAccelerationVectorArray  ;

};// class RMLOutputParameters



#endif