linkage_dynamic_model Derived Type

type, public :: linkage_dynamic_model

Defines the variational-integrator representation of a linkage. Body index zero in a joint descriptor denotes the fixed ground link.


Contents

Constructor

Type-Bound Procedures


Constructor

public interface linkage_dynamic_model

  • private function ldm_from_serial(mechanism, q) result(rst)

    Constructs a dynamic model from a serial linkage and a compatible set of joint variables. Every serial link is treated as a moving rigid body; the proximal joint of the first link is attached to ground.

    Arguments

    Type IntentOptional Attributes Name
    type(serial_linkage), intent(in) :: mechanism

    The serial linkage to convert.
    real(kind=real64), intent(in), dimension(:) :: q

    One joint variable for each link.

    Return Value type(linkage_dynamic_model)

    The resulting dynamic model.

  • private function ldm_from_parallel(mechanism, q) result(rst)

    Constructs a dynamic model from a parallel or planar linkage. The mechanism's base link remains fixed and all other links become moving maximal-coordinate rigid bodies.

    Arguments

    Type IntentOptional Attributes Name
    class(kinematic_mechanism), intent(in) :: mechanism

    The parallel linkage to convert.
    real(kind=real64), intent(in), dimension(:) :: q

    The complete, constraint-compatible joint-variable array.

    Return Value type(linkage_dynamic_model)

    The resulting dynamic model.


Type-Bound Procedures

procedure, public :: add_axial_element => ldm_add_axial_element

  • private subroutine ldm_add_axial_element(this, element)

    Adds an extensible axial force element to the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(inout) :: this

    The model that receives the element.
    class(axial_force_element), intent(in) :: element

    The axial element to add. Its body indices must identify two distinct valid bodies or ground.

procedure, public :: add_linear_damper => ldm_add_linear_damper

  • private subroutine ldm_add_linear_damper(this, element)

    Adds a validated linear axial damper to the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(inout) :: this

    The model that receives the damper.
    type(linear_damper), intent(in) :: element

    The damper to add. Its damping coefficient must be nonnegative.

procedure, public :: add_linear_spring => ldm_add_linear_spring

  • private subroutine ldm_add_linear_spring(this, element)

    Adds a validated linear axial spring to the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(inout) :: this

    The model that receives the spring.
    type(linear_spring), intent(in) :: element

    The spring to add. Its stiffness and free length must be nonnegative.

procedure, public :: add_torsional_damper => ldm_add_torsional_damper

  • private subroutine ldm_add_torsional_damper(this, element)

    Adds a validated linear torsional damper to the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(inout) :: this

    The model that receives the damper.
    type(torsional_damper), intent(in) :: element

    The damper to add. Its damping coefficient must be nonnegative.

procedure, public :: add_torsional_element => ldm_add_torsional_element

  • private subroutine ldm_add_torsional_element(this, element)

    Adds an extensible torsional element bound to a revolute joint.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(inout) :: this

    The model that receives the element.
    class(torsional_force_element), intent(in) :: element

    The torsional element to add. Its one-based joint index must refer to a revolute joint in this model.

procedure, public :: add_torsional_spring => ldm_add_torsional_spring

  • private subroutine ldm_add_torsional_spring(this, element)

    Adds a validated linear torsional spring to the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(inout) :: this

    The model that receives the spring.
    type(torsional_spring), intent(in) :: element

    The spring to add. Its stiffness must be nonnegative.

procedure, public :: constraint_residual => ldm_constraint_residual

  • private function ldm_constraint_residual(this, state) result(rst)

    Evaluates every joint and planar constraint for a supplied state.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model whose constraints are evaluated.
    type(variational_state), intent(in) :: state

    The body state at which the constraints are evaluated.

    Return Value real(kind=real64), allocatable, dimension(:)

    The constraint residual vector in the model's constraint ordering.

procedure, public :: get_axial_element_count => ldm_get_axial_count

  • private pure function ldm_get_axial_count(this) result(rst)

    Gets the number of axial force elements in the model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.

    Return Value integer(kind=int32)

    The number of stored axial elements.

procedure, public :: get_axial_element_results => ldm_get_axial_results

  • private function ldm_get_axial_results(this, state) result(rst)

    Gets instantaneous lengths, rates, and signed forces for axial elements.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model containing the elements.
    type(variational_state), intent(in) :: state

    The state at which each element is evaluated.

    Return Value type(axial_element_result), allocatable, dimension(:)

    One result for each axial element, in insertion order.

procedure, public :: get_body_count => ldm_get_body_count

  • private pure function ldm_get_body_count(this) result(rst)

    Gets the number of moving rigid bodies in the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.

    Return Value integer(kind=int32)

    The number of moving bodies; ground is not included.

procedure, public :: get_constraint_count => ldm_get_constraint_count

  • private pure function ldm_get_constraint_count(this) result(rst)

    Gets the number of scalar constraints in the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.

    Return Value integer(kind=int32)

    The total number of joint and planar-body constraints.

procedure, public :: get_initial_state => ldm_get_initial_state

  • private function ldm_get_initial_state(this) result(rst)

    Gets a copy of the constraint-compatible state used to construct the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.

    Return Value type(variational_state)

    A copy of the model's constraint-compatible initial state.

procedure, public :: get_joint_count => ldm_get_joint_count

  • private pure function ldm_get_joint_count(this) result(rst)

    Gets the number of joints represented by the dynamic model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.

    Return Value integer(kind=int32)

    The joint count.

procedure, public :: get_joint_reactions => ldm_get_joint_reactions

  • private function ldm_get_joint_reactions(this, state, multipliers) result(rst)

    Converts one time step's constraint multipliers into the force and moment exerted by every joint on its child link. Multipliers associated with the planar-body constraints or a prescribed-motion constraint are excluded.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.
    type(variational_state), intent(in) :: state

    The state corresponding to the supplied multipliers.
    real(kind=real64), intent(in), dimension(:) :: multipliers

    The constraint multiplier vector returned by the integrator.

    Return Value type(joint_reaction), allocatable, dimension(:)

    One world-frame reaction wrench for each joint, in mechanism order.

procedure, public :: get_torsional_element_count => ldm_get_torsional_count

  • private pure function ldm_get_torsional_count(this) result(rst)

    Gets the number of torsional force elements in the model.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model.

    Return Value integer(kind=int32)

    The number of stored torsional elements.

procedure, public :: get_torsional_element_results => ldm_get_torsional_results

  • private function ldm_get_torsional_results(this, state) result(rst)

    Gets instantaneous angles, twist rates, and torques for torsional elements.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in) :: this

    The dynamic linkage model containing the elements.
    type(variational_state), intent(in) :: state

    The state at which each element is evaluated.

    Return Value type(torsional_element_result), allocatable, dimension(:)

    One result for each torsional element, in insertion order.

procedure, public :: solve => ldm_solve

  • private function ldm_solve(this, integrator, dt, ntime, initial_state, gravity, body_force, body_torque, prescribed_body, prescribed_motion, multipliers, args, info) result(rst)

    Integrates the linkage dynamics under an optional uniform world-frame gravitational acceleration and optional constant body loads.

    Arguments

    Type IntentOptional Attributes Name
    class(linkage_dynamic_model), intent(in), target :: this

    The dynamic linkage model to integrate.
    type(variational_integrator), intent(in) :: integrator

    The variational integrator used to advance the model.
    real(kind=real64), intent(in) :: dt

    The time step in seconds.
    integer(kind=int32), intent(in) :: ntime

    The number of time steps to integrate.
    type(variational_state), intent(in), optional :: initial_state

    An optional starting state; the model's initial state is used when this argument is absent.
    real(kind=real64), intent(in), optional, dimension(3) :: gravity

    Optional constant gravitational acceleration in world coordinates.
    real(kind=real64), intent(in), optional, dimension(:,:) :: body_force

    Constant 3-by-nbody world-frame force array.
    real(kind=real64), intent(in), optional, dimension(:,:) :: body_torque

    Constant 3-by-nbody body-frame torque array.
    integer(kind=int32), intent(in), optional :: prescribed_body

    The moving body whose absolute planar angle is prescribed.
    procedure(linkage_prescribed_motion), intent(in), optional, pointer :: prescribed_motion

    The prescribed absolute planar angle as a function of time.
    real(kind=real64), intent(out), optional, allocatable, dimension(:,:) :: multipliers

    Constraint multipliers for each completed time step. When a motion is prescribed, the last row is the required motor torque.
    class(*), intent(inout), optional, target :: args

    A mechanism for the caller to pass information to/from the user-defined routines (e.g. presribed_motion).
    type(variational_integrator_info), intent(out), optional :: info

    Optional convergence diagnostics aggregated over the trajectory.

    Return Value type(variational_state), allocatable, dimension(:)

    The state at the initial time followed by the state after each completed integration step.