d0/d96/MetaSkeleton_8hpp_source.html

/*

 * Copyright (c) 2011-2018, The DART development contributors

 * All rights reserved.

 *

 * The list of contributors can be found at:

 *   https://github.com/dartsim/dart/blob/master/LICENSE

 *

 * This file is provided under the following "BSD-style" License:

 *   Redistribution and use in source and binary forms, with or

 *   without modification, are permitted provided that the following

 *   conditions are met:

 *   * Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *   * Redistributions in binary form must reproduce the above

 *     copyright notice, this list of conditions and the following

 *     disclaimer in the documentation and/or other materials provided

 *     with the distribution.

 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

 *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 *   POSSIBILITY OF SUCH DAMAGE.

 */


#ifndef DART_DYNAMICS_METASKELETON_HPP_

#define DART_DYNAMICS_METASKELETON_HPP_


#include <vector>

#include <string>


#include <Eigen/Dense>


#include "dart/common/LockableReference.hpp"

#include "dart/common/Signal.hpp"

#include "dart/common/Subject.hpp"

#include "dart/math/Geometry.hpp"

#include "dart/dynamics/Frame.hpp"

#include "dart/dynamics/InvalidIndex.hpp"


namespace dart {

namespace dynamics {


class BodyNode;

class SoftBodyNode;

class PointMass;

class Joint;

class DegreeOfFreedom;

class Marker;


class MetaSkeleton : public common::Subject

{

public:

  using NameChangedSignal

      = common::Signal<void(std::shared_ptr<const MetaSkeleton> _skeleton,

                            const std::string& _oldName,

                            const std::string& _newName)>;


  MetaSkeleton(const MetaSkeleton&) = delete;


  virtual ~MetaSkeleton() = default;


  virtual std::unique_ptr<common::LockableReference> getLockableReference()

  const = 0;

  // TODO: Rename this to getMutex once the deprecated Skeleton::getMutex() is

  // removed in DART 7.


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual const std::string& setName(const std::string& _name) = 0;


  virtual const std::string& getName() const = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual std::size_t getNumBodyNodes() const = 0;


  virtual BodyNode* getBodyNode(std::size_t _idx) = 0;


  virtual const BodyNode* getBodyNode(std::size_t _idx) const = 0;


  virtual BodyNode* getBodyNode(const std::string& name) = 0;


  virtual const BodyNode* getBodyNode(const std::string& name) const = 0;


  virtual const std::vector<BodyNode*>& getBodyNodes() = 0;


  virtual const std::vector<const BodyNode*>& getBodyNodes() const = 0;


  virtual std::vector<BodyNode*> getBodyNodes(const std::string& name) = 0;


  virtual std::vector<const BodyNode*> getBodyNodes(

      const std::string& name) const = 0;


  virtual bool hasBodyNode(const BodyNode* bodyNode) const = 0;


  virtual std::size_t getIndexOf(const BodyNode* _bn, bool _warning=true) const = 0;


  virtual std::size_t getNumJoints() const = 0;


  virtual Joint* getJoint(std::size_t _idx) = 0;


  virtual const Joint* getJoint(std::size_t _idx) const = 0;


  virtual Joint* getJoint(const std::string& name) = 0;


  virtual const Joint* getJoint(const std::string& name) const = 0;


  virtual std::vector<Joint*> getJoints() = 0;


  virtual std::vector<const Joint*> getJoints() const = 0;


  virtual std::vector<Joint*> getJoints(const std::string& name) = 0;


  virtual std::vector<const Joint*> getJoints(

      const std::string& name) const = 0;


  virtual bool hasJoint(const Joint* joint) const = 0;


  virtual std::size_t getIndexOf(const Joint* _joint, bool _warning=true) const = 0;


  virtual std::size_t getNumDofs() const = 0;


  virtual DegreeOfFreedom* getDof(std::size_t _idx) = 0;


  virtual const DegreeOfFreedom* getDof(std::size_t _idx) const = 0;


  virtual const std::vector<DegreeOfFreedom*>& getDofs() = 0;


  virtual std::vector<const DegreeOfFreedom*> getDofs() const = 0;


  virtual std::size_t getIndexOf(const DegreeOfFreedom* _dof,

                            bool _warning=true) const = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setCommand(std::size_t _index, double _command);


  double getCommand(std::size_t _index) const;


  void setCommands(const Eigen::VectorXd& _commands);


  void setCommands(const std::vector<std::size_t>& _indices,

                           const Eigen::VectorXd& _commands);


  Eigen::VectorXd getCommands() const;


  Eigen::VectorXd getCommands(const std::vector<std::size_t>& _indices) const;


  void resetCommands();


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setPosition(std::size_t index, double _position);


  double getPosition(std::size_t _index) const;


  void setPositions(const Eigen::VectorXd& _positions);


  void setPositions(const std::vector<std::size_t>& _indices,

                    const Eigen::VectorXd& _positions);


  Eigen::VectorXd getPositions() const;


  Eigen::VectorXd getPositions(const std::vector<std::size_t>& _indices) const;


  void resetPositions();


  void setPositionLowerLimit(std::size_t _index, double _position);


  void setPositionLowerLimits(const Eigen::VectorXd& positions);


  void setPositionLowerLimits(const std::vector<std::size_t>& indices,

                              const Eigen::VectorXd& positions);


  double getPositionLowerLimit(std::size_t _index) const;


  Eigen::VectorXd getPositionLowerLimits() const;


  Eigen::VectorXd getPositionLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setPositionUpperLimit(std::size_t _index, double _position);


  void setPositionUpperLimits(const Eigen::VectorXd& positions);


  void setPositionUpperLimits(const std::vector<std::size_t>& indices,

                              const Eigen::VectorXd& positions);


  double getPositionUpperLimit(std::size_t _index) const;


  Eigen::VectorXd getPositionUpperLimits() const;


  Eigen::VectorXd getPositionUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setVelocity(std::size_t _index, double _velocity);


  double getVelocity(std::size_t _index) const;


  void setVelocities(const Eigen::VectorXd& _velocities);


  void setVelocities(const std::vector<std::size_t>& _indices,

                     const Eigen::VectorXd& _velocities);


  Eigen::VectorXd getVelocities() const;


  Eigen::VectorXd getVelocities(const std::vector<std::size_t>& _indices) const;


  void resetVelocities();


  void setVelocityLowerLimit(std::size_t _index, double _velocity);


  void setVelocityLowerLimits(const Eigen::VectorXd& velocities);


  void setVelocityLowerLimits(const std::vector<std::size_t>& indices,

                              const Eigen::VectorXd& velocities);


  double getVelocityLowerLimit(std::size_t _index);


  Eigen::VectorXd getVelocityLowerLimits() const;


  Eigen::VectorXd getVelocityLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setVelocityUpperLimit(std::size_t _index, double _velocity);


  void setVelocityUpperLimits(const Eigen::VectorXd& velocities);


  void setVelocityUpperLimits(const std::vector<std::size_t>& indices,

                              const Eigen::VectorXd& velocities);


  double getVelocityUpperLimit(std::size_t _index);


  Eigen::VectorXd getVelocityUpperLimits() const;


  Eigen::VectorXd getVelocityUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setAcceleration(std::size_t _index, double _acceleration);


  double getAcceleration(std::size_t _index) const;


  void setAccelerations(const Eigen::VectorXd& _accelerations);


  void setAccelerations(const std::vector<std::size_t>& _indices,

                        const Eigen::VectorXd& _accelerations);


  Eigen::VectorXd getAccelerations() const;


  Eigen::VectorXd getAccelerations(const std::vector<std::size_t>& _indices) const;


  void resetAccelerations();


  void setAccelerationLowerLimit(std::size_t _index, double _acceleration);


  void setAccelerationLowerLimits(const Eigen::VectorXd& accelerations);


  void setAccelerationLowerLimits(const std::vector<std::size_t>& indices,

                              const Eigen::VectorXd& accelerations);


  double getAccelerationLowerLimit(std::size_t _index) const;


  Eigen::VectorXd getAccelerationLowerLimits() const;


  Eigen::VectorXd getAccelerationLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setAccelerationUpperLimit(std::size_t _index, double _acceleration);


  void setAccelerationUpperLimits(const Eigen::VectorXd& accelerations);


  void setAccelerationUpperLimits(const std::vector<std::size_t>& indices,

                              const Eigen::VectorXd& accelerations);


  double getAccelerationUpperLimit(std::size_t _index) const;


  Eigen::VectorXd getAccelerationUpperLimits() const;


  Eigen::VectorXd getAccelerationUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setForce(std::size_t _index, double _force);


  double getForce(std::size_t _index) const;


  void setForces(const Eigen::VectorXd& _forces);


  void setForces(const std::vector<std::size_t>& _index,

                 const Eigen::VectorXd& _forces);


  Eigen::VectorXd getForces() const;


  Eigen::VectorXd getForces(const std::vector<std::size_t>& _indices) const;


  void resetGeneralizedForces();


  void setForceLowerLimit(std::size_t _index, double _force);


  void setForceLowerLimits(const Eigen::VectorXd& forces);


  void setForceLowerLimits(const std::vector<std::size_t>& indices,

                           const Eigen::VectorXd& forces);


  double getForceLowerLimit(std::size_t _index) const;


  Eigen::VectorXd getForceLowerLimits() const;


  Eigen::VectorXd getForceLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setForceUpperLimit(std::size_t _index, double _force);


  void setForceUpperLimits(const Eigen::VectorXd& forces);


  void setForceUpperLimits(const std::vector<std::size_t>& indices,

                           const Eigen::VectorXd& forces);


  double getForceUpperLimit(std::size_t _index) const;


  Eigen::VectorXd getForceUpperLimits() const;


  Eigen::VectorXd getForceUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  Eigen::VectorXd getVelocityChanges() const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setJointConstraintImpulses(const Eigen::VectorXd& _impulses);


  Eigen::VectorXd getJointConstraintImpulses() const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual math::Jacobian getJacobian(const JacobianNode* _node) const = 0;


  virtual math::Jacobian getJacobian(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf) const = 0;


  math::Jacobian getJacobian(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  virtual math::Jacobian getJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset) const = 0;


  virtual math::Jacobian getJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf) const = 0;


  math::Jacobian getJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  virtual math::Jacobian getWorldJacobian(const JacobianNode* _node) const = 0;


  virtual math::Jacobian getWorldJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset) const = 0;


  virtual math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf = Frame::World()) const;


  math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf = Frame::World()) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual math::AngularJacobian getAngularJacobian(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  math::AngularJacobian getAngularJacobian(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf = Frame::World()) const;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node) const = 0;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf) const = 0;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset) const = 0;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf) const = 0;


  math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  virtual math::Jacobian getJacobianClassicDeriv(

      const JacobianNode* _node) const = 0;


  virtual math::Jacobian getJacobianClassicDeriv(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf) const = 0;


  virtual math::Jacobian getJacobianClassicDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getLinearJacobianDeriv(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getLinearJacobianDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::AngularJacobian getAngularJacobianDeriv(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual double getMass() const = 0;


  virtual const Eigen::MatrixXd& getMassMatrix() const = 0;


  virtual const Eigen::MatrixXd& getAugMassMatrix() const = 0;


  virtual const Eigen::MatrixXd& getInvMassMatrix() const = 0;


  virtual const Eigen::MatrixXd& getInvAugMassMatrix() const = 0;


  virtual const Eigen::VectorXd& getCoriolisForces() const = 0;


  virtual const Eigen::VectorXd& getGravityForces() const = 0;


  virtual const Eigen::VectorXd& getCoriolisAndGravityForces() const = 0;


  virtual const Eigen::VectorXd& getExternalForces() const = 0;


  virtual const Eigen::VectorXd& getConstraintForces() const = 0;


  virtual void clearExternalForces() = 0;


  virtual void clearInternalForces() = 0;


  double computeLagrangian() const;


  DART_DEPRECATED(6.1)

  double getKineticEnergy() const;


  virtual double computeKineticEnergy() const = 0;


  DART_DEPRECATED(6.1)

  double getPotentialEnergy() const;


  virtual double computePotentialEnergy() const = 0;


  DART_DEPRECATED(6.0)

  virtual void clearCollidingBodies() = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual Eigen::Vector3d getCOM(

      const Frame* _withRespectTo = Frame::World()) const = 0;


  virtual Eigen::Vector6d getCOMSpatialVelocity(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual Eigen::Vector3d getCOMLinearVelocity(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual Eigen::Vector6d getCOMSpatialAcceleration(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual Eigen::Vector3d getCOMLinearAcceleration(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::Jacobian getCOMJacobian(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getCOMLinearJacobian(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::Jacobian getCOMJacobianSpatialDeriv(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getCOMLinearJacobianDeriv(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


protected:


  MetaSkeleton();


  //--------------------------------------------------------------------------

  // Signals

  //--------------------------------------------------------------------------

  NameChangedSignal mNameChangedSignal;


public:


  //--------------------------------------------------------------------------

  // Slot registers

  //--------------------------------------------------------------------------

  common::SlotRegister<NameChangedSignal> onNameChanged;

};


} // namespace dynamics

} // namespace dart


#endif // DART_DYNAMICS_METASKELETON_HPP_

DART_DEPRECATED
#define DART_DEPRECATED(version)
Definition Deprecated.hpp:51

Frame.hpp

Geometry.hpp

InvalidIndex.hpp

LockableReference.hpp

Signal.hpp

name
std::string * name
Definition SkelParser.cpp:1642

index
std::size_t index
Definition SkelParser.cpp:1617

Subject.hpp

dart::common::Signal< void(std::shared_ptr< const MetaSkeleton > _skeleton, const std::string &_oldName, const std::string &_newName)>

dart::common::Subject
The Subject class is a base class for any object that wants to report when it gets destroyed.
Definition Subject.hpp:58

dart::dynamics::BodyNode
BodyNode class represents a single node of the skeleton.
Definition BodyNode.hpp:78

dart::dynamics::DegreeOfFreedom
DegreeOfFreedom class is a proxy class for accessing single degrees of freedom (aka generalized coord...
Definition DegreeOfFreedom.hpp:53

dart::dynamics::Frame
The Frame class serves as the backbone of DART's kinematic tree structure.
Definition Frame.hpp:57

dart::dynamics::Frame::World
static Frame * World()
Definition Frame.cpp:72

dart::dynamics::JacobianNode
The JacobianNode class serves as a common interface for BodyNodes and EndEffectors to both be used as...
Definition JacobianNode.hpp:54

dart::dynamics::Joint
class Joint
Definition Joint.hpp:59

dart::dynamics::MetaSkeleton
MetaSkeleton is a pure abstract base class that provides a common interface for obtaining data (such ...
Definition MetaSkeleton.hpp:62

dart::dynamics::MetaSkeleton::getForces
Eigen::VectorXd getForces() const
Get the forces for all generalized coordinates.
Definition MetaSkeleton.cpp:814

dart::dynamics::MetaSkeleton::setAccelerationLowerLimits
void setAccelerationLowerLimits(const Eigen::VectorXd &accelerations)
Set the lower limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:698

dart::dynamics::MetaSkeleton::getJacobian
virtual math::Jacobian getJacobian(const JacobianNode *_node, const Eigen::Vector3d &_localOffset, const Frame *_inCoordinatesOf) const =0
Get the spatial Jacobian targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getJoint
virtual const Joint * getJoint(const std::string &name) const =0
Returns the joint of given name.

dart::dynamics::MetaSkeleton::getLinearJacobianDeriv
virtual math::LinearJacobian getLinearJacobianDeriv(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
of a BodyNode.

dart::dynamics::MetaSkeleton::resetCommands
void resetCommands()
Set all commands to zero.
Definition MetaSkeleton.cpp:361

dart::dynamics::MetaSkeleton::getPotentialEnergy
double getPotentialEnergy() const
Get the potential energy of this MetaSkeleton.
Definition MetaSkeleton.cpp:1080

dart::dynamics::MetaSkeleton::getAccelerationUpperLimits
Eigen::VectorXd getAccelerationUpperLimits() const
Get the upper limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:770

dart::dynamics::MetaSkeleton::setVelocityLowerLimits
void setVelocityLowerLimits(const Eigen::VectorXd &velocities)
Set the lower limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:560

dart::dynamics::MetaSkeleton::getPositionUpperLimit
double getPositionUpperLimit(std::size_t _index) const
Get the upper limit of a generalized coordinate's position.
Definition MetaSkeleton.cpp:482

dart::dynamics::MetaSkeleton::setVelocityUpperLimits
void setVelocityUpperLimits(const Eigen::VectorXd &velocities)
Set the upper limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:604

dart::dynamics::MetaSkeleton::getAccelerationUpperLimit
double getAccelerationUpperLimit(std::size_t _index) const
Get the upper limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:763

dart::dynamics::MetaSkeleton::getCOM
virtual Eigen::Vector3d getCOM(const Frame *_withRespectTo=Frame::World()) const =0
Get the MetaSkeleton's COM with respect to any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::setForceUpperLimits
void setForceUpperLimits(const Eigen::VectorXd &forces)
Set the upperlimits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:887

dart::dynamics::MetaSkeleton::getBodyNode
virtual BodyNode * getBodyNode(std::size_t _idx)=0
Get BodyNode whose index is _idx.

dart::dynamics::MetaSkeleton::getKineticEnergy
double getKineticEnergy() const
Get the kinetic energy of this MetaSkeleton.
Definition MetaSkeleton.cpp:1074

dart::dynamics::MetaSkeleton::~MetaSkeleton
virtual ~MetaSkeleton()=default
Default destructor.

dart::dynamics::MetaSkeleton::setAcceleration
void setAcceleration(std::size_t _index, double _acceleration)
Set the acceleration of a single generalized coordinate.
Definition MetaSkeleton.cpp:641

dart::dynamics::MetaSkeleton::setAccelerationUpperLimit
void setAccelerationUpperLimit(std::size_t _index, double _acceleration)
Set the upper limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:738

dart::dynamics::MetaSkeleton::getCOMLinearVelocity
virtual Eigen::Vector3d getCOMLinearVelocity(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM linear velocity in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::clearCollidingBodies
virtual void clearCollidingBodies()=0
Clear collision flags of the BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::getCommands
Eigen::VectorXd getCommands() const
Get commands for all generalized coordinates.
Definition MetaSkeleton.cpp:347

dart::dynamics::MetaSkeleton::getForce
double getForce(std::size_t _index) const
Get the force of a single generalized coordinate.
Definition MetaSkeleton.cpp:792

dart::dynamics::MetaSkeleton::setForce
void setForce(std::size_t _index, double _force)
Set the force of a single generalized coordinate.
Definition MetaSkeleton.cpp:785

dart::dynamics::MetaSkeleton::getJacobianClassicDeriv
virtual math::Jacobian getJacobianClassicDeriv(const JacobianNode *_node, const Frame *_inCoordinatesOf) const =0
Get the spatial Jacobian (classical) time derivative targeting the origin a BodyNode.

dart::dynamics::MetaSkeleton::resetAccelerations
void resetAccelerations()
Set all accelerations to zero.
Definition MetaSkeleton.cpp:685

dart::dynamics::MetaSkeleton::mNameChangedSignal
NameChangedSignal mNameChangedSignal
Definition MetaSkeleton.hpp:881

dart::dynamics::MetaSkeleton::getLinearJacobian
virtual math::LinearJacobian getLinearJacobian(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the linear Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getIndexOf
virtual std::size_t getIndexOf(const DegreeOfFreedom *_dof, bool _warning=true) const =0
Get the index of a specific DegreeOfFreedom within this ReferentialSkeleton.

dart::dynamics::MetaSkeleton::resetPositions
void resetPositions()
Set all positions to zero.
Definition MetaSkeleton.cpp:410

dart::dynamics::MetaSkeleton::hasBodyNode
virtual bool hasBodyNode(const BodyNode *bodyNode) const =0
Returns whether this Skeleton contains bodyNode.

dart::dynamics::MetaSkeleton::getBodyNodes
virtual const std::vector< BodyNode * > & getBodyNodes()=0
Get all the BodyNodes that are held by this MetaSkeleton.

dart::dynamics::MetaSkeleton::getMassMatrix
virtual const Eigen::MatrixXd & getMassMatrix() const =0
Get the Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::getDofs
virtual const std::vector< DegreeOfFreedom * > & getDofs()=0
Get the vector of DegreesOfFreedom for this MetaSkeleton.

dart::dynamics::MetaSkeleton::getGravityForces
virtual const Eigen::VectorXd & getGravityForces() const =0
Get gravity force vector of the MetaSkeleton.

dart::dynamics::MetaSkeleton::clearExternalForces
virtual void clearExternalForces()=0
Clear the external forces of the BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::getBodyNode
virtual BodyNode * getBodyNode(const std::string &name)=0
Returns the BodyNode of given name.

dart::dynamics::MetaSkeleton::getBodyNode
virtual const BodyNode * getBodyNode(const std::string &name) const =0
Returns the BodyNode of given name.

dart::dynamics::MetaSkeleton::getNumJoints
virtual std::size_t getNumJoints() const =0
Get number of Joints.

dart::dynamics::MetaSkeleton::getPositionUpperLimits
Eigen::VectorXd getPositionUpperLimits() const
Get the upper limits for all generalized coordinates.
Definition MetaSkeleton.cpp:489

dart::dynamics::MetaSkeleton::getAngularJacobianDeriv
virtual math::AngularJacobian getAngularJacobianDeriv(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the angular Jacobian time derivative of a BodyNode.

dart::dynamics::MetaSkeleton::setPosition
void setPosition(std::size_t index, double _position)
Set the position of a single generalized coordinate.
Definition MetaSkeleton.cpp:367

dart::dynamics::MetaSkeleton::getMass
virtual double getMass() const =0
Get the total mass of all BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::setForceLowerLimits
void setForceLowerLimits(const Eigen::VectorXd &forces)
Set the lower limits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:843

dart::dynamics::MetaSkeleton::getLockableReference
virtual std::unique_ptr< common::LockableReference > getLockableReference() const =0
Returns mutex.

dart::dynamics::MetaSkeleton::getBodyNodes
virtual std::vector< const BodyNode * > getBodyNodes(const std::string &name) const =0
Returns all the BodyNodes of given name.

dart::dynamics::MetaSkeleton::getCOMLinearAcceleration
virtual Eigen::Vector3d getCOMLinearAcceleration(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the MetaSkeleton's COM linear acceleration in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::getAccelerationLowerLimit
double getAccelerationLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:716

dart::dynamics::MetaSkeleton::getForceUpperLimit
double getForceUpperLimit(std::size_t _index) const
Get the upper limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:902

dart::dynamics::MetaSkeleton::getJoint
virtual Joint * getJoint(std::size_t _idx)=0
Get Joint whose index is _idx.

dart::dynamics::MetaSkeleton::getPositionLowerLimits
Eigen::VectorXd getPositionLowerLimits() const
Get the lower limits for all generalized coordinates.
Definition MetaSkeleton.cpp:445

dart::dynamics::MetaSkeleton::setAccelerationUpperLimits
void setAccelerationUpperLimits(const Eigen::VectorXd &accelerations)
Set the upper limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:745

dart::dynamics::MetaSkeleton::getJacobian
virtual math::Jacobian getJacobian(const JacobianNode *_node, const Frame *_inCoordinatesOf) const =0
Get the spatial Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getVelocity
double getVelocity(std::size_t _index) const
Get the velocity of a single generalized coordinate.
Definition MetaSkeleton.cpp:511

dart::dynamics::MetaSkeleton::getInvMassMatrix
virtual const Eigen::MatrixXd & getInvMassMatrix() const =0
Get inverse of Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::setPositionUpperLimits
void setPositionUpperLimits(const Eigen::VectorXd &positions)
Set the upper limits for all generalized coordinates.
Definition MetaSkeleton.cpp:467

dart::dynamics::MetaSkeleton::getBodyNodes
virtual std::vector< BodyNode * > getBodyNodes(const std::string &name)=0
Returns all the BodyNodes of given name.

dart::dynamics::MetaSkeleton::getLinearJacobian
virtual math::LinearJacobian getLinearJacobian(const JacobianNode *_node, const Eigen::Vector3d &_localOffset, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the linear Jacobian targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getCOMJacobian
virtual math::Jacobian getCOMJacobian(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the MetaSkeleton's COM Jacobian in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::resetGeneralizedForces
void resetGeneralizedForces()
Set all forces of the generalized coordinates to zero.
Definition MetaSkeleton.cpp:828

dart::dynamics::MetaSkeleton::setCommand
void setCommand(std::size_t _index, double _command)
Set a single command.
Definition MetaSkeleton.cpp:318

dart::dynamics::MetaSkeleton::setVelocityUpperLimit
void setVelocityUpperLimit(std::size_t _index, double _velocity)
Set the upper limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:597

dart::dynamics::MetaSkeleton::getNumBodyNodes
virtual std::size_t getNumBodyNodes() const =0
Get number of body nodes.

dart::dynamics::MetaSkeleton::setAccelerationLowerLimit
void setAccelerationLowerLimit(std::size_t _index, double _acceleration)
Set the lower limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:691

dart::dynamics::MetaSkeleton::getForceLowerLimit
double getForceLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:858

dart::dynamics::MetaSkeleton::resetVelocities
void resetVelocities()
Set all velocities to zero.
Definition MetaSkeleton.cpp:547

dart::dynamics::MetaSkeleton::getJacobianClassicDeriv
virtual math::Jacobian getJacobianClassicDeriv(const JacobianNode *_node) const =0
Get the spatial Jacobian (classical) time derivative targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getVelocityUpperLimits
Eigen::VectorXd getVelocityUpperLimits() const
Get the upper limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:626

dart::dynamics::MetaSkeleton::getConstraintForces
virtual const Eigen::VectorXd & getConstraintForces() const =0
Get constraint force vector.

dart::dynamics::MetaSkeleton::getJoints
virtual std::vector< Joint * > getJoints(const std::string &name)=0
Returns all the Joint of given name.

dart::dynamics::MetaSkeleton::getDof
virtual DegreeOfFreedom * getDof(std::size_t _idx)=0
Get degree of freedom (aka generalized coordinate) whose index is _idx.

dart::dynamics::MetaSkeleton::getJoints
virtual std::vector< const Joint * > getJoints() const =0
Returns all the joints that are held by this MetaSkeleton.

dart::dynamics::MetaSkeleton::getVelocityLowerLimits
Eigen::VectorXd getVelocityLowerLimits() const
Get the lower limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:582

dart::dynamics::MetaSkeleton::getDofs
virtual std::vector< const DegreeOfFreedom * > getDofs() const =0
Get a vector of const DegreesOfFreedom for this MetaSkeleton.

dart::dynamics::MetaSkeleton::setForces
void setForces(const Eigen::VectorXd &_forces)
Set the forces of all generalized coordinates.
Definition MetaSkeleton.cpp:799

dart::dynamics::MetaSkeleton::getJoint
virtual Joint * getJoint(const std::string &name)=0
Returns the Joint of given name.

dart::dynamics::MetaSkeleton::setVelocities
void setVelocities(const Eigen::VectorXd &_velocities)
Set the velocities of all generalized coordinates.
Definition MetaSkeleton.cpp:518

dart::dynamics::MetaSkeleton::getVelocities
Eigen::VectorXd getVelocities() const
Get the velocities for all generalized coordinates.
Definition MetaSkeleton.cpp:533

dart::dynamics::MetaSkeleton::setName
virtual const std::string & setName(const std::string &_name)=0
Set the name of this MetaSkeleton.

dart::dynamics::MetaSkeleton::getPositionLowerLimit
double getPositionLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's position.
Definition MetaSkeleton.cpp:438

dart::dynamics::MetaSkeleton::setPositionLowerLimit
void setPositionLowerLimit(std::size_t _index, double _position)
Set the lower limit of a generalized coordinate's position.
Definition MetaSkeleton.cpp:416

dart::dynamics::MetaSkeleton::setPositions
void setPositions(const Eigen::VectorXd &_positions)
Set the positions for all generalized coordinates.
Definition MetaSkeleton.cpp:381

dart::dynamics::MetaSkeleton::getPosition
double getPosition(std::size_t _index) const
Get the position of a single generalized coordinate.
Definition MetaSkeleton.cpp:374

dart::dynamics::MetaSkeleton::setCommands
void setCommands(const Eigen::VectorXd &_commands)
Set commands for all generalized coordinates.
Definition MetaSkeleton.cpp:332

dart::dynamics::MetaSkeleton::getDof
virtual const DegreeOfFreedom * getDof(std::size_t _idx) const =0
Get degree of freedom (aka generalized coordinate) whose index is _idx.

dart::dynamics::MetaSkeleton::getJacobianSpatialDeriv
virtual math::Jacobian getJacobianSpatialDeriv(const JacobianNode *_node, const Frame *_inCoordinatesOf) const =0
Get the spatial Jacobian time derivative targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::clearInternalForces
virtual void clearInternalForces()=0
Clear the internal forces of the BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::hasJoint
virtual bool hasJoint(const Joint *joint) const =0
Returns whether this Skeleton contains join.

dart::dynamics::MetaSkeleton::getJacobianClassicDeriv
virtual math::Jacobian getJacobianClassicDeriv(const JacobianNode *_node, const Eigen::Vector3d &_localOffset, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the spatial Jacobian (classical) time derivative targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getCOMSpatialVelocity
virtual Eigen::Vector6d getCOMSpatialVelocity(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM spatial velocity in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::getCoriolisAndGravityForces
virtual const Eigen::VectorXd & getCoriolisAndGravityForces() const =0
Get combined vector of Coriolis force and gravity force of the MetaSkeleton.

dart::dynamics::MetaSkeleton::getAugMassMatrix
virtual const Eigen::MatrixXd & getAugMassMatrix() const =0
Get augmented mass matrix of the skeleton.

dart::dynamics::MetaSkeleton::getJacobian
virtual math::Jacobian getJacobian(const JacobianNode *_node, const Eigen::Vector3d &_localOffset) const =0
Get the spatial Jacobian targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getJacobian
virtual math::Jacobian getJacobian(const JacobianNode *_node) const =0
Get the spatial Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getForceLowerLimits
Eigen::VectorXd getForceLowerLimits() const
Get the lower limits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:865

dart::dynamics::MetaSkeleton::getCOMJacobianSpatialDeriv
virtual math::Jacobian getCOMJacobianSpatialDeriv(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM Jacobian spatial time derivative in terms of any Frame (default is World Frame...

dart::dynamics::MetaSkeleton::getForceUpperLimits
Eigen::VectorXd getForceUpperLimits() const
Get the upper limits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:909

dart::dynamics::MetaSkeleton::getCoriolisForces
virtual const Eigen::VectorXd & getCoriolisForces() const =0
Get Coriolis force vector of the MetaSkeleton's BodyNodes.

dart::dynamics::MetaSkeleton::getExternalForces
virtual const Eigen::VectorXd & getExternalForces() const =0
Get external force vector of the MetaSkeleton.

dart::dynamics::MetaSkeleton::getAccelerationLowerLimits
Eigen::VectorXd getAccelerationLowerLimits() const
Get the lower limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:723

dart::dynamics::MetaSkeleton::getPositions
Eigen::VectorXd getPositions() const
Get the positions for all generalized coordinates.
Definition MetaSkeleton.cpp:396

dart::dynamics::MetaSkeleton::getAcceleration
double getAcceleration(std::size_t _index) const
Get the acceleration of a single generalized coordinate.
Definition MetaSkeleton.cpp:648

dart::dynamics::MetaSkeleton::setPositionLowerLimits
void setPositionLowerLimits(const Eigen::VectorXd &positions)
Set the lower limits for all generalized coordinates.
Definition MetaSkeleton.cpp:423

dart::dynamics::MetaSkeleton::getIndexOf
virtual std::size_t getIndexOf(const BodyNode *_bn, bool _warning=true) const =0
Get the index of a specific BodyNode within this ReferentialSkeleton.

dart::dynamics::MetaSkeleton::getVelocityUpperLimit
double getVelocityUpperLimit(std::size_t _index)
Get the upper limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:619

dart::dynamics::MetaSkeleton::setForceUpperLimit
void setForceUpperLimit(std::size_t _index, double _force)
Set the upper limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:880

dart::dynamics::MetaSkeleton::setForceLowerLimit
void setForceLowerLimit(std::size_t _index, double _force)
Set the lower limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:836

dart::dynamics::MetaSkeleton::getJoint
virtual const Joint * getJoint(std::size_t _idx) const =0
Get const Joint whose index is _idx.

dart::dynamics::MetaSkeleton::setAccelerations
void setAccelerations(const Eigen::VectorXd &_accelerations)
Set the accelerations of all generalized coordinates.
Definition MetaSkeleton.cpp:655

dart::dynamics::MetaSkeleton::getJacobianSpatialDeriv
virtual math::Jacobian getJacobianSpatialDeriv(const JacobianNode *_node, const Eigen::Vector3d &_localOffset, const Frame *_inCoordinatesOf) const =0
Get the spatial Jacobian time derivative targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getVelocityChanges
Eigen::VectorXd getVelocityChanges() const
Get the velocity changes for all the generalized coordinates.
Definition MetaSkeleton.cpp:924

dart::dynamics::MetaSkeleton::getWorldJacobian
virtual math::Jacobian getWorldJacobian(const JacobianNode *_node, const Eigen::Vector3d &_localOffset) const =0
Get the spatial Jacobian targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::setPositionUpperLimit
void setPositionUpperLimit(std::size_t _index, double _position)
Set the upper limit of a generalized coordainte's position.
Definition MetaSkeleton.cpp:460

dart::dynamics::MetaSkeleton::getAngularJacobian
virtual math::AngularJacobian getAngularJacobian(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the angular Jacobian of a BodyNode.

dart::dynamics::MetaSkeleton::MetaSkeleton
MetaSkeleton(const MetaSkeleton &)=delete

dart::dynamics::MetaSkeleton::getCOMLinearJacobianDeriv
virtual math::LinearJacobian getCOMLinearJacobianDeriv(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM Linear Jacobian time derivative in terms of any Frame (default is World Frame)...

dart::dynamics::MetaSkeleton::getWorldJacobian
virtual math::Jacobian getWorldJacobian(const JacobianNode *_node) const =0
Get the spatial Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::onNameChanged
common::SlotRegister< NameChangedSignal > onNameChanged
Definition MetaSkeleton.hpp:888

dart::dynamics::MetaSkeleton::computeKineticEnergy
virtual double computeKineticEnergy() const =0
Get the kinetic energy of this MetaSkeleton.

dart::dynamics::MetaSkeleton::setVelocityLowerLimit
void setVelocityLowerLimit(std::size_t _index, double _velocity)
Set the lower limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:553

dart::dynamics::MetaSkeleton::getJacobianSpatialDeriv
virtual math::Jacobian getJacobianSpatialDeriv(const JacobianNode *_node) const =0
Get the spatial Jacobian time derivative targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getBodyNodes
virtual const std::vector< const BodyNode * > & getBodyNodes() const =0
Get all the BodyNodes that are held by this MetaSkeleton.

dart::dynamics::MetaSkeleton::getVelocityLowerLimit
double getVelocityLowerLimit(std::size_t _index)
Get the lower limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:575

dart::dynamics::MetaSkeleton::computePotentialEnergy
virtual double computePotentialEnergy() const =0
Get the potential energy of this MetaSkeleton.

dart::dynamics::MetaSkeleton::getCommand
double getCommand(std::size_t _index) const
Get a single command.
Definition MetaSkeleton.cpp:325

dart::dynamics::MetaSkeleton::getAccelerations
Eigen::VectorXd getAccelerations() const
Get the accelerations for all generalized coordinates.
Definition MetaSkeleton.cpp:670

dart::dynamics::MetaSkeleton::getCOMSpatialAcceleration
virtual Eigen::Vector6d getCOMSpatialAcceleration(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM spatial acceleration in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::computeLagrangian
double computeLagrangian() const
Compute and return Lagrangian of this MetaSkeleton.
Definition MetaSkeleton.cpp:1068

dart::dynamics::MetaSkeleton::getCOMLinearJacobian
virtual math::LinearJacobian getCOMLinearJacobian(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the MetaSkeleton's COM Linear Jacobian in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::getJacobianSpatialDeriv
virtual math::Jacobian getJacobianSpatialDeriv(const JacobianNode *_node, const Eigen::Vector3d &_localOffset) const =0
Get the spatial Jacobian time derivative targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getJoints
virtual std::vector< Joint * > getJoints()=0
Returns all the joints that are held by this MetaSkeleton.

dart::dynamics::MetaSkeleton::getJoints
virtual std::vector< const Joint * > getJoints(const std::string &name) const =0
Returns all the Joint of given name.

dart::dynamics::MetaSkeleton::getLinearJacobianDeriv
virtual math::LinearJacobian getLinearJacobianDeriv(const JacobianNode *_node, const Eigen::Vector3d &_localOffset, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the linear Jacobian (classical) time derivative targeting an offset in a BodyNode.

dart::dynamics::MetaSkeleton::getName
virtual const std::string & getName() const =0
Get the name of this MetaSkeleton.

dart::dynamics::MetaSkeleton::setJointConstraintImpulses
void setJointConstraintImpulses(const Eigen::VectorXd &_impulses)
Set the constraint impulses for the generalized coordinates.
Definition MetaSkeleton.cpp:931

dart::dynamics::MetaSkeleton::getJointConstraintImpulses
Eigen::VectorXd getJointConstraintImpulses() const
Get the constraint impulses for the generalized coordinates.
Definition MetaSkeleton.cpp:938

dart::dynamics::MetaSkeleton::getNumDofs
virtual std::size_t getNumDofs() const =0
Return the number of degrees of freedom in this skeleton.

dart::dynamics::MetaSkeleton::getInvAugMassMatrix
virtual const Eigen::MatrixXd & getInvAugMassMatrix() const =0
Get inverse of augmented Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::setVelocity
void setVelocity(std::size_t _index, double _velocity)
Set the velocity of a single generalized coordinate.
Definition MetaSkeleton.cpp:504

dart::dynamics::MetaSkeleton::getBodyNode
virtual const BodyNode * getBodyNode(std::size_t _idx) const =0
Get const BodyNode whose index is _idx.

dart::dynamics::MetaSkeleton::getIndexOf
virtual std::size_t getIndexOf(const Joint *_joint, bool _warning=true) const =0
Get the index of a specific Joint within this ReferentialSkeleton.

Eigen
Definition MathTypes.hpp:47

dart::math::Jacobian
Eigen::Matrix< double, 6, Eigen::Dynamic > Jacobian
Definition MathTypes.hpp:108

dart::math::AngularJacobian
Eigen::Matrix< double, 3, Eigen::Dynamic > AngularJacobian
Definition MathTypes.hpp:107

dart::math::LinearJacobian
Eigen::Matrix< double, 3, Eigen::Dynamic > LinearJacobian
Definition MathTypes.hpp:106

dart
Definition BulletCollisionDetector.cpp:63