d0/d96/MetaSkeleton_8hpp_source.html

 /*

  * Copyright (c) 2011-2019, 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 MetaSkeletonPtr cloneMetaSkeleton(

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

   // TODO: In DART7, rename this to clone() and change the current

   // Skeleton::clone() to override it.


   MetaSkeletonPtr cloneMetaSkeleton() const;


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

   const = 0;

   // TODO: In DART7, rename this to getMutex() and change the current

   // Skeleton::getMutex() to override it.


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

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


   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:820

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

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::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:367

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

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

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

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

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

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

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:893

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

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:647

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

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:744

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:353

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

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

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:691

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

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:416

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< const BodyNode * > & getBodyNodes() const =0
Get all the BodyNodes that are held by this MetaSkeleton.

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

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:495

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:373

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:849

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::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::getAccelerationLowerLimit
double getAccelerationLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's acceleration.
Definition: MetaSkeleton.cpp:722

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

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

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

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:517

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

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

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:834

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

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:603

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:697

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

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

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::resetVelocities
void resetVelocities()
Set all velocities to zero.
Definition: MetaSkeleton.cpp:553

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:632

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

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

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

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

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

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::setVelocities
void setVelocities(const Eigen::VectorXd &_velocities)
Set the velocities of all generalized coordinates.
Definition: MetaSkeleton.cpp:524

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

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

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:422

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

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

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

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

dart::dynamics::MetaSkeleton::getBodyNode
virtual const BodyNode * getBodyNode(std::size_t _idx) const =0
Get const BodyNode 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::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:871

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:915

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

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

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

dart::dynamics::MetaSkeleton::cloneMetaSkeleton
MetaSkeletonPtr cloneMetaSkeleton() const
Creates an identical clone of this MetaSkeleton.
Definition: MetaSkeleton.cpp:318

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

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

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

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:625

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:886

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

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

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:842

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

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

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:930

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::getBodyNode
virtual BodyNode * getBodyNode(const std::string &name)=0
Returns the BodyNode of given name.

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:466

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::getAugMassMatrix
virtual const Eigen::MatrixXd & getAugMassMatrix() const =0
Get augmented mass matrix of the skeleton.

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

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::getBodyNodes
virtual std::vector< BodyNode * > getBodyNodes(const std::string &name)=0
Returns all the BodyNodes of given name.

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:897

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:559

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::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::getConstraintForces
virtual const Eigen::VectorXd & getConstraintForces() const =0
Get constraint force vector.

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

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::getJoints
virtual std::vector< Joint * > getJoints(const std::string &name)=0
Returns all the Joint of given name.

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:331

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

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

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

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

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:1074

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::getMassMatrix
virtual const Eigen::MatrixXd & getMassMatrix() const =0
Get the Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::cloneMetaSkeleton
virtual MetaSkeletonPtr cloneMetaSkeleton(const std::string &cloneName) const =0
Creates an identical clone of this MetaSkeleton.

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::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::getJoint
virtual const Joint * getJoint(const std::string &name) const =0
Returns the joint of given name.

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

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

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

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

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

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::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: Random-impl.hpp:92

Eigen::Vector6d
Matrix< double, 6, 1 > Vector6d
Definition: MathTypes.hpp:49

dart::dynamics::MetaSkeletonPtr
std::shared_ptr< MetaSkeleton > MetaSkeletonPtr
Definition: SmartPointer.hpp:68

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