RMLInputParameters.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 __RMLInputParameters__
#define __RMLInputParameters__


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
class RMLInputParameters
{

protected:

//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLInputParameters(const unsigned int DegreesOfFreedom)
    {
        this->NumberOfDOFs                  =   DegreesOfFreedom                        ;
        this->MinimumSynchronizationTime    =   0.0                                     ;
        this->SelectionVector               =   new RMLBoolVector   (DegreesOfFreedom)  ;
        this->CurrentPositionVector         =   new RMLDoubleVector (DegreesOfFreedom)  ;
        this->CurrentVelocityVector         =   new RMLDoubleVector (DegreesOfFreedom)  ;
        this->CurrentAccelerationVector     =   new RMLDoubleVector (DegreesOfFreedom)  ;
        this->MaxAccelerationVector         =   new RMLDoubleVector (DegreesOfFreedom)  ;
        this->MaxJerkVector                 =   new RMLDoubleVector (DegreesOfFreedom)  ;
        this->TargetVelocityVector          =   new RMLDoubleVector (DegreesOfFreedom)  ;

        memset(this->SelectionVector->VecData               ,   0x0 ,       DegreesOfFreedom * sizeof(bool))    ;
        memset(this->CurrentPositionVector->VecData         ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->CurrentVelocityVector->VecData         ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->CurrentAccelerationVector->VecData     ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->MaxAccelerationVector->VecData         ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->MaxJerkVector->VecData                 ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
        memset(this->TargetVelocityVector->VecData          ,   0x0 ,       DegreesOfFreedom * sizeof(double))  ;
    }

public:

//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLInputParameters(const RMLInputParameters &IP)
    {
        this->NumberOfDOFs              =   IP.GetNumberOfDOFs()                                            ;
        this->SelectionVector           =   new RMLBoolVector   ((IP.CurrentPositionVector)->GetVecDim())   ;
        this->CurrentPositionVector     =   new RMLDoubleVector ((IP.CurrentPositionVector)->GetVecDim())   ;
        this->CurrentVelocityVector     =   new RMLDoubleVector ((IP.CurrentPositionVector)->GetVecDim())   ;
        this->CurrentAccelerationVector =   new RMLDoubleVector ((IP.CurrentPositionVector)->GetVecDim())   ;
        this->MaxAccelerationVector     =   new RMLDoubleVector ((IP.CurrentPositionVector)->GetVecDim())   ;
        this->MaxJerkVector             =   new RMLDoubleVector ((IP.CurrentPositionVector)->GetVecDim())   ;
        this->TargetVelocityVector      =   new RMLDoubleVector ((IP.CurrentPositionVector)->GetVecDim())   ;

        *this                           =   IP                                                              ;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    ~RMLInputParameters(void)
    {
        delete  this->SelectionVector               ;
        delete  this->CurrentPositionVector         ;
        delete  this->CurrentVelocityVector         ;
        delete  this->CurrentAccelerationVector     ;
        delete  this->MaxAccelerationVector         ;
        delete  this->MaxJerkVector                 ;
        delete  this->TargetVelocityVector          ;

        this->SelectionVector           =   NULL    ;
        this->CurrentPositionVector     =   NULL    ;
        this->CurrentVelocityVector     =   NULL    ;
        this->CurrentAccelerationVector =   NULL    ;
        this->MaxAccelerationVector     =   NULL    ;
        this->MaxJerkVector             =   NULL    ;
        this->TargetVelocityVector      =   NULL    ;
        this->NumberOfDOFs              =   0       ;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLInputParameters &operator = (const RMLInputParameters &IP)
    {
        this->NumberOfDOFs                      =   IP.NumberOfDOFs                 ;
        this->MinimumSynchronizationTime        =   IP.MinimumSynchronizationTime   ;
        *(this->SelectionVector             )   =   *(IP.SelectionVector            );
        *(this->CurrentPositionVector       )   =   *(IP.CurrentPositionVector      );
        *(this->CurrentVelocityVector       )   =   *(IP.CurrentVelocityVector      );
        *(this->CurrentAccelerationVector   )   =   *(IP.CurrentAccelerationVector  );
        *(this->MaxAccelerationVector       )   =   *(IP.MaxAccelerationVector      );
        *(this->MaxJerkVector               )   =   *(IP.MaxJerkVector              );
        *(this->TargetVelocityVector        )   =   *(IP.TargetVelocityVector       );

        return(*this);
    }


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetSelectionVector(const RMLBoolVector &InputVector)
    {
        *(this->SelectionVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetSelectionVector(const bool *InputVector)
    {
        memcpy(     (void*)this->SelectionVector->VecData
                ,   (void*)InputVector
                ,   (this->SelectionVector->GetVecDim() * sizeof(bool)) );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetSelectionVectorElement(      const bool          &InputValue
                                            ,   const unsigned int  &Index)
    {
        (*this->SelectionVector)[Index] =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetSelectionVector(RMLBoolVector *InputVector) const
    {
        *InputVector    =   *(this->SelectionVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetSelectionVector(     bool                    *InputVector
                                    ,   const unsigned int      &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->SelectionVector->VecData
                ,   SizeInBytes );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetSelectionVectorElement(      bool                *InputValue
                                            ,   const unsigned int  &Index) const
    {
        if ( ( Index + 1 ) > ((unsigned int) this->SelectionVector->GetVecDim() ) )
        {
            *InputValue =   0.0;
        }
        else
        {
            *InputValue =   (*this->SelectionVector)[Index];
        }
    }


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentPositionVector(const RMLDoubleVector &InputVector)
    {
        *(this->CurrentPositionVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentPositionVector(const double *InputVector)
    {
        memcpy(     (void*)this->CurrentPositionVector->VecData
                ,   (void*)InputVector
                ,   (this->CurrentPositionVector->GetVecDim() * sizeof(double)) );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentPositionVectorElement(        const double        &InputValue
                                                    ,   const unsigned int  &Index)
    {
        (*this->CurrentPositionVector)[Index]   =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetCurrentPositionVector(RMLDoubleVector *InputVector) const
    {
        *InputVector    =   *(this->CurrentPositionVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetCurrentPositionVector(       double              *InputVector
                                            ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->CurrentPositionVector->VecData
                ,   SizeInBytes );
    }


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


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentVelocityVector(const RMLDoubleVector &InputVector)
    {
        *(this->CurrentVelocityVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentVelocityVector(const double *InputVector)
    {
        memcpy(     (void*)this->CurrentVelocityVector->VecData
                ,   (void*)InputVector
                ,   (this->CurrentVelocityVector->GetVecDim() * sizeof(double)) );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentVelocityVectorElement(    const double        &InputValue
                                                ,   const unsigned int  &Index)
    {
        (*this->CurrentVelocityVector)[Index]   =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetCurrentVelocityVector(RMLDoubleVector *InputVector) const
    {
        *InputVector    =   *(this->CurrentVelocityVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetCurrentVelocityVector(       double              *InputVector
                                            ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->CurrentVelocityVector->VecData
                ,   SizeInBytes );
    }


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


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentAccelerationVector(const RMLDoubleVector &InputVector)
    {
        *(this->CurrentAccelerationVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentAccelerationVector(const double *InputVector)
    {
        memcpy(     (void*)this->CurrentAccelerationVector->VecData
                ,   (void*)InputVector
                ,   (this->CurrentAccelerationVector->GetVecDim() * sizeof(double)) );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetCurrentAccelerationVectorElement(    const double        &InputValue
                                                    ,   const unsigned int  &Index)
    {
        (*this->CurrentAccelerationVector)[Index]   =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetCurrentAccelerationVector(RMLDoubleVector *InputVector) const
    {
        *InputVector    =   *(this->CurrentAccelerationVector);
    }



//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetCurrentAccelerationVector(       double              *InputVector
                                                ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->CurrentAccelerationVector->VecData
                ,   SizeInBytes );
    }


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


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMaxAccelerationVector(const RMLDoubleVector &InputVector)
    {
        *(this->MaxAccelerationVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMaxAccelerationVector(const double *InputVector)
    {
        memcpy(     (void*)this->MaxAccelerationVector->VecData
                ,   (void*)InputVector
                ,   (this->MaxAccelerationVector->GetVecDim() * sizeof(double)) );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMaxAccelerationVectorElement(    const double        &InputValue
                                                ,   const unsigned int  &Index)
    {
        (*this->MaxAccelerationVector)[Index]   =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetMaxAccelerationVector(RMLDoubleVector *InputVector) const
    {
        *InputVector    =   *(this->MaxAccelerationVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetMaxAccelerationVector(       double              *InputVector
                                            ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->MaxAccelerationVector->VecData
                ,   SizeInBytes );
    }


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


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMaxJerkVector(const RMLDoubleVector &InputVector)
    {
        *(this->MaxJerkVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMaxJerkVector(const double *InputVector)
    {
        memcpy(     (void*)this->MaxJerkVector->VecData
                ,   (void*)InputVector
                ,   (this->MaxJerkVector->GetVecDim() * sizeof(double)) );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMaxJerkVectorElement(    const double        &InputValue
                                        ,   const unsigned int  &Index)
    {
        (*this->MaxJerkVector)[Index]   =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetMaxJerkVector(RMLDoubleVector *InputVector) const
    {
        *InputVector    =   *(this->MaxJerkVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetMaxJerkVector(       double              *InputVector
                                    ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->MaxJerkVector->VecData
                ,   SizeInBytes );
    }


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


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetTargetVelocityVector(const RMLDoubleVector &InputVector)
    {
        *(this->TargetVelocityVector) = InputVector;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetTargetVelocityVector(const double *InputVector)
    {
        memcpy(     (void*)this->TargetVelocityVector->VecData
                ,   (void*)InputVector
                ,   (this->TargetVelocityVector->GetVecDim() * sizeof(double))  );
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetTargetVelocityVectorElement(     const double        &InputValue
                                                ,   const unsigned int  &Index)
    {
        (*this->TargetVelocityVector)[Index]    =   InputValue;
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetTargetVelocityVector(RMLDoubleVector *InputVector) const
    {
        *InputVector    =   *(this->TargetVelocityVector);
    }


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void GetTargetVelocityVector(    double              *InputVector
                                        ,   const unsigned int  &SizeInBytes) const
    {
        memcpy(     (void*)InputVector
                ,   (void*)this->TargetVelocityVector->VecData
                ,   SizeInBytes );
    }


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


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


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


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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    inline void SetMinimumSynchronizationTime(double Time)
    {
        this->MinimumSynchronizationTime    =   Time;
        return;
    }


protected:


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

        if (FileHandler == NULL)
        {
            return;
        }

        fprintf(FileHandler,   "Selection vector           : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %s ", (this->SelectionVector->VecData[i])?("true"):("false"));
        }
        fprintf(FileHandler, "\nCurrent position vector    : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->CurrentPositionVector->VecData[i]);
        }
        fprintf(FileHandler, "\nCurrent velocity vector    : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->CurrentVelocityVector->VecData[i]);
        }
        fprintf(FileHandler, "\nCurrent acceleration vector: ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->CurrentAccelerationVector->VecData[i]);
        }
        fprintf(FileHandler, "\nTarget velocity vector     : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->TargetVelocityVector->VecData[i]);
        }
        fprintf(FileHandler, "\nMax. acceleration vector   : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->MaxAccelerationVector->VecData[i]);
        }
        fprintf(FileHandler, "\nMax. jerk vector           : ");
        for (i = 0; i < this->NumberOfDOFs; i++)
        {
            fprintf(FileHandler, " %.20le ", this->MaxJerkVector->VecData[i]);
        }
        fprintf(FileHandler, "\n");
        return;
    }

public:

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


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    double                  MinimumSynchronizationTime;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLBoolVector           *SelectionVector;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *CurrentPositionVector;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *CurrentVelocityVector;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *CurrentAccelerationVector;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *MaxAccelerationVector;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *MaxJerkVector;


//  ---------------------- Doxygen info ----------------------
//  ----------------------------------------------------------
    RMLDoubleVector         *TargetVelocityVector;


};// class RMLInputParameters



#endif