---

IDLagrange.h

Go to the documentation of this file.

//
//      Title           : IDLagrange.h
//      Project         : OSCAR Version 2.0
//      Created         : Jun 30 14:05:48 1996
//      Author          : Chetan Kapoor
//      Platforms       : All
//      Copyright       : Copyright© The University of Texas at Austin, 2002. All rights reserved.
//                 
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//
//      Purpose         : Inverse Dynamics Using Tesar, Thomas formulation.
//
//----------------------------------------------------------------------------
//
//      $Revisions$
//                      2/12/03 - Make it compatible with new InverseDynamics - Chalongrath Pholsiri
//
//      $Log: IDLagrange.h,v $
//      Revision 1.5  2005/03/14 21:52:04  pmarch
//      Added to namespace OSCAR and removed "RR" from front of class names.
//
//      Revision 1.4  2004/05/28 18:57:58  pmarch
//      Added /defgroup and /ingroup tags.
//
//      Revision 1.3  2004/02/19 21:37:42  josh
//      - Updated documentation.
//
//      Revision 1.2  2003/09/02 21:05:08  eswint
//      - Reflects changes to Matrix v1.10
//
//      Revision 1.1  2003/08/18 21:17:50  josh
//      Initial commit
//
//

#ifndef IDLagrange_hpp
#define IDLagrange_hpp

#include "InverseDynamics.h"
#include "Math/Tensor.h"
#include "Math/Rot3by3.h"
#include "Math/Matrix.h"
#include "Math/Xform.h"

namespace OSCAR {

  class IDLagrange : public InverseDynamics
  {
  
  public:
    IDLagrange(unsigned int DOF, const String& linkCGandMassFile, 
      const String& linkInertiaFile, 
      const Vector3D& gravity = Vector3D(0.0, 0.0, -9.8));

    IDLagrange(unsigned int DOF, const MatrixData& linkCGandMass, 
      const TensorData& linkInertia, 
      const Vector3D& gravity = Vector3D(0.0, 0.0, -9.8));
  
    virtual ~IDLagrange();

    bool SetGfunctions(const Tensor* tg, const Tensor* rg = 0);

    bool SetHfunctions(const TensorP* th, const TensorP* rh);

    bool        GetGravityTorques(Vector& gravityTorques);

    bool        GetVelocityTorques(const Vector& velocity, 
      Vector& torques);

    bool        GetAccelerationTorques(const Vector& acceleration, 
      Vector& torques);

    const Vector& GetJointTorques(const Vector& velocity,
                                    const Vector& acceleration,
                                    const HandPose& eefLoad = HandPose(0,0,0,0,0,0));

    const Matrix* GetInertiaMatrix();

  
    const Rot3by3* GetGlobalInertiaMatrices(const Xform* global_ts);

    const Matrix* GetIstar(const Xform* global_ts);
    const Tensor* GetIstarForEachLink(const Xform* global_ts);
    const Tensor* GetPstar();
    const Tensor* GetPstar(const Xform* global_ts);
    bool        GetAppliedLoadTorques(unsigned int linkNumber, const Tensor& gr, 
      const Tensor& gt,
      const Vector& link_load, 
      Vector& jnt_torques);
  protected:
  
    Rot3by3     *rotations;       // DOF X 3 X 3.  This will hold the
                            // 3 X 3 rotation matrices of each link
                            // with respect to the base
  
    Rot3by3     *rotations_trans; // DOF X 3 X 3.  This will hold the transpose
                                // 3 X 3 rotation matrices of each link
                                // with respect to the base

    Tensor      *global_inertia;  // DOF X 3 X 3.  This will hold the local
                                // inertia tensors for each link defined
                                // in the global frame
  
    Matrix      *Istar;           // DOF X DOF.  This will hold the equivalent
                          // inertia matrix

    Tensor  *linkIstars;// DOF X DOF X DOF This holds the equivalent 
                          // inertia matrix for each link in a Tensor
                          // This tensor is only filled when 'calculateIstarForEachLink'
                          // is called so that 'calculateIstar' may be optimized for speed.
  
    Tensor      *Pstar;           // DOF X DOF X DOF.  This will hold the
                          // inertia power modeling matrix

    const Tensor *trans_g;
    const Tensor *rot_g;
    const TensorP *trans_h;
    const TensorP *rot_h;
    bool        IstarUpdated, PstarUpdated, gravityUpdated;
  
    void        fillRotationMatrices(const Xform* global_ts);
    bool        calculateGlobalInertiaMatrices(const Xform* global_ts); 
    bool        calculateIstar();
    bool  calculateIstarForEachLink();
    bool        calculatePstar();
  
  private:
    IDLagrange(const IDLagrange&);
    IDLagrange& operator=(const IDLagrange&);
  };

  #include "Dynamics/IDLagrange.ipp"

}

#endif  // ifndef IDLagrange_hpp

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations