licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 997 | """
Origin{T} <: Node{T}
Global reference frame
id: always 0
name: always :origin
state: State; defaults to zero values
shape: Shape; defaults to EmptyShape
"""
mutable struct Origin{T} <: Node{T}
id::Int64
name::Symbol
state::State{T}
shape::Shape{T}
function Origin{T}(;
name::Symbol=:origin,
state=State{T}(),
shape::Shape=EmptyShape()) where T
new{T}(getGlobalID(), name, state, shape)
end
function Origin(;
name::Symbol=:origin,
state=State{Float64}(),
shape::Shape=EmptyShape())
Origin{Float64}(; name, state, shape)
end
function Origin(body::Body{T}) where T
new{T}(body.id, body.name, body.state, body.shape)
end
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, origin::Origin)
summary(io, origin)
println(io, "")
println(io, " id: "*string(origin.id))
println(io, " name: "*string(origin.name))
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3746 | function set_velocity_solution!(body::Body)
state = body.state
state.vsol[1] = state.v15
state.vsol[2] = state.v15
state.ωsol[1] = state.ω15
state.ωsol[2] = state.ω15
end
function set_previous_configuration!(body::Body{T}, timestep::T) where {T}
x2, v15, q2, ω15 = initial_configuration_velocity(body.state)
body.state.x1 = next_position(x2, -v15, timestep)
body.state.q1 = next_orientation(q2, -ω15, timestep)
end
function initialize_state!(body::Body{T}, timestep) where T
set_previous_configuration!(body, timestep)
state = body.state
state.JF2 = szeros(T,3)
state.Jτ2 = szeros(T,3)
end
function update_state!(body::Body{T}, timestep) where T
state = body.state
state.x1 = state.x2
state.q1 = state.q2
state.v15 = state.vsol[2]
state.ω15 = state.ωsol[2]
state.x2 = next_position(state.x2, state.vsol[2], timestep)
state.q2 = next_orientation(state.q2, state.ωsol[2], timestep)
state.JF2 = szeros(T,3)
state.Jτ2 = szeros(T,3)
end
# maximal
function set_maximal_configurations!(body::Body;
x::AbstractVector=SA[0.0; 0.0; 0.0],
q::Quaternion=one(Quaternion))
body.state.x2 = x
body.state.q2 = q
return body.state.x2, body.state.q2
end
function set_maximal_velocities!(body::Body;
v::AbstractVector=SA[0.0; 0.0; 0.0],
ω::AbstractVector=SA[0.0; 0.0; 0.0])
body.state.v15 = v
body.state.ω15 = ω
return body.state.v15, body.state.ω15
end
function set_maximal_configurations!(pbody::Node, cbody::Body;
parent_vertex::AbstractVector=SA[0.0; 0.0; 0.0],
child_vertex::AbstractVector=SA[0.0; 0.0; 0.0],
Δx::AbstractVector=SA[0.0; 0.0; 0.0],
Δq::Quaternion=one(Quaternion))
q1 = pbody.state.q2
q2 = pbody.state.q2 * Δq
x2 = pbody.state.x2 + vector_rotate(parent_vertex + Δx, q1) - vector_rotate(child_vertex, q2)
return set_maximal_configurations!(cbody; x=x2, q=q2)
end
function set_maximal_velocities!(pbody::Node, cbody::Body;
parent_vertex::AbstractVector=SA[0.0; 0.0; 0.0],
child_vertex::AbstractVector=SA[0.0; 0.0; 0.0],
Δv::AbstractVector=SA[0.0; 0.0; 0.0],
Δω::AbstractVector=SA[0.0; 0.0; 0.0])
x1 = pbody.state.x2
v1 = pbody.state.v15
q1 = pbody.state.q2
ω1 = pbody.state.ω15
x2 = cbody.state.x2
q2 = cbody.state.q2
ω2 = vector_rotate(Δω + ω1, inv(q2) * q1)
ω1w = vector_rotate(ω1, q1)
ω2w = vector_rotate(ω2, q2)
Δvw = vector_rotate(Δv, q1)
cApB_w = (x2 + vector_rotate(child_vertex, q2)) - x1
pBcB_w = - vector_rotate(child_vertex, q2)
v2 = copy(v1)
v2 += skew(ω1w) * cApB_w
v2 += skew(ω2w) * pBcB_w
v2 += Δvw
return set_maximal_velocities!(cbody; v = v2, ω = ω2)
end
"""
set_external_force!(body; force, torque, vertex)
applies an external force on a body
body: Body
force: force in body frame
torque: torque in local frame
vertex: point where force is applied in local frame
"""
function set_external_force!(body::Body; force=zeros(3), torque=zeros(3), vertex=zeros(3))
body.state.Fext = vector_rotate(force, body.state.q2)
body.state.τext = torque + cross(vertex, force)
return
end
"""
add_external_force!(body; force, torque, vertex)
adds an additional external force on a body
body: Body
force: force in body frame
torque: torque in local frame
"""
function add_external_force!(body::Body; force=zeros(3), torque=zeros(3), vertex=zeros(3))
body.state.Fext += vector_rotate(force, body.state.q2)
body.state.τext += torque + cross(vertex, force)
return
end
function clear_external_force!(body::Body{T}) where T
body.state.Fext = szeros(T,3)
body.state.τext = szeros(T,3)
return
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 13458 | """
Shape{T}
Abstract type; Subtypes contain geometric and visual information for a Body.
"""
abstract type Shape{T} end
"""
EmptyShape{T} <: Shape{T}
Contains no geometric or visual information
"""
struct EmptyShape{T} <: Shape{T}
EmptyShape() = new{Float64}()
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, shape::EmptyShape)
summary(io, shape)
println(io, "")
end
#TODO: change to MeshShape
"""
Mesh{T} <: Shape{T}
Contains geometric and visual information based on .obj file
"""
mutable struct Mesh{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
path::String
scale::SVector{3,T}
color::RGBA
function Mesh(path::String;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((position_offset, orientation_offset))...)
new{T}(position_offset, orientation_offset, path, scale, color)
end
function Mesh(path::String, m::Real, J::AbstractMatrix;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((m, J, position_offset, orientation_offset))...)
return Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, path, scale, color))
end
end
"""
Box{T} <: Shape{T}
Cuboid geometry
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
xyz: dimensions (meters)
scale: scaling
color: RGBA
"""
mutable struct Box{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
xyz::SVector{3,T}
scale::SVector{3,T}
color::RGBA
function Box(x::Real, y::Real, z::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((x, y, z, position_offset, orientation_offset))...)
new{T}(position_offset, orientation_offset, [x; y; z], scale, color)
end
function Box(x::Real, y::Real, z::Real, m::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((x, y, z, m, position_offset, orientation_offset))...)
J = 1 / 12 * m * diagm([y^2 + z^2; x^2 + z^2; x^2 + y^2])
return Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, [x;y;z], scale, color))
end
end
"""
Cylinder{T} <: Shape{T}
cylinder geometry
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
rh: radius and height dimensions (meters)
scale: scaling
color: RGBA
"""
mutable struct Cylinder{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
rh::SVector{2,T}
scale::SVector{3,T}
color::RGBA
# Cylinder points in the z direction
function Cylinder(r::Real, h::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((r, h, position_offset, orientation_offset))...)
new{T}(position_offset, orientation_offset, [r;h], scale, color)
end
function Cylinder(r::Real, h::Real, m::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((r, h, m, position_offset, orientation_offset))...)
J = 1 / 2 * m * diagm([r^2 + 1 / 6 * h^2; r^2 + 1 / 6 * h^2; r^2])
return Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, [r;h], scale, color))
end
end
"""
Capsule geometry created as a CombinedShapes
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
rh: radius and height dimensions (meters)
scale: scaling
color: RGBA
"""
function Capsule(r::Real, h::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((r, h, position_offset, orientation_offset))...)
cylinder = Cylinder(r, h)
cap1 = Sphere(r; position_offset=[0;0;h/2])
cap2 = Sphere(r; position_offset=[0;0;-h/2])
CombinedShapes([cylinder;cap1;cap2]; position_offset, orientation_offset, scale, color)
end
function Capsule(r::Real, h::Real, m::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((r, h, m, position_offset, orientation_offset))...)
volume_cylinder = π * h * r^2.0
volume_hemisphere = π * 4.0 / 3.0 * r^3.0 / 2.0
volume_total = volume_cylinder + 2 * volume_hemisphere
mass_cylinder = m * volume_cylinder / volume_total
mass_hemisphere = m * volume_hemisphere / volume_total
Ixx_cylinder = mass_cylinder * (1.0 / 12.0 * h^2.0 + 1.0 / 4.0 * r^2.0)
Izz_cylinder = mass_cylinder * 1.0 / 2.0 * r^2.0
Ixx_hemisphere = 83.0 / 320 * mass_hemisphere * r^2
Izz_hemisphere = mass_hemisphere * 2.0 / 5.0 * r^2 / 2.0
d = (3.0 / 8.0 * r + 0.5 * h)
Ixx = Ixx_cylinder + 2.0 * (Ixx_hemisphere + mass_hemisphere * d^2.0)
Izz = Izz_cylinder + Izz_hemisphere * 2.0
J = diagm([Ixx; Ixx; Izz])
return Body(m, J; name=name, shape=Capsule(r, h; position_offset, orientation_offset, scale, color))
end
"""
CombinedShapes{T} <: Shape{T}
composite geometry
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
shape: list of Shape objects
xyz: dimensions (meters)
"""
mutable struct CombinedShapes{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
shapes::Vector{<:Shape{T}}
scale::SVector{3,T}
color::RGBA
function CombinedShapes(shapes::Vector{<:Shape{T}};
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75)) where T
new{T}(position_offset, orientation_offset, shapes, scale, color)
end
function CombinedShapes(shapes::Vector{<:Shape{T}}, m::T, J;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
name::Symbol=Symbol("body_" * randstring(4)),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75)) where T
Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, shapes, scale, color))
end
end
"""
Sphere{T} <: Shape{T}
sphere geometry
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
r: radius (meters)
scale: scaling
color: RGBA
"""
mutable struct Sphere{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
r::T
scale::SVector{3,T}
color::RGBA
function Sphere(r::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((r, position_offset, orientation_offset))...)
new{T}(position_offset, orientation_offset, r, scale, color)
end
function Sphere(r::Real, m::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((r, m, position_offset, orientation_offset))...)
J = 2 / 5 * m * diagm([r^2 for i = 1:3])
return Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, r, scale, color))
end
end
"""
Pyramid{T} <: Shape{T}
pyramid geometry
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
wh: width and height dimensions (meters)
scale: scaling
color: RGBA
"""
mutable struct Pyramid{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
wh::SVector{2,T}
scale::SVector{3,T}
color::RGBA
# Pyramid points in the z direction, Center of mass at 1/4 h
function Pyramid(w::Real, h::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((w, h, position_offset, orientation_offset))...)
new{T}(position_offset, orientation_offset, [w;h], scale, color)
end
function Pyramid(w::Real, h::Real, m::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)), color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((w, h, m, position_offset, orientation_offset))...)
J = 1/80 * m * diagm([4*w^2+3*h^2;4*w^2+3*h^2;8*w^2])
return Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, [w;h], scale, color))
end
end
"""
FrameShape{T} <: Shape{T}
coordinate frame geometry
position_offset: geometry origin offset from center of mass
orientation_offset: orientation offset from body frame
scale: scaling
color: not used
"""
mutable struct FrameShape{T} <: Shape{T}
position_offset::SVector{3,T}
orientation_offset::Quaternion{T}
scale::SVector{3,T}
color::RGBA
function FrameShape(;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((position_offset, orientation_offset))...)
new{T}(position_offset, orientation_offset, scale, color)
end
function FrameShape(m::Real;
position_offset::AbstractVector=szeros(3),
orientation_offset::Quaternion=one(Quaternion),
scale::AbstractVector=sones(3),
name::Symbol=Symbol("body_" * randstring(4)), color=RGBA(0.75, 0.75, 0.75))
T = promote_type(quateltype.((m, position_offset, orientation_offset))...)
J = m * sI(3)
return Body(m, J; name=name, shape=new{T}(position_offset, orientation_offset, scale, color))
end
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, shape::Shape)
summary(io, shape)
println(io,"")
println(io," position_offset: "*string(shape.position_offset))
println(io," orientation_offset: "*string(shape.orientation_offset))
println(io," scale: "*string(shape.scale))
println(io," color: "*string(shape.color))
end
function convert_shape(box::Box)
x, y, z = Tuple(box.xyz)
return GeometryBasics.HyperRectangle(Vec(-x / 2.0, -y / 2.0, -z / 2.0), Vec(x, y, z))
end
function convert_shape(cylinder::Cylinder)
r, h = Tuple(cylinder.rh)
return GeometryBasics.Cylinder(Point(0.0, 0.0, -h / 2.0),Point(0.0, 0.0, h / 2.0), r)
end
function convert_shape(sphere::Sphere)
r = sphere.r
return GeometryBasics.Sphere(Point(0.0, 0.0, 0.0), r)
end
function convert_shape(pyramid::Pyramid)
w, h = Tuple(pyramid.wh)
return GeometryBasics.Pyramid(Point(0.0, 0.0, -h / 4.0), h, w)
end
function convert_shape(frame::FrameShape)
return MeshCat.Triad()
end
function convert_shape(mesh::Mesh)
return MeshFileObject(mesh.path)
end
function convert_shape(::EmptyShape)
return nothing
end
function convert_shape(combinedshapes::CombinedShapes)
geom = []
for shape in combinedshapes.shapes
push!(geom, convert_shape(shape))
end
return geom
end
# color
set_color!(shape::EmptyShape, color) = nothing
function set_color!(shape::Shape, color)
shape.color = color
end
function set_color!(shapes::CombinedShapes, color)
for i in eachindex(shapes)
shapes.shape[i].color = color
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2907 | """
State{T}
state information in maximal coordinates for Body at time steps: 1, 2, 3.
information at time step 3 is recovered using configurations at time step 2 and velocities at time step 2.5.
x1: position at previous time step
q1: orientation (Quaternion) at previous time step
v15: linear velocity at time step 1.5 (midpoint)
ω15: angular velocity at time step 1.5 (midpoint)
x2: position at current time step
q2: orientation (Quaternion) at current time step
JF2: linear impulse (force * time step) applied at current time step
Jτ2: angular impulse (torque * timestep) applied at current time step
Fext: external force applied at current time step
τext: external torque applied at current time step
vsol: linear velocity at time step 2.5 (midpoint); contains current value (index 1) and candidate value (index 2)
ωsol: angular velocity at time step 2.5 (midpoint); contains current value (index 1) and candidate value (index 2)
d: implicit dynamics evaluator (zero vector indicates physics are satisfied)
D: Jacobian of implicit dynamics
"""
mutable struct State{T}
# previous state
x1::SVector{3,T}
q1::Quaternion{T}
v15::SVector{3,T}
ω15::SVector{3,T}
# current state
x2::SVector{3,T}
q2::Quaternion{T}
JF2::SVector{3,T}
Jτ2::SVector{3,T}
Fext::SVector{3,T}
τext::SVector{3,T}
# solution estimate [before step; after step]
vsol::Vector{SVector{3,T}}
ωsol::Vector{SVector{3,T}}
# dynamics and Jacobian evaluation
d::SVector{6,T}
D::SMatrix{6,6,T,36}
function State{T}() where T
x1 = szeros(T, 3)
q1 = one(Quaternion{T})
v15 = szeros(T, 3)
ω15 = szeros(T, 3)
x2 = szeros(T, 3)
q2 = one(Quaternion{T})
JF2 = szeros(T, 3)
Jτ2 = szeros(T, 3)
Fext = szeros(T, 3)
τext = szeros(T, 3)
vsol = [szeros(T, 3) for i=1:2]
ωsol = [szeros(T, 3) for i=1:2]
d = szeros(T, 6)
D = szeros(T, 6, 6)
new{T}(x1, q1, v15, ω15, x2, q2, JF2, Jτ2, Fext, τext, vsol, ωsol, d, D)
end
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, state::State{T}) where {T}
summary(io, state)
println(io, "")
println(io, "x1: "*string(state.x1))
println(io, "q1: "*string(state.q1))
println(io, "v15: "*string(state.v15))
println(io, "ω15: "*string(state.ω15))
println(io, "x2: "*string(state.x2))
println(io, "q2: "*string(state.q2))
println(io, "JF2: "*string(state.JF2))
println(io, "Jτ2: "*string(state.Jτ2))
println(io, "Fext: "*string(state.Fext))
println(io, "τext: "*string(state.τext))
println(io, "vsol: "*string(state.vsol))
println(io, "ωsol: "*string(state.ωsol))
println(io, "d: "*string(state.d))
println(io, "D: "*string(state.D))
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 489 | # second-order cone product; see: https://web.stanford.edu/~boyd/papers/ecos.html
function cone_product(u::AbstractVector{T}, v::AbstractVector{T}) where {T}
[u' * v; u[1] * v[2:end] + v[1] * u[2:end]]
end
function cone_product(u::SVector{N,T}, v::SVector{N,T}) where {N,T}
vcat(u' * v, u[1] * v[SUnitRange(2,end)] + v[1] * u[SUnitRange(2,end)])
end
function cone_product_jacobian(u::SVector{3,T}) where T
SMatrix{3,3,T,9}(u[1], u[2], u[3], u[2], u[1], 0, u[3], 0, u[1])
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3682 | # constraint Jacobian
function constraint_jacobian_configuration(mechanism, contact::ContactConstraint, body::Body)
relative = (body.id == contact.parent_id ? :parent : :child)
timestep = mechanism.timestep
pbody = get_body(mechanism, contact.parent_id)
cbody = get_body(mechanism, contact.child_id)
return constraint_jacobian_configuration(relative,
contact.model,
next_configuration_velocity(pbody.state, timestep)...,
next_configuration_velocity(cbody.state, timestep)...,
mechanism.timestep)
end
function constraint_jacobian_velocity(mechanism, contact::ContactConstraint, body::Body)
relative = (body.id == contact.parent_id ? :parent : :child)
timestep = mechanism.timestep
pbody = get_body(mechanism, contact.parent_id)
cbody = get_body(mechanism, contact.child_id)
return constraint_jacobian_velocity(relative,
contact.model,
next_configuration_velocity(pbody.state, timestep)...,
next_configuration_velocity(cbody.state, timestep)...,
mechanism.timestep)
end
# impulses
function impulses!(mechanism, body::Body, contact::ContactConstraint)
body.state.d -= impulse_map(mechanism, contact, body) * contact.impulses[2]
return
end
function impulse_map(mechanism, contact::ContactConstraint, body::Body)
relative = (body.id == contact.parent_id ? :parent : :child)
pbody = get_body(mechanism, contact.parent_id)
cbody = get_body(mechanism, contact.child_id)
return impulse_map(relative, contact.model, pbody, cbody, mechanism.timestep)
end
function impulse_map_jacobian_configuration(mechanism, body::Body{T}, contact::ContactConstraint{T}) where T
relative = (body.id == contact.parent_id ? :parent : :child)
return impulse_map_jacobian(relative, relative, contact.model,
get_body(mechanism, contact.parent_id),
get_body(mechanism, contact.child_id),
contact.impulses[2],
mechanism.timestep)
end
function impulses_jacobian_velocity!(mechanism, body::Body, contact::ContactConstraint)
timestep = mechanism.timestep
body.state.D -= impulse_map_jacobian_configuration(mechanism, body, contact) * integrator_jacobian_velocity(body, timestep)
return
end
# off-diagonal terms for linear system
function off_diagonal_jacobians(mechanism, body::Body, contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs,N½}
Z = szeros(T,N½,6)
return [Z' -impulse_map(mechanism, contact, body)], [Z; constraint_jacobian_velocity(mechanism, contact, body)]
end
# off-diagonal terms for linear system
function off_diagonal_jacobians(mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½}, body::Body) where {T,N,Nc,Cs,N½}
Z = szeros(T,N½,6)
return [Z; constraint_jacobian_velocity(mechanism, contact, body)], [Z' -impulse_map(mechanism, contact, body)]
end
# linear system entries
function set_matrix_vector_entries!(mechanism::Mechanism, matrix_entry::Entry, vector_entry::Entry, contact::ContactConstraint)
matrix_entry.value = constraint_jacobian(contact)
vector_entry.value = vcat(-complementarityμ(mechanism, contact), -constraint(mechanism, contact))
return
end
# reset variables using cone-specific neutral vector
function reset!(contact::ContactConstraint;
scale=1.0)
contact.impulses[1] = scale * neutral_vector(contact.model)
contact.impulses[2] = scale * neutral_vector(contact.model)
contact.impulses_dual[1] = scale * neutral_vector(contact.model)
contact.impulses_dual[2] = scale * neutral_vector(contact.model)
return
end
# dimension of cone
cone_degree(contact::ContactConstraint) = sum(cone_degree(contact.model))
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 5004 | """
ContactConstraint{T} <: Constraint{T}
constraint containing information for contact node.
id: unique identifying number
name: unique identifying name
model: type of contact model: ImpactContact, LinearContact, NonlinearContact
parent_id: identifying number of Body experiencing contact
child_id: always 0
impulses: contact impulses applied to Body
impulses_dual: dual contact impulses, used by solver to enforce correct contact behaviors
"""
mutable struct ContactConstraint{T,N,Nc,Cs,N½} <: Constraint{T,N}
# ID
id::Int64
name::Symbol
# contact model
model::Cs
# neighbor IDs
parent_id::Int
child_id::Int
# variables
impulses::Vector{SVector{N½,T}}
impulses_dual::Vector{SVector{N½,T}}
function ContactConstraint(data;
name::Symbol=Symbol("contact_" * randstring(4)))
model, parent_id, child_id = data
T = typeof(model).parameters[1]
N = length(model)
N½ = Int64(N/2)
impulses = [neutral_vector(model) for i = 1:2]
impulses_dual = [neutral_vector(model) for i = 1:2]
new{T,N,1,typeof(model),N½}(getGlobalID(), name, model, parent_id, child_id, impulses, impulses_dual)
end
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, constraint::ContactConstraint)
# summary(io, constraint)
# println(io, "")
# println(io, "id: "*string(constraint.id))
# println(io, "name: "*string(constraint.name))
# println(io, "model: "*string(constraint.model))
# println(io, "parent_id: "*string(constraint.parent_id))
# println(io, "child_id: "*string(constraint.child_id))
# println(io, "impulses: "*string(constraint.impulses))
# println(io, "impulses_dual: "*string(constraint.impulses_dual))
# end
"""
contact_constraint(bodies::Vector{Body})
generate ContactConstraints for each Body in list
normals: surface normal for each contact point
friction_coefficients: value of coefficient of friction for each contact point (optional for ImpactContact)
contact_origins: the offset with respect to the center of Body for each contact point (optional)
contact_radius: radius for each contact (optional)
contact_type: :nonlinear, :linear, :impact
"""
function contact_constraint(bodies::Vector{Body{T}},
normals::AbstractVector{<:AbstractVector};
friction_coefficients::AbstractVector=ones(T,length(normals)),
contact_origins::AbstractVector=[szeros(T, 3) for i=1:length(normals)],
contact_radii::AbstractVector=[0.0 for i=1:length(normals)],
names::Vector{Symbol}=[Symbol("contact_" * randstring(4)) for i = 1:length(normals)],
contact_type::Symbol=:nonlinear) where T
n = length(normals)
@assert n == length(bodies) == length(normals) == length(friction_coefficients) == length(contact_origins) == length(contact_radii)
contacts = Vector{ContactConstraint}()
for i = 1:n
contact = contact_constraint(bodies[i], normals[i],
friction_coefficient=friction_coefficients[i],
contact_origin=contact_origins[i],
contact_radius=contact_radii[i],
name=names[i],
contact_type=contact_type)
push!(contacts, contact)
end
contacts = [contacts...] # vector typing
return contacts
end
function contact_constraint(body::Body{T},
normals::AbstractVector{<:AbstractVector};
friction_coefficients::AbstractVector=ones(T,length(normals)),
contact_origins::AbstractVector=[szeros(T, 3) for i=1:length(normals)],
contact_radii::AbstractVector=[0.0 for i=1:length(normals)],
names::Vector{Symbol}=[Symbol("contact_" * randstring(4)) for i = 1:length(normals)],
contact_type::Symbol=:nonlinear) where T
n = length(normals)
@assert n == length(normals) == length(friction_coefficients) == length(contact_origins) == length(contact_radii)
return contact_constraint(fill(body, n), normals;
friction_coefficients, contact_origins, contact_radii, names, contact_type)
end
function contact_constraint(body::Body{T},
normal::AbstractVector;
friction_coefficient=T(1),
contact_origin::AbstractVector=szeros(T, 3),
contact_radius=T(0),
name::Symbol=Symbol("contact_" * randstring(4)),
contact_type::Symbol=:nonlinear) where T
if contact_type == :nonlinear
model = NonlinearContact(body, normal, friction_coefficient;
contact_origin, contact_radius)
elseif contact_type == :linear
model = LinearContact(body, normal, friction_coefficient;
contact_origin, contact_radius)
elseif contact_type == :impact
model = ImpactContact(body, normal;
contact_origin, contact_radius)
else
@warn "unknown contact_type"
end
contacts = ContactConstraint((model, body.id, 0); name)
return contacts
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 6633 | """
Contact{T,N}
Abstract type containing contact information associated with Body objects.
"""
abstract type Contact{T,N} end
# constraint Jacobians
function constraint_jacobian_configuration(relative::Symbol, model::Contact,
xp::AbstractVector, vp::AbstractVector, qp::Quaternion, ωp::AbstractVector,
xc::AbstractVector, vc::AbstractVector, qc::Quaternion, ωc::AbstractVector,
timestep)
# distance Jacobian
∂d∂x = ∂distance∂x(relative, model.collision, xp, qp, xc, qc)
∂d∂q = ∂distance∂q(relative, model.collision, xp, qp, xc, qc)
# contact point velocity Jacobian
∂vt∂x = ∂relative_tangential_velocity∂x(relative, model, xp, qp, vp, ωp, xc, qc, vc, ωc)
∂vt∂q = ∂relative_tangential_velocity∂q(relative, model, xp, qp, vp, ωp, xc, qc, vc, ωc)
X = [
∂d∂x;
szeros(1, 3);
model.friction_parameterization * ∂vt∂x;
]
Q = [
∂d∂q;
szeros(1, 4);
model.friction_parameterization * ∂vt∂q
]
return [X Q]
end
function constraint_jacobian_velocity(relative::Symbol, model::Contact,
xp::AbstractVector, vp::AbstractVector, qp::Quaternion, ωp::AbstractVector,
xc::AbstractVector, vc::AbstractVector, qc::Quaternion, ωc::AbstractVector,
timestep)
# distance Jacobian
∂d∂x = ∂distance∂x(relative, model.collision, xp, qp, xc, qc)
∂d∂q = ∂distance∂q(relative, model.collision, xp, qp, xc, qc)
# relative tangential velocity Jacobian
∂vt∂q = ∂relative_tangential_velocity∂q(relative, model, xp, qp, vp, ωp, xc, qc, vc, ωc)
∂vt∂v = ∂relative_tangential_velocity∂v(relative, model, xp, qp, vp, ωp, xc, qc, vc, ωc)
∂vt∂ω = ∂relative_tangential_velocity∂ω(relative, model, xp, qp, vp, ωp, xc, qc, vc, ωc)
# recover current orientation
if relative == :parent
x = next_position(xp, -vp, timestep)
∂x∂v = linear_integrator_jacobian_velocity(x, vp, timestep)
q = next_orientation(qp, -ωp, timestep)
∂q∂ω = rotational_integrator_jacobian_velocity(q, ωp, timestep);
elseif relative == :child
x = next_position(xc, -vc, timestep)
∂x∂v = linear_integrator_jacobian_velocity(x, vc, timestep)
q = next_orientation(qc, -ωc, timestep)
∂q∂ω = rotational_integrator_jacobian_velocity(q, ωc, timestep);
end
V = [
∂d∂x * ∂x∂v;
szeros(1, 3);
model.friction_parameterization * ∂vt∂v
]
Ω = [
∂d∂q * ∂q∂ω;
szeros(1, 3);
model.friction_parameterization * (∂vt∂ω + ∂vt∂q * ∂q∂ω);
]
return [V Ω]
end
function impulse_map(relative::Symbol, model::Contact, pbody::Node, cbody::Node, timestep)
# configurations
xp, qp = next_configuration(pbody.state, timestep)
xc, qc = next_configuration(cbody.state, timestep)
# mapping
X = force_mapping(relative, model, xp, qp, xc, qc)
c = contact_point(relative, model.collision, xp, qp, xc, qc)
if relative == :parent
r = c - xp
Q = rotation_matrix(inv(qp)) * skew(r) * X
elseif relative == :child
r = c - xc
Q = rotation_matrix(inv(qc)) * skew(r) * X
end
return [
X;
Q;
]
end
function impulse_map_jacobian(relative::Symbol, jacobian::Symbol, model::Contact, pbody::Node, cbody::Node, λ, timestep)
# configurations
xp, qp = next_configuration(pbody.state, timestep)
xc, qc = next_configuration(cbody.state, timestep)
# mapping
X = force_mapping(relative, model, xp, qp, xc, qc)
# force Jacobian
Xx = ∂force_mapping_jvp∂x(relative, jacobian, model, xp, qp, xc, qc, λ)
Xq = ∂force_mapping_jvp∂q(relative, jacobian, model, xp, qp, xc, qc, λ)
# contact point
c = contact_point(relative, model.collision, xp, qp, xc, qc)
# torque Jacobian
if relative == :parent
r = c - xp
q = qp
elseif relative == :child
r = c - xc
q = qc
end
Qx = rotation_matrix(inv(q)) * skew(r) * Xx
Qx -= rotation_matrix(inv(q)) * skew(X * λ) * (∂contact_point∂x(relative, jacobian, model.collision, xp, qp, xc, qc) - (relative == jacobian ? 1.0 : 0.0) * sI(3))
Qq = rotation_matrix(inv(q)) * skew(r) * Xq
Qq -= rotation_matrix(inv(q)) * skew(X * λ) * ∂contact_point∂q(relative, jacobian, model.collision, xp, qp, xc, qc)
Qq += ∂rotation_matrix∂q(inv(q), skew(r) * X * λ) * Tmat()
return [
Xx Xq;
Qx Qq;
]
end
# force mapping
function force_mapping(relative::Symbol, model::Contact,
xp::AbstractVector, qp::Quaternion,
xc::AbstractVector, qc::Quaternion)
X = [
contact_normal(model.collision, xp, qp, xc, qc)' szeros(3, 1) contact_tangent(model.collision, xp, qp, xc, qc)' * model.friction_parameterization'
]
if relative == :parent
return X
elseif relative == :child
return -1.0 * X
end
end
# mapping * λ
function ∂force_mapping_jvp∂x(relative::Symbol, jacobian::Symbol,
model::Contact,
xp::AbstractVector, qp::Quaternion,
xc::AbstractVector, qc::Quaternion,
λ::AbstractVector)
# normal
X = ∂contact_normal_transpose∂x(jacobian, model.collision, xp, qp, xc, qc) * λ[1]
# tangent
λ_tangent = model.friction_parameterization' * λ[SUnitRange(3, length(λ))]
X += ∂contact_tangent_one_transpose∂x(jacobian, model.collision, xp, qp, xc, qc) * λ_tangent[1]
X += ∂contact_tangent_two_transpose∂x(jacobian, model.collision, xp, qp, xc, qc) * λ_tangent[2]
if relative == :parent
return X
elseif relative == :child
return -1.0 * X
end
end
# mapping * λ
function ∂force_mapping_jvp∂q(relative::Symbol, jacobian::Symbol,
model::Contact,
xp::AbstractVector, qp::Quaternion,
xc::AbstractVector, qc::Quaternion,
λ::AbstractVector)
# normal
X = ∂contact_normal_transpose∂q(jacobian, model.collision, xp, qp, xc, qc) * λ[1]
# tangent
λ_tangent = model.friction_parameterization' * λ[SUnitRange(3, length(λ))]
X += ∂contact_tangent_one_transpose∂q(jacobian, model.collision, xp, qp, xc, qc) * λ_tangent[1]
X += ∂contact_tangent_two_transpose∂q(jacobian, model.collision, xp, qp, xc, qc) * λ_tangent[2]
if relative == :parent
return X
elseif relative == :child
return -1.0 * X
end
end
# utilities
Base.length(model::Contact{T,N}) where {T,N} = N
neutral_vector(model::Contact{T,N}) where {T,N} = sones(T, Int(N / 2))
cone_degree(model::Contact{T,N}) where {T,N} = Int(N / 2)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4535 | """
ImpactContact{T,N} <: Contact{T,N}
contact object for impact (i.e., no friction)
collision: Collision
"""
mutable struct ImpactContact{T,N} <: Contact{T,N}
friction_parameterization::SMatrix{0,2,T,0}
collision::Collision{T,0,3,0}
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, contact::ImpactContact)
# summary(io, contact)
# println(io, "")
# println(io, "friction_parameterization: "*string(contact.friction_parameterization))
# println(io, "collision: "*string(contact.collision))
# end
function ImpactContact(body::Body{T}, normal::AbstractVector;
contact_origin=szeros(T, 3),
contact_radius=0.0) where T
# contact directions
V1, V2, V3 = orthogonal_columns(normal) #
A = [V1 V2 V3]
Ainv = inv(A)
contact_normal = Ainv[3, SA[1; 2; 3]]'
# friction parametrization
parameterization = szeros(T, 0, 2)
# collision
collision = SphereHalfSpaceCollision(szeros(T, 0, 3), contact_normal, SVector{3}(contact_origin), contact_radius)
ImpactContact{Float64,2}(parameterization, collision)
end
function constraint(mechanism, contact::ContactConstraint{T,N,Nc,Cs}) where {T,N,Nc,Cs<:ImpactContact{T,N}}
# contact model
model = contact.model
# parent
pbody = get_body(mechanism, contact.parent_id)
xp, qp = next_configuration(pbody.state, mechanism.timestep)
# child
cbody = get_body(mechanism, contact.child_id)
xc, qc = next_configuration(cbody.state, mechanism.timestep)
# constraint
SVector{1,T}(distance(model.collision, xp, qp, xc, qc) - contact.impulses_dual[2][1])
end
function constraint_jacobian(contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:ImpactContact{T,N},N½}
γ = contact.impulses[2] + REG * neutral_vector(contact.model)
s = contact.impulses_dual[2] + REG * neutral_vector(contact.model)
∇s = hcat(γ, -Diagonal(sones(N½)))
∇γ = hcat(s, -Diagonal(szeros(N½)))
return [∇s ∇γ]
end
function constraint_jacobian_configuration(relative::Symbol, model::ImpactContact,
xp::AbstractVector, vp::AbstractVector, qp::Quaternion, ωp::AbstractVector,
xc::AbstractVector, vc::AbstractVector, qc::Quaternion, ωc::AbstractVector,
timestep)
X = ∂distance∂x(relative, model.collision, xp, qp, xc, qc)
Q = ∂distance∂q(relative, model.collision, xp, qp, xc, qc)
return [X Q]
end
function constraint_jacobian_velocity(relative::Symbol, model::ImpactContact,
xp::AbstractVector, vp::AbstractVector, qp::Quaternion, ωp::AbstractVector,
xc::AbstractVector, vc::AbstractVector, qc::Quaternion, ωc::AbstractVector,
timestep)
# recover current orientation
if relative == :parent
x = next_position(xp, -vp, timestep)
∂x∂v = linear_integrator_jacobian_velocity(x, vp, timestep)
q = next_orientation(qp, -ωp, timestep)
∂q∂ω = rotational_integrator_jacobian_velocity(q, ωp, timestep)
elseif relative == :child
x = next_position(xc, -vc, timestep)
∂x∂v = linear_integrator_jacobian_velocity(x, vc, timestep)
q = next_orientation(qc, -ωc, timestep)
∂q∂ω = rotational_integrator_jacobian_velocity(q, ωc, timestep)
end
# Jacobian
V = ∂distance∂x(relative, model.collision, xp, qp, xc, qc) * ∂x∂v
Ω = ∂distance∂q(relative, model.collision, xp, qp, xc, qc) * ∂q∂ω
return [V Ω]
end
function force_mapping(relative::Symbol, model::ImpactContact,
xp::AbstractVector, qp::Quaternion,
xc::AbstractVector, qc::Quaternion)
X = contact_normal(model.collision, xp, qp, xc, qc)'
if relative == :parent
return X
elseif relative == :child
return -1.0 * X
end
end
function ∂force_mapping_jvp∂x(relative::Symbol, jacobian::Symbol,
model::ImpactContact,
xp::AbstractVector, qp::Quaternion,
xc::AbstractVector, qc::Quaternion,
λ::AbstractVector)
X = ∂contact_normal_transpose∂x(jacobian, model.collision, xp, qp, xc, qc) * λ[1]
if relative == :parent
return X
elseif relative == :child
return -1.0 * X
end
end
function ∂force_mapping_jvp∂q(relative::Symbol, jacobian::Symbol,
model::ImpactContact,
xp::AbstractVector, qp::Quaternion,
xc::AbstractVector, qc::Quaternion,
λ::AbstractVector)
X = ∂contact_normal_transpose∂q(jacobian, model.collision, xp, qp, xc, qc) * λ[1]
if relative == :parent
return X
elseif relative == :child
return -1.0 * X
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3421 | """
LinearContact{T,N} <: Contact{T,N}
contact object for impact and friction with a linearized friction cone
friction_coefficient: value of friction coefficient
collision: Collision
"""
mutable struct LinearContact{T,N} <: Contact{T,N}
friction_coefficient::T
friction_parameterization::SMatrix{4,2,T,8}
collision::Collision{T,2,3,6}
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, contact::LinearContact)
# summary(io, contact)
# println(io, "")
# println(io, "friction_coefficient: "*string(contact.friction_coefficient))
# println(io, "friction_parameterization: "*string(contact.friction_parameterization))
# println(io, "collision: "*string(contact.collision))
# end
function LinearContact(body::Body{T}, normal::AbstractVector, friction_coefficient;
contact_origin=szeros(T, 3),
contact_radius=0.0) where T
# contact directions
V1, V2, V3 = orthogonal_columns(normal)
A = [V1 V2 V3]
Ainv = inv(A)
contact_normal = Ainv[3, SA[1; 2; 3]]'
contact_tangent = Ainv[SA[1; 2], SA[1; 2; 3]]
# friction parameterization
parameterization = SA{T}[
0.0 1.0
0.0 -1.0
1.0 0.0
-1.0 0.0
]
# collision
collision = SphereHalfSpaceCollision(contact_tangent, contact_normal, SVector{3}(contact_origin), contact_radius)
LinearContact{Float64,12}(friction_coefficient, parameterization, collision)
end
function constraint_jacobian(contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:LinearContact{T,N},N½}
friction_coefficient = contact.model.friction_coefficient
γ = contact.impulses[2] + REG * neutral_vector(contact.model)
s = contact.impulses_dual[2] + REG * neutral_vector(contact.model)
∇s1 = Diagonal(γ) # 6x6
∇s2 = Diagonal(-sones(T, 6))
∇s = vcat(∇s1, ∇s2) # 12x6
∇γ1 = Diagonal(s) # 6x6
∇γ2 = @SMatrix[0.0 0.0 0.0 0.0 0.0 0.0;
friction_coefficient 0.0 -1.0 -1.0 -1.0 -1.0;
0.0 1.0 0.0 0.0 0.0 0.0;
0.0 1.0 0.0 0.0 0.0 0.0;
0.0 1.0 0.0 0.0 0.0 0.0;
0.0 1.0 0.0 0.0 0.0 0.0;]
∇γ = vcat(∇γ1, ∇γ2) # 12x6
return [∇s ∇γ]
end
function constraint(mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:LinearContact{T,N},N½}
# contact model
model = contact.model
# parent
pbody = get_body(mechanism, contact.parent_id)
xp, vp, qp, ωp = next_configuration_velocity(pbody.state, mechanism.timestep)
# child
cbody = get_body(mechanism, contact.child_id)
xc, vc, qc, ωc = next_configuration_velocity(cbody.state, mechanism.timestep)
# distance
d = distance(model.collision, xp, qp, xc, qc)
# relative tangential velocity
vt = relative_tangential_velocity(model, xp, qp, vp, ωp, xc, qc, vc, ωc)
# unpack contact variables
γ = contact.impulses[2][1]
sγ = contact.impulses_dual[2][1]
ψ = contact.impulses[2][2]
sψ = contact.impulses_dual[2][2]
β = contact.impulses[2][SA[3;4;5;6]]
sβ = contact.impulses_dual[2][SA[3;4;5;6]]
SVector{N½,T}(
d - sγ,
model.friction_coefficient * γ - sum(β) - sψ,
(model.friction_parameterization * vt + ψ * sones(4) - sβ)...)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3600 | """
NonlinearContact{T,N} <: Contact{T,N}
contact object for impact and friction with a nonlinear friction cone
friction_coefficient: value of friction coefficient
contact_tangent: mapping from world frame to surface tangent frame
contact_normal: inverse/complement of contact_tangent
contact_origin: position of contact on Body relative to center of mass
contact radius: radius of contact
"""
mutable struct NonlinearContact{T,N} <: Contact{T,N}
friction_coefficient::T
friction_parameterization::SMatrix{2,2,T,4}
collision::Collision{T,2,3,6}
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, contact::NonlinearContact)
# summary(io, contact)
# println(io, "")
# println(io, "friction_coefficient: "*string(contact.friction_coefficient))
# println(io, "friction_parameterization: "*string(contact.friction_parameterization))
# println(io, "collision: "*string(contact.collision))
# end
function NonlinearContact(body::Body{T}, normal::AbstractVector, friction_coefficient;
contact_origin=szeros(T, 3),
contact_radius=0.0) where T
# contact directions
V1, V2, V3 = orthogonal_columns(normal)
A = [V1 V2 V3]
Ainv = inv(A)
contact_normal = Ainv[3, SA[1; 2; 3]]'
contact_tangent = Ainv[SA[1; 2], SA[1; 2; 3]]
# friction parameterization
parameterization = SA{T}[
1.0 0.0
0.0 1.0
]
# collision
collision = SphereHalfSpaceCollision(contact_tangent, contact_normal, SVector{3}(contact_origin), contact_radius)
NonlinearContact{T,8}(friction_coefficient, parameterization, collision)
end
function constraint(mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:NonlinearContact{T,N},N½}
# contact model
model = contact.model
# parent
pbody = get_body(mechanism, contact.parent_id)
xp, vp, qp, ωp = next_configuration_velocity(pbody.state, mechanism.timestep)
# child
cbody = get_body(mechanism, contact.child_id)
xc, vc, qc, ωc = next_configuration_velocity(cbody.state, mechanism.timestep)
# distance
d = distance(model.collision, xp, qp, xc, qc)
# relative tangential velocity
vt = relative_tangential_velocity(model, xp, qp, vp, ωp, xc, qc, vc, ωc)
# unpack contact variables
γ = contact.impulses[2]
s = contact.impulses_dual[2]
SVector{N½,T}(
d - s[1],
model.friction_coefficient * γ[1] - γ[2],
(model.friction_parameterization * vt - s[SA[3;4]])...)
end
function constraint_jacobian(contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:NonlinearContact{T,N},N½}
friction_coefficient = contact.model.friction_coefficient
γ = contact.impulses[2] + REG * neutral_vector(contact.model) # TODO need to check this is legit
s = contact.impulses_dual[2] + REG * neutral_vector(contact.model) # TODO need to check this is legit
∇s1 = [γ[SA[1]]; szeros(T,3)]'
∇s2 = [szeros(T,3,1) cone_product_jacobian(γ[SA[2,3,4]])]
∇s3 = Diagonal(SVector{4,T}(-1.0, 0.0, -1.0, -1.0))
∇s = [∇s1; ∇s2; ∇s3]
∇γ1 = [s[SA[1]]; szeros(T, 3)]'
∇γ2 = [szeros(T,3,1) cone_product_jacobian(s[SA[2,3,4]])]
∇γ3 = SA[0.0 0.0 0.0 0.0;
friction_coefficient -1.0 0.0 0.0;
0.0 0.0 0.0 0.0;
0.0 0.0 0.0 0.0;]
∇γ = [∇γ1; ∇γ2; ∇γ3]
return [∇s ∇γ]
end
neutral_vector(::NonlinearContact{T,N}) where {T,N} = [sones(T, 2); szeros(T, Int(N/2) - 2)]
cone_degree(::NonlinearContact) = 2
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2814 | """
get_sdf(contact, x, q)
returns the signed distance for a contact
contact: ContactConstraint
x: body position
q: body orientation
"""
function get_sdf(contact::ContactConstraint{T,N,Nc,Cs}, x::AbstractVector{T},
q::Quaternion{T}) where {T,N,Nc,Cs<:Contact{T,N}}
model = contact.model
return model.collision.contact_normal * (x + vector_rotate(model.collision.contact_origin, q)) - model.collision.contact_radius
end
function get_sdf(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, storage::Storage{T,N}) where {T,Nn,Ne,Nb,Ni,N}
d = []
for contact in mechanism.contacts
ibody = get_body(mechanism, contact.parent_id).id - Ne
push!(d, [get_sdf(contact, storage.x[ibody][i], storage.q[ibody][i]) for i = 1:N])
end
return d
end
"""
contact_location(contact, x, q)
location of contact point in world coordinates
contact: ContactConstraint
x: body position
q: body orientation
"""
function contact_location(contact::ContactConstraint{T,N,Nc,Cs}, x::AbstractVector{T},
q::Quaternion{T}) where {T,N,Nc,Cs<:Contact{T,N}}
model = contact.model
return x + vector_rotate(model.collision.contact_origin, q) - model.collision.contact_normal' * model.collision.contact_radius
end
function contact_location(contact::ContactConstraint{T,N,Nc,Cs},
body::Body) where {T,N,Nc,Cs<:Contact{T,N}}
x = body.state.x2
q = body.state.q2
return contact_location(contact, x, q)
end
function contact_location(mechanism::Mechanism, contact::ContactConstraint)
body = mechanism.bodies[findfirst(x -> x.id == contact.parent_id, mechanism.bodies)]
return contact_location(contact, body)
end
function contact_location(mechanism::Mechanism)
return [contact_location(mechanism, contact) for contact in mechanism.contacts]
end
#="""
string_location(contact, x, q)
location of the attach point of the string in world coordinates
collision: StringCollision
x: body position
q: body orientation
"""=#
function string_location(collision::StringCollision, x::AbstractVector{T},
q::Quaternion{T}; relative::Symbol=:parent) where T
origin = (relative == :parent) ? collision.origin_parent : collision.origin_child
return x + vector_rotate(origin, q)
end
function string_location(collision::StringCollision, body::Body; relative::Symbol=:parent)
x = body.state.x2
q = body.state.q2
return string_location(collision, x, q, relative=relative)
end
function string_location(mechanism::Mechanism, collision::StringCollision)
pbody = get_body(mechanism, contact.parent_id)
cbody = get_body(mechanism, contact.child_id)
x_parent = string_location(collision, pbody, relative=:parent)
x_child = string_location(collision, cbody, relative=:child)
return x_parent, x_child
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 6225 | # contact point velocity
function contact_point_velocity(model::Contact, x, q, v, ω, c)
return v + skew(vector_rotate(ω, q)) * (c - x)
end
function ∂contact_point_velocity∂x(model::Contact, x, q, v, ω, c)
return -skew(vector_rotate(ω, q))
end
function ∂contact_point_velocity∂q(model::Contact, x, q, v, ω, c)
return -skew(c - x) * ∂vector_rotate∂q(ω, q)
end
function ∂contact_point_velocity∂v(model::Contact, x, q, v, ω, c)
return 1.0 * sI(3)
end
function ∂contact_point_velocity∂ω(model::Contact, x, q, v, ω, c)
return -skew(c - x) * rotation_matrix(q)
end
function ∂contact_point_velocity∂c(model::Contact, x, q, v, ω, c)
return skew(vector_rotate(ω, q))
end
# relative tangential velocity
function relative_tangential_velocity(model::Contact, xp, qp, vp, ωp, xc, qc, vc, ωc)
# contact points
cp = contact_point(:parent, model.collision, xp, qp, xc, qc)
cc = contact_point(:child, model.collision, xp, qp, xc, qc)
# contact point velocities
vp = contact_point_velocity(model, xp, qp, vp, ωp, cp)
vc = contact_point_velocity(model, xc, qc, vc, ωc, cc)
# tangent projection
return contact_tangent(model.collision, xp, qp, xc, qc) * (vp - vc)
end
function ∂relative_tangential_velocity∂x(jacobian::Symbol, model::Contact, xp, qp, vp, ωp, xc, qc, vc, ωc)
# contact points
cp = contact_point(:parent, model.collision, xp, qp, xc, qc)
cc = contact_point(:child, model.collision, xp, qp, xc, qc)
# contact point velocities
vp = contact_point_velocity(model, xp, qp, vp, ωp, cp)
vc = contact_point_velocity(model, xc, qc, vc, ωc, cc)
Δv = vp - vc
# Jacobians
if jacobian == :parent
X = contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂x(model, xp, qp, vp, ωp, cp)
X += contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xp, qp, vp, ωp, cp) * ∂contact_point∂x(:parent, jacobian, model.collision, xp, qp, xc, qc)
X -= contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xc, qc, vc, ωc, cc) * ∂contact_point∂x(:child, jacobian, model.collision, xp, qp, xc, qc)
elseif jacobian == :child
X = contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xp, qp, vp, ωp, cp) * ∂contact_point∂x(:parent, jacobian, model.collision, xp, qp, xc, qc)
X -= contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂x(model, xc, qc, vc, ωc, cc)
X -= contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xc, qc, vc, ωc, cc) * ∂contact_point∂x(:child, jacobian, model.collision, xp, qp, xc, qc)
end
X += [
Δv' * ∂contact_tangent_one_transpose∂x(jacobian, model.collision, xp, qp, xc, qc);
Δv' * ∂contact_tangent_two_transpose∂x(jacobian, model.collision, xp, qp, xc, qc);
]
return X
end
function ∂relative_tangential_velocity∂q(jacobian::Symbol, model::Contact, xp, qp, vp, ωp, xc, qc, vc, ωc)
# contact points
cp = contact_point(:parent, model.collision, xp, qp, xc, qc)
cc = contact_point(:child, model.collision, xp, qp, xc, qc)
# contact point velocities
vp = contact_point_velocity(model, xp, qp, vp, ωp, cp)
vc = contact_point_velocity(model, xc, qc, vc, ωc, cc)
Δv = vp - vc
# Jacobians
if jacobian == :parent
X = contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂q(model, xp, qp, vp, ωp, cp)
X += contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xp, qp, vp, ωp, cp) * ∂contact_point∂q(:parent, jacobian, model.collision, xp, qp, xc, qc)
X -= contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xc, qc, vc, ωc, cc) * ∂contact_point∂q(:child, jacobian, model.collision, xp, qp, xc, qc)
elseif jacobian == :child
X = contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xp, qp, vp, ωp, cp) * ∂contact_point∂q(:parent, jacobian, model.collision, xp, qp, xc, qc)
X -= contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂q(model, xc, qc, vc, ωc, cc)
X -= contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂c(model, xc, qc, vc, ωc, cc) * ∂contact_point∂q(:child, jacobian, model.collision, xp, qp, xc, qc)
end
# X += ∂contact_tangent_jvp∂q(jacobian, model.collision, xp, qp, xc, qc, Δv)
X += [
Δv' * ∂contact_tangent_one_transpose∂q(jacobian, model.collision, xp, qp, xc, qc);
Δv' * ∂contact_tangent_two_transpose∂q(jacobian, model.collision, xp, qp, xc, qc);
]
return X
end
function ∂relative_tangential_velocity∂v(jacobian::Symbol, model::Contact, xp, qp, vp, ωp, xc, qc, vc, ωc)
# contact points
cp = contact_point(:parent, model.collision, xp, qp, xc, qc)
cc = contact_point(:child, model.collision, xp, qp, xc, qc)
# contact point velocities
vp = contact_point_velocity(model, xp, qp, vp, ωp, cp)
vc = contact_point_velocity(model, xc, qc, vc, ωc, cc)
# Δv = vp - vc
# Jacobians
if jacobian == :parent
X = contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂v(model, xp, qp, vp, ωp, cp)
elseif jacobian == :child
X = -1.0 * contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂v(model, xc, qc, vc, ωc, cc)
end
return X
end
function ∂relative_tangential_velocity∂ω(jacobian::Symbol, model::Contact, xp, qp, vp, ωp, xc, qc, vc, ωc)
# contact points
cp = contact_point(:parent, model.collision, xp, qp, xc, qc)
cc = contact_point(:child, model.collision, xp, qp, xc, qc)
# contact point velocities
vp = contact_point_velocity(model, xp, qp, vp, ωp, cp)
vc = contact_point_velocity(model, xc, qc, vc, ωc, cc)
# Δv = vp - vc
if jacobian == :parent
X = contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂ω(model, xp, qp, vp, ωp, cp)
elseif jacobian == :child
X = -1.0 * contact_tangent(model.collision, xp, qp, xc, qc) * ∂contact_point_velocity∂ω(model, xc, qc, vc, ωc, cc)
end
return X
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4044 | """
CapsuleCapsuleCollision
collision between two capsules
origin_parent: radius of contact for parent body
origin_child: radius of contact for child body
orientation_parent: radius of contact for parent body
orientation_child: radius of contact for child body
radius_parent: radius of contact for parent body
radius_child: radius of contact for child body
height_parent: radius of contact for parent body
height_child: radius of contact for child body
"""
mutable struct CapsuleCapsuleCollision{T,O,I,OI} <: Collision{T,O,I,OI}
origin_parent::SVector{I,T}
origin_child::SVector{I,T}
orientation_parent::Quaternion{T}
orientation_child::Quaternion{T}
radius_parent::T
radius_child::T
height_parent::T
height_child::T
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, collision::CapsuleCapsuleCollision)
# summary(io, collision)
# println(io, "")
# println(io, "origin_parent: "*string(collision.origin_parent))
# println(io, "origin_child: "*string(collision.origin_child))
# println(io, "orientation_parent: "*string(collision.orientation_parent))
# println(io, "orientation_child: "*string(collision.orientation_child))
# println(io, "radius_parent: "*string(collision.radius_parent))
# println(io, "radius_child: "*string(collision.radius_child))
# println(io, "height_parent: "*string(collision.height_parent))
# println(io, "height_child: "*string(collision.height_child))
# end
# distance
function distance(collision::CapsuleCapsuleCollision, xp, qp, xc, qc)
# contact points
pp = contact_point(:parent, collision, xp, qp, xc, qc)
pc = contact_point(:child, collision, xp, qp, xc, qc)
# difference
d = pp - pc
return norm(pp - pc, 2)
end
function ∂distance∂x(gradient::Symbol, collision::CapsuleCapsuleCollision, xp, qp, xc, qc)
# contact points
pp = contact_point(:parent, collision, xp, qp, xc, qc)
pc = contact_point(:child, collision, xp, qp, xc, qc)
# difference
d = pp - pc
X = ∂norm∂x(d) * (∂contact_point∂x(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂x(:child, jacobian, collision, xp, qp, xc, qc))
return X
end
function ∂distance∂q(gradient::Symbol, collision::CapsuleCapsuleCollision, xp, qp, xc, qc)
# contact points
pp = contact_point(:parent, collision, xp, qp, xc, qc)
pc = contact_point(:child, collision, xp, qp, xc, qc)
# difference
d = pp - pc
X = ∂norm∂x(d) * (∂contact_point∂q(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂q(:child, jacobian, collision, xp, qp, xc, qc))
return X
end
# contact point in world frame
function contact_point(relative::Symbol, collision::CapsuleCapsuleCollision, xp, qp, xc, qc)
# call mehrotra
if relative == :parent
return collision.ip.z[SA[1;2;3]]
elseif relative == :child
return collision.ip.z[SA[4;5;6]]
end
end
function ∂contact_point∂x(relative::Symbol, jacobian::Symbol, collision::CapsuleCapsuleCollision, xp, qp, xc, qc)
# call mehrotra
if relative == :parent
if jacobian == :parent
X = collision.ip.δz[]
elseif jacobian == :child
X = collision.ip.δz[]
end
elseif relative == :child
if jacobian == :parent
X = collision.ip.δz[]
elseif jacobian == :child
X = collision.ip.δz[]
end
end
return X
end
function ∂contact_point∂q(relative::Symbol, jacobian::Symbol, collision::CapsuleCapsuleCollision, xp, qp, xc, qc)
# call mehrotra
if relative == :parent
if jacobian == :parent
X = collision.ip.δz[]
elseif jacobian == :child
X = collision.ip.δz[]
end
elseif relative == :child
if jacobian == :parent
X = collision.ip.δz[]
elseif jacobian == :child
X = collision.ip.δz[]
end
end
return X
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 7288 | """
Collision
abstract type defining interaction between two bodies
"""
abstract type Collision{T,O,I,OI} end
# contact point origin
function contact_point_origin(x, q, k)
x + vector_rotate(k, q)
end
∂contact_point_origin∂x(x, q, k) = 1.0 * sI(3)
∂contact_point_origin∂q(x, q, k) = ∂vector_rotate∂q(k, q)
∂contact_point_origin∂k(x, q, k) = rotation_matrix(q)
"""
contact_normal(collision, xp, qp, xc, qc)
the contact normal (from child to parent) between two contact points
collision: Collision
xp: parent body position
qp: parent body orientation
xc: child body position
qc: child body orientation
"""
function contact_normal(collision::Collision, xp, qp, xc, qc)
# contact points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
# distance
dis = distance(collision, xp, qp, xc, qc)
# normalized direction
if dis >= 0.0
return normalize(dir)'
else
return -1.0 * normalize(dir)'
end
end
function ∂contact_normal_transpose∂x(jacobian::Symbol, collision::Collision, xp, qp, xc, qc)
# contact origin points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
# Jacobians
X = ∂normalize∂x(dir) * (∂contact_point∂x(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂x(:child, jacobian, collision, xp, qp, xc, qc))
# distance
dis = distance(collision, xp, qp, xc, qc)
# normalized direction
if dis >= 0.0
return X
else
return -1.0 * X
end
end
function ∂contact_normal_transpose∂q(jacobian::Symbol, collision::Collision, xp, qp, xc, qc)
# contact origin points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
Q = ∂normalize∂x(dir) * (∂contact_point∂q(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂q(:child, jacobian, collision, xp, qp, xc, qc))
# Jacobians
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_normal(collision, xp, Quaternion(q...), xc, qc)', vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_normal(collision, xp, qp, xc, Quaternion(q...))', vector(qc))
# end
# distance
dis = distance(collision, xp, qp, xc, qc)
# @assert norm((dis >= 0.0 ? 1.0 : -1.0) * Q - FD, Inf) < 1.0e-2
# normalized direction
if dis >= 0.0
return Q
else
return -1.0 * Q
end
end
function contact_tangent_one(collision::Collision, xp, qp, xc, qc)
# normal
n = contact_normal(collision, xp, qp, xc, qc)
# tangents
w = [1.0; 0.0; 0.0]
t1 = skew(w) * n' # tangent
if !(norm(t1) > 1.0e-6)
# @warn "edge case!"
w = [0.0; 1.0; 0.0]
t1 = skew(w) * n' # tangent
end
return t1'
end
function contact_tangent_two(collision::Collision, xp, qp, xc, qc)
# normal
n = contact_normal(collision, xp, qp, xc, qc)
# tangent one
t1 = contact_tangent_one(collision, xp, qp, xc, qc)
# tangent two
t2 = skew(t1') * n'
return t2'
end
"""
contact_tangent(collision, xp, qp, xc, qc)
contact tangents between two contact points
collision: Collision
xp: parent body position
qp: parent body orientation
xc: child body position
qc: child body orientation
"""
function contact_tangent(collision::Collision, xp, qp, xc, qc)
[
contact_tangent_one(collision, xp, qp, xc, qc);
contact_tangent_two(collision, xp, qp, xc, qc);
]
end
function ∂contact_tangent_one_transpose∂x(jacobian::Symbol, collision::Collision, xp, qp, xc, qc)
# normal
n = contact_normal(collision, xp, qp, xc, qc)
# tangents
w = [1.0; 0.0; 0.0] # candidate
t1 = skew(w) * n' # tangent
if !(norm(t1) > 1.0e-5)
w = [0.0; 1.0; 0.0] # candidate
t1 = skew(w) * n' # tangent
end
∂t1∂x = skew(w) * ∂contact_normal_transpose∂x(jacobian, collision, xp, qp, xc, qc)
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_tangent(collision, x, qp, xc, qc)[1, :]', xp)
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_tangent(collision, xp, qp, x, qc)[1, :]', xc)
# end
# @assert norm(FD - ∂t1∂x, Inf) < 1.0e-2
return ∂t1∂x
end
function ∂contact_tangent_two_transpose∂x(jacobian::Symbol, collision::Collision, xp, qp, xc, qc)
# normal
n = contact_normal(collision, xp, qp, xc, qc)
t1 = contact_tangent_one(collision, xp, qp, xc, qc)
∂t1∂x = ∂contact_tangent_one_transpose∂x(jacobian, collision, xp, qp, xc, qc)
∂t2∂x = skew(t1') * ∂contact_normal_transpose∂x(jacobian, collision, xp, qp, xc, qc) + ∂skew∂p(n') * ∂t1∂x
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_tangent(collision, x, qp, xc, qc)[2, :]', xp)
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_tangent(collision, xp, qp, x, qc)[2, :]', xc)
# end
# @assert norm(FD - ∂t2∂x, Inf) < 1.0e-2
return ∂t2∂x
end
function ∂contact_tangent_one_transpose∂q(jacobian::Symbol, collision::Collision, xp, qp, xc, qc)
# normal
n = contact_normal(collision, xp, qp, xc, qc)
# tangents
w = [1.0; 0.0; 0.0] # candidate
t1 = skew(w) * n' # tangent
if !(norm(t1) > 1.0e-5)
w = [0.0; 1.0; 0.0] # candidate
t1 = skew(w) * n' # tangent
end
∂t1∂q = skew(t1) * ∂contact_normal_transpose∂q(jacobian, collision, xp, qp, xc, qc)
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_tangent(collision, xp, Quaternion(q...), xc, qc)[1, :]', vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_tangent(collision, xp, qp, xc, Quaternion(q...))[1, :]', vector(qc))
# end
# return FD
# @assert norm(FD - ∂t1∂q, Inf) < 1.0e-2
return ∂t1∂q
end
function ∂contact_tangent_two_transpose∂q(jacobian::Symbol, collision::Collision, xp, qp, xc, qc)
# normal
n = contact_normal(collision, xp, qp, xc, qc)
# tangents
w = [1.0; 0.0; 0.0] # candidate
t1 = skew(w) * n' # tangent
if !(norm(t1) > 1.0e-5)
w = [0.0; 1.0; 0.0] # candidate
t1 = skew(w) * n' # tangent
end
t2 = skew(t1) * n' # tangent
∂t1∂q = skew(w) * ∂contact_normal_transpose∂q(jacobian, collision, xp, qp, xc, qc)
∂t2∂q = skew(t1) * ∂contact_normal_transpose∂q(jacobian, collision, xp, qp, xc, qc) + ∂skew∂p(n') * ∂t1∂q
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_tangent(collision, xp, Quaternion(q...), xc, qc)[2, :]', vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_tangent(collision, xp, qp, xc, Quaternion(q...))[2, :]', vector(qc))
# end
# @assert norm(FD - ∂t2∂q, Inf) < 1.0e-2
return ∂t2∂q
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4913 | function contact_point_box(ps, xc, qc, kx, ky, kz)
# corner kinematics
cx = contact_point_origin(szeros(3), qc, kx)
cy = contact_point_origin(szeros(3), qc, ky)
cz = contact_point_origin(szeros(3), qc, kz)
v1 = 2.0 * cx
v2 = 2.0 * cy
v3 = 2.0 * cz
# origin is opposite corner
origin = xc - cx - cy - cz
@show tx = dot(ps - origin, v1) / dot(v1, v1)
@show ty = dot(ps - origin, v2) / dot(v2, v2)
@show tz = dot(ps - origin, v3) / dot(v3, v3)
coc = origin
if tx >= 1.0
coc += v1
elseif tx < 0.0
nothing
else
coc += tx * v1
end
if ty >= 1.0
coc += v2
elseif ty < 0.0
nothing
else
coc += ty * v2
end
if tz >= 1.0
coc += v3
elseif tz < 0.0
nothing
else
coc += tz * v3
end
return coc
end
function ∂contact_point_box∂p(ps, xc, qc, kx, ky, kz)
cx = contact_point_origin(szeros(3), qc, kx)
cy = contact_point_origin(szeros(3), qc, ky)
cz = contact_point_origin(szeros(3), qc, kz)
v1 = 2.0 * cx
v2 = 2.0 * cy
v3 = 2.0 * cz
origin = xc - cx - cy - cz
tx = dot(ps - origin, v1) / dot(v1, v1)
ty = dot(ps - origin, v2) / dot(v2, v2)
tz = dot(ps - origin, v3) / dot(v3, v3)
P = szeros(3, 3)
if tx >= 1.0
# coc += v1
# X +=
elseif tx < 0.0
# nothing
# X +=
else
# coc += tx * v1
P += v1 * 1.0 / dot(v1, v1) * v1'
end
if ty >= 1.0
# coc += v2
elseif ty < 0.0
# nothing
else
# coc += ty * v2
P += v2 * 1.0 / dot(v2, v2) * v2'
end
if tz >= 1.0
# coc += v3
elseif tz < 0.0
# nothing
else
# coc += tz * v3
P += v3 * 1.0 / dot(v3, v3) * v3'
end
return P
# FiniteDiff.finite_difference_jacobian(p -> contact_point_box(p, xc, qc, kx, ky, kz), ps)
end
function ∂contact_point_box∂x(ps, xc, qc, kx, ky, kz)
cx = contact_point_origin(szeros(3), qc, kx)
cy = contact_point_origin(szeros(3), qc, ky)
cz = contact_point_origin(szeros(3), qc, kz)
v1 = 2.0 * cx
v2 = 2.0 * cy
v3 = 2.0 * cz
origin = xc - cx - cy - cz
tx = dot(ps - origin, v1) / dot(v1, v1)
ty = dot(ps - origin, v2) / dot(v2, v2)
tz = dot(ps - origin, v3) / dot(v3, v3)
X = 1.0 * sI(3)
if tx >= 1.0
# coc += v1
elseif tx < 0.0
# nothing
else
# coc += tx * v1
X += v1 * 1.0 / dot(v1, v1) * v1' * -1.0
end
if ty >= 1.0
# coc += v2
elseif ty < 0.0
# nothing
else
# coc += ty * v2
X += v2 * 1.0 / dot(v2, v2) * v2' * -1.0
end
if tz > 1.0
# coc += v3
elseif tz < 0.0
# nothing
else
# coc += tz * v3
X += v3 * 1.0 / dot(v3, v3) * v3' * -1.0
end
return X
# FiniteDiff.finite_difference_jacobian(x -> contact_point_box(ps, x, qc, kx, ky, kz), xc)
end
function ∂contact_point_box∂q(ps, xc, qc, kx, ky, kz)
cx = contact_point_origin(szeros(3), qc, kx)
cy = contact_point_origin(szeros(3), qc, ky)
cz = contact_point_origin(szeros(3), qc, kz)
v1 = 2.0 * cx
v2 = 2.0 * cy
v3 = 2.0 * cz
∂v1∂q = 2.0 * ∂contact_point_origin∂q(szeros(3), qc, kx)
∂v2∂q = 2.0 * ∂contact_point_origin∂q(szeros(3), qc, ky)
∂v3∂q = 2.0 * ∂contact_point_origin∂q(szeros(3), qc, kz)
origin = xc - cx - cy - cz
tx = dot(ps - origin, v1) / dot(v1, v1)
ty = dot(ps - origin, v2) / dot(v2, v2)
tz = dot(ps - origin, v3) / dot(v3, v3)
Q = -0.5 * (∂v1∂q + ∂v2∂q + ∂v3∂q)
if tx >= 1.0
# coc += v1
Q += ∂v1∂q
elseif tx < 0.0
# nothing
else
# coc += tx * v1
Q += tx * ∂v1∂q
Q += v1 * (ps - xc)' ./ dot(v1, v1) * ∂v1∂q
Q += v1 * -1.0 * dot(ps - xc, v1) ./ dot(v1, v1)^2 * 2.0 * v1' * ∂v1∂q
Q += v1 * 1.0 / dot(v1, v1) * v1' * -0.5 * ∂v1∂q
end
if ty >= 1.0
# coc += v2
Q += ∂v2∂q
elseif ty < 0.0
# nothing
else
# coc += ty * v2
Q += tx * ∂v2∂q
Q += v2 * (ps - xc)' ./ dot(v2, v2) * ∂v2∂q
Q += v2 * -1.0 * dot(ps - xc, v2) ./ dot(v2, v2)^2 * 2.0 * v2' * ∂v2∂q
Q += v2 * 1.0 / dot(v2, v2) * v2' * -0.5 * ∂v2∂q
end
if tz >= 1.0
# coc += v3
Q += ∂v3∂q
elseif tz < 0.0
# nothing
else
# coc += tz * v3
Q += tx * ∂v3∂q
Q += v3 * (ps - xc)' ./ dot(v3, v3) * ∂v3∂q
Q += v3 * -1.0 * dot(ps - xc, v3) ./ dot(v3, v3)^2 * 2.0 * v3' * ∂v3∂q
Q += v3 * 1.0 / dot(v3, v3) * v3' * -0.5 * ∂v3∂q
end
return Q
# FiniteDiff.finite_difference_jacobian(q -> contact_point_box(ps, xc, Quaternion(q...), kx, ky, kz), vector(qc))
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1184 | function klamp(t, a, b)
if t <= a
return a
elseif b <= t
return b
else
da = abs(t - a)
db = abs(t - b)
if da < db
return a
else
return b
end
# return t
end
end
function contact_point_box(ps, xc, qc, kx, ky, kz)
# rotate point into box frame
ps_box_frame = vector_rotate(ps - xc, inv(qc))
# find box point in box frame
px = clamp(ps_box_frame[1], -0.5 * kx, 0.5 * kx)
py = clamp(ps_box_frame[2], -0.5 * ky, 0.5 * ky)
pz = clamp(ps_box_frame[3], -0.5 * kz, 0.5 * kz)
# box point in world frame
return vector_rotate([px; py; pz], qc) + xc
end
function ∂contact_point_box∂p(ps, xc, qc, kx, ky, kz)
FiniteDiff.finite_difference_jacobian(p -> contact_point_box(p, xc, qc, kx, ky, kz), ps)
end
function ∂contact_point_box∂x(ps, xc, qc, kx, ky, kz)
FiniteDiff.finite_difference_jacobian(x -> contact_point_box(ps, x, qc, kx, ky, kz), xc)
end
function ∂contact_point_box∂q(ps, xc, qc, kx, ky, kz)
FiniteDiff.finite_difference_jacobian(q -> contact_point_box(ps, xc, Quaternion(q...), kx, ky, kz), vector(qc))
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3454 | # capsule contact point origin sphere-capsule
function contact_point_segment(ps, xc, qc, ka, kb)
# capsule origin a
ca = contact_point_origin(xc, qc, ka)
# capsule origin b
cb = contact_point_origin(xc, qc, kb)
# point differences
dab = cb - ca
das = ps - ca
t = dot(das, dab) / dot(dab, dab)
# t_clamp = min(max(t, 0.0), 1.0)
# closest point
if t <= 0.0
p = ca
elseif t >= 1.0
p = cb
else
p = ca + t * dab
end
return p
end
# capsule contact point origin sphere-capsule
function ∂contact_point_segment∂p(ps, xc, qc, ka, kb)
# capsule origin a
ca = contact_point_origin(xc, qc, ka)
# capsule origin b
cb = contact_point_origin(xc, qc, kb)
# point differences
dab = cb - ca
das = ps - ca
t = dot(das, dab) ./ dot(dab, dab)
# t_clamp = min(max(t, 0.0), 1.0)
# closest point
if t <= 0.0
# p = ca
return szeros(3, 3)
elseif t >= 1.0
# p = cb
return szeros(3, 3)
else
# p = ca + t * dab
return dab * dab' ./ dot(dab, dab)
end
return p
end
# capsule contact point origin sphere-capsule
function ∂contact_point_segment∂x(ps, xc, qc, ka, kb)
# capsule origin a
ca = contact_point_origin(xc, qc, ka)
# capsule origin b
cb = contact_point_origin(xc, qc, kb)
# point differences
dab = cb - ca
das = ps - ca
t = dot(das, dab) ./ dot(dab, dab)
# t_clamp = min(max(t, 0.0), 1.0)
# closest point
if t <= 0.0
# p = ca
return ∂contact_point_origin∂x(xc, qc, ka)
elseif t >= 1.0
# p = cb
return ∂contact_point_origin∂x(xc, qc, kb)
else
# p = ca + t * dab
X = ∂contact_point_origin∂x(xc, qc, ka)
X += t * (∂contact_point_origin∂x(xc, qc, kb) - ∂contact_point_origin∂x(xc, qc, ka))
t1 = 1.0 / (dab' * dab) * dab' * (-∂contact_point_origin∂x(xc, qc, ka))
t2 = 1.0 / (dab' * dab) * das' * (∂contact_point_origin∂x(xc, qc, kb) - ∂contact_point_origin∂x(xc, qc, ka))
t3 = -2.0 * das' * dab / (dab' * dab)^2 * dab' * (∂contact_point_origin∂x(xc, qc, kb) - ∂contact_point_origin∂x(xc, qc, ka))
X += dab * (t1 + t2 + t3)
return X
end
end
# capsule contact point origin sphere-capsule
function ∂contact_point_segment∂q(ps, xc, qc, ka, kb)
# capsule origin a
ca = contact_point_origin(xc, qc, ka)
# capsule origin b
cb = contact_point_origin(xc, qc, kb)
# point differences
dab = cb - ca
das = ps - ca
t = dot(das, dab) ./ dot(dab, dab)
# t_clamp = min(max(t, 0.0), 1.0)
# closest point
if t <= 0.0
# p = ca
return ∂contact_point_origin∂q(xc, qc, ka)
elseif t >= 1.0
# p = cb
return ∂contact_point_origin∂q(xc, qc, kb)
else
# p = ca + t * dab
Q = ∂contact_point_origin∂q(xc, qc, ka)
Q += t * (∂contact_point_origin∂q(xc, qc, kb) - ∂contact_point_origin∂q(xc, qc, ka))
t1 = 1.0 / (dab' * dab) * dab' * (-∂contact_point_origin∂q(xc, qc, ka))
t2 = 1.0 / (dab' * dab) * das' * (∂contact_point_origin∂q(xc, qc, kb) - ∂contact_point_origin∂q(xc, qc, ka))
t3 = -2.0 * das' * dab ./ (dab' * dab)^2 * dab' * (∂contact_point_origin∂q(xc, qc, kb) - ∂contact_point_origin∂q(xc, qc, ka))
Q += dab * (t1 + t2 + t3)
return Q
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 9515 | """
SphereBoxCollision
collision between sphere and box
origin_sphere: position of sphere contact relative to body center of mass
origin_box_a: position of box corner contact a relative to body center of mass
origin_box_b: position of box corner contact b relative to body center of mass
radius_sphere: radius of sphere contact
"""
mutable struct SphereBoxCollision{T,O,I,OI} <: Collision{T,O,I,OI}
origin_sphere::SVector{I,T}
width::T
depth::T
height::T
radius_sphere::T
end
# distance
function distance(collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_box(cop, xc, qc, collision.width, collision.depth, collision.height)
# distance between contact origins
d = norm(cop - coc, 2)
# minimum distance between spheres
return d - collision.radius_sphere
end
function ∂distance∂x(gradient::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_box(cop, xc, qc, collision.width, collision.depth, collision.height)
# distance between contact origins
d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = ∂norm∂d * (1.0 * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere) - ∂contact_point_box∂p(cop, xc, qc, collision.width, collision.depth, collision.height) * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere))
elseif gradient == :child
D = ∂norm∂d * -1.0 * ∂contact_point_box∂x(cop, xc, qc, collision.width, collision.depth, collision.height)
end
# if gradient == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, x, qp, xc, qc), xp)
# elseif gradient == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, xp, qp, x, qc), xc)
# end
# return FD
# @assert norm(D - FD, Inf) < 1.0e-5
return D
end
function ∂distance∂q(gradient::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_box(cop, xc, qc, collision.width, collision.depth, collision.height)
# distance between contact origins
d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = ∂norm∂d * (1.0 * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere) - ∂contact_point_box∂p(cop, xc, qc, collision.width, collision.depth, collision.height) * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere))
elseif gradient == :child
D = ∂norm∂d * -1.0 * ∂contact_point_box∂q(cop, xc, qc, collision.width, collision.depth, collision.height)
end
# if gradient == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, Quaternion(q...), xc, qc), vector(qp))
# elseif gradient == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, qp, xc, Quaternion(q...)), vector(qc))
# end
# return FD
# @assert norm(D - FD, Inf) < 1.0e-5
return D
end
# contact point in world frame
function contact_point(relative::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_box(cop, xc, qc, collision.width, collision.depth, collision.height)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
# contact point
if relative == :parent
return cop - collision.radius_sphere * dir
elseif relative == :child
return coc
end
end
function ∂contact_point∂x(relative::Symbol, jacobian::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_box(cop, xc, qc, collision.width, collision.depth, collision.height)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
if relative == :parent
# cop - collision.radius_sphere * dir
if jacobian == :parent
∂c∂x = ∂contact_point_origin∂x(xp, qp, collision.origin_sphere)
X = ∂c∂x
X -= collision.radius_sphere * ∂normalize∂x(d) * (∂c∂x - ∂contact_point_box∂p(cop, xc, qc, collision.width, collision.depth, collision.height) * ∂c∂x)
elseif jacobian == :child
X = -1.0 * collision.radius_sphere * ∂normalize∂x(d) * -1.0 * ∂contact_point_box∂x(cop, xc, qc, collision.width, collision.depth, collision.height)
end
elseif relative == :child
# coc
if jacobian == :parent
X = ∂contact_point_box∂p(cop, xc, qc, collision.width, collision.depth, collision.height) * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere)
elseif jacobian == :child
X = ∂contact_point_box∂x(cop, xc, qc, collision.width, collision.depth, collision.height)
end
end
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, x, qp, xc, qc), xp)
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, xp, qp, x, qc), xc)
# end
# return FD
# @assert norm(X - FD, Inf) < 1.0e-5
return X
end
function ∂contact_point∂q(relative::Symbol, jacobian::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_box(cop, xc, qc, collision.width, collision.depth, collision.height)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
if relative == :parent
# cop - collision.radius_sphere * dir
if jacobian == :parent
∂c∂q = ∂contact_point_origin∂q(xp, qp, collision.origin_sphere)
Q = ∂c∂q
Q -= collision.radius_sphere * ∂normalize∂x(d) * (∂c∂q - ∂contact_point_box∂p(cop, xc, qc, collision.width, collision.depth, collision.height) * ∂c∂q)
elseif jacobian == :child
Q = -1.0 * collision.radius_sphere * ∂normalize∂x(d) * -1.0 * ∂contact_point_box∂q(cop, xc, qc, collision.width, collision.depth, collision.height)
end
elseif relative == :child
# coc
if jacobian == :parent
Q = ∂contact_point_box∂p(cop, xc, qc, collision.width, collision.depth, collision.height) * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere)
elseif jacobian == :child
Q = ∂contact_point_box∂q(cop, xc, qc, collision.width, collision.depth, collision.height)
end
end
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, Quaternion(q...), xc, qc), vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, qp, xc, Quaternion(q...)), vector(qc))
# end
# return FD
# @assert norm(Q - FD, Inf) < 1.0e-5
return Q
end
function contact_normal(collision::SphereBoxCollision, xp, qp, xc, qc)
# contact points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
# distance
dis = distance(collision, xp, qp, xc, qc)
# normalized direction
if dis >= 0.0
return normalize(dir)'
else
return -1.0 * normalize(dir)'
end
end
function ∂contact_normal_transpose∂x(jacobian::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
# Jacobians
X = ∂normalize∂x(dir) * (∂contact_point∂x(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂x(:child, jacobian, collision, xp, qp, xc, qc))
# distance
dis = distance(collision, xp, qp, xc, qc)
# normalized direction
if dis >= 0.0
return X
else
return -1.0 * X
end
end
function ∂contact_normal_transpose∂q(jacobian::Symbol, collision::SphereBoxCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
Q = ∂normalize∂x(dir) * (∂contact_point∂q(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂q(:child, jacobian, collision, xp, qp, xc, qc))
# Jacobians
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_normal(collision, xp, Quaternion(q...), xc, qc)', vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_normal(collision, xp, qp, xc, Quaternion(q...))', vector(qc))
# end
# distance
dis = distance(collision, xp, qp, xc, qc)
# @assert norm((dis >= 0.0 ? 1.0 : -1.0) * Q - FD, Inf) < 1.0e-2
# normalized direction
if dis >= 0.0
return Q
else
return -1.0 * Q
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 8645 | """
SphereCapsuleCollision
collision between sphere and capsule
origin_sphere: position of sphere contact relative to body center of mass
origin_capsule_a: position of capsule contact a relative to body center of mass
origin_capsule_b: position of capsule contact b relative to body center of mass
radius_sphere: radius of sphere contact
radius_capsule: radius of capsule contact
"""
mutable struct SphereCapsuleCollision{T,O,I,OI} <: Collision{T,O,I,OI}
origin_sphere::SVector{I,T}
origin_capsule_a::SVector{I,T}
origin_capsule_b::SVector{I,T}
radius_sphere::T
radius_capsule::T
end
# distance
function distance(collision::SphereCapsuleCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_segment(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
# distance between contact origins
d = norm(cop - coc, 2)
# minimum distance between spheres
return d - (collision.radius_sphere + collision.radius_capsule)
end
function ∂distance∂x(gradient::Symbol, collision::SphereCapsuleCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_segment(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
# distance between contact origins
d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = ∂norm∂d * (1.0 * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere) - ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere))
elseif gradient == :child
D = ∂norm∂d * -1.0 * ∂contact_point_segment∂x(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
end
# if gradient == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, x, qp, xc, qc), xp)
# elseif gradient == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, xp, qp, x, qc), xc)
# end
# return FD
# @assert norm(D - FD, Inf) < 1.0e-5
return D
end
function ∂distance∂q(gradient::Symbol, collision::SphereCapsuleCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_segment(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
# distance between contact origins
d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = ∂norm∂d * (1.0 * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere) - ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere))
elseif gradient == :child
D = ∂norm∂d * -1.0 * ∂contact_point_segment∂q(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
end
# if gradient == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, Quaternion(q...), xc, qc), vector(qp))
# elseif gradient == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, qp, xc, Quaternion(q...)), vector(qc))
# end
# return FD
# @assert norm(D - FD, Inf) < 1.0e-5
return D
end
# contact point in world frame
function contact_point(relative::Symbol, collision::SphereCapsuleCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_segment(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
# contact point
if relative == :parent
return cop - collision.radius_sphere * dir
elseif relative == :child
return coc + collision.radius_capsule * dir
end
end
function ∂contact_point∂x(relative::Symbol, jacobian::Symbol, collision::SphereCapsuleCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_segment(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
if relative == :parent
# cop - collision.radius_sphere * dir
if jacobian == :parent
∂c∂x = ∂contact_point_origin∂x(xp, qp, collision.origin_sphere)
X = ∂c∂x
X -= collision.radius_sphere * ∂normalize∂x(d) * (∂c∂x - ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂c∂x)
elseif jacobian == :child
X = -1.0 * collision.radius_sphere * ∂normalize∂x(d) * -1.0 * ∂contact_point_segment∂x(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
end
elseif relative == :child
# coc + collision.radius_capsule * dir
if jacobian == :parent
X = ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere)
X += 1.0 * collision.radius_capsule * ∂normalize∂x(d) * (∂contact_point_origin∂x(xp, qp, collision.origin_sphere) - ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂contact_point_origin∂x(xp, qp, collision.origin_sphere))
elseif jacobian == :child
X = ∂contact_point_segment∂x(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
X += collision.radius_capsule * ∂normalize∂x(d) * (-∂contact_point_segment∂x(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b))
end
end
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, x, qp, xc, qc), xp)
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, xp, qp, x, qc), xc)
# end
# return FD
# @assert norm(X - FD, Inf) < 1.0e-5
return X
end
function ∂contact_point∂q(relative::Symbol, jacobian::Symbol, collision::SphereCapsuleCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_sphere)
coc = contact_point_segment(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
if relative == :parent
# cop - collision.radius_sphere * dir
if jacobian == :parent
∂c∂q = ∂contact_point_origin∂q(xp, qp, collision.origin_sphere)
Q = ∂c∂q
Q -= collision.radius_sphere * ∂normalize∂x(d) * (∂c∂q - ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂c∂q)
elseif jacobian == :child
Q = -1.0 * collision.radius_sphere * ∂normalize∂x(d) * -1.0 * ∂contact_point_segment∂q(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
end
elseif relative == :child
# coc + collision.radius_capsule * dir
if jacobian == :parent
Q = ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere)
Q += 1.0 * collision.radius_capsule * ∂normalize∂x(d) * (∂contact_point_origin∂q(xp, qp, collision.origin_sphere) - ∂contact_point_segment∂p(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b) * ∂contact_point_origin∂q(xp, qp, collision.origin_sphere))
elseif jacobian == :child
Q = ∂contact_point_segment∂q(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b)
Q += collision.radius_capsule * ∂normalize∂x(d) * (-∂contact_point_segment∂q(cop, xc, qc, collision.origin_capsule_a, collision.origin_capsule_b))
end
end
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, Quaternion(q...), xc, qc), vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, qp, xc, Quaternion(q...)), vector(qc))
# end
# return FD
# @assert norm(Q - FD, Inf) < 1.0e-5
return Q
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 5065 | """
SphereHalfSpaceCollision
collision between a spherical contact and a flat surface
contact_tangent: mapping from world frame to surface tangent frame
contact_normal: inverse/complement of contact_tangent
contact_origin: position of contact on Body relative to center of mass
contact_radius: radius of contact
"""
mutable struct SphereHalfSpaceCollision{T,O,I,OI} <: Collision{T,O,I,OI}
contact_tangent::SMatrix{O,I,T,OI}
contact_normal::Adjoint{T,SVector{I,T}}
contact_origin::SVector{I,T}
contact_radius::T
function SphereHalfSpaceCollision(contact_tangent::SMatrix{O,I,T0,OI}, contact_normal, contact_origin, contact_radius) where {O,I,T0,OI}
T = promote_type(eltype.((contact_tangent, contact_normal, contact_origin, contact_radius))...)
new{T,O,I,OI}(contact_tangent, contact_normal, contact_origin, contact_radius)
end
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, collision::SphereHalfSpaceCollision)
# summary(io, collision)
# println(io, "")
# println(io, "contact_tangent: "*string(collision.contact_tangent))
# println(io, "contact_normal: "*string(collision.contact_normal))
# println(io, "contact_origin: "*string(collision.contact_origin))
# println(io, "contact_radius: "*string(collision.contact_radius))
# end
# distance
function distance(collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
collision.contact_normal * (xp + vector_rotate(collision.contact_origin, qp)) - collision.contact_radius
end
function ∂distance∂x(gradient::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
if gradient == :parent
return collision.contact_normal
elseif gradient == :child
return szeros(eltype(xc), 1, 3)
end
end
function ∂distance∂q(gradient::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
if gradient == :parent
return collision.contact_normal * ∂vector_rotate∂q(collision.contact_origin, qp)
elseif gradient == :child
return szeros(eltype(qc), 1, 4)
end
end
# contact point in world frame
function contact_point(relative::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
if relative == :parent
return xp + vector_rotate(collision.contact_origin, qp) - collision.contact_normal' * collision.contact_radius
elseif relative == :child
projector = collision.contact_tangent' * collision.contact_tangent
return projector * (xp + vector_rotate(collision.contact_origin, qp))
end
end
function ∂contact_point∂x(relative::Symbol, jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
if relative == :parent
if jacobian == :parent
return 1.0 * sI(3)
elseif jacobian == :child
return szeros(eltype(xp), 3, 3)
end
elseif relative == :child
if jacobian == :parent
projector = collision.contact_tangent' * collision.contact_tangent
return projector
elseif jacobian == :child
return szeros(eltype(xp), 3, 3)
end
end
end
function ∂contact_point∂q(relative::Symbol, jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
if relative == :parent
if jacobian == :parent
return ∂vector_rotate∂q(collision.contact_origin, qp)
end
elseif relative == :child
if jacobian == :parent
projector = collision.contact_tangent' * collision.contact_tangent
return projector * ∂vector_rotate∂q(collision.contact_origin, qp)
elseif jacobian == :child
return szeros(eltype(qp), 3, 4)
end
end
end
# normal projection (from child to parent)
function contact_normal(collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return collision.contact_normal
end
function ∂contact_normal_transpose∂x(jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return szeros(eltype(collision.contact_normal), 3, 3)
end
function ∂contact_normal_transpose∂q(jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return szeros(eltype(collision.contact_normal), 3, 4)
end
# tangent projection
function contact_tangent(collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return collision.contact_tangent # {2,4} x 3
end
function ∂contact_tangent_one_transpose∂x(jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return szeros(eltype(collision.contact_tangent), 3, 3)
end
function ∂contact_tangent_two_transpose∂x(jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return szeros(eltype(collision.contact_tangent), 3, 3)
end
function ∂contact_tangent_one_transpose∂q(jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return szeros(eltype(collision.contact_tangent), 3, 4)
end
function ∂contact_tangent_two_transpose∂q(jacobian::Symbol, collision::SphereHalfSpaceCollision, xp, qp, xc, qc)
return szeros(eltype(collision.contact_tangent), 3, 4)
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 7128 | """
SphereSphereCollision
collision between two spheres
origin_parent: position of contact on parent body relative to center of mass
origin_child: position of contact on parent body relative to center of mass
radius_parent: radius of contact for parent body
radius_child: radius of contact for child body
"""
mutable struct SphereSphereCollision{T,O,I,OI} <: Collision{T,O,I,OI}
origin_parent::SVector{I,T}
origin_child::SVector{I,T}
radius_parent::T
radius_child::T
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, collision::SphereSphereCollision)
# summary(io, collision)
# println(io, "")
# println(io, "origin_parent: "*string(collision.origin_parent))
# println(io, "origin_child: "*string(collision.origin_child))
# println(io, "radius_parent: "*string(collision.radius_parent))
# println(io, "radius_child: "*string(collision.radius_child))
# end
# distance
function distance(collision::SphereSphereCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# distance between contact origins
d = norm(cop - coc, 2)
# minimum distance between spheres
return d - (collision.radius_parent + collision.radius_child)
end
function ∂distance∂x(gradient::Symbol, collision::SphereSphereCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# distance between contact origins
d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = ∂norm∂d * 1.0 * ∂contact_point_origin∂x(xp, qp, collision.origin_parent)
elseif gradient == :child
D = ∂norm∂d * -1.0 * ∂contact_point_origin∂x(xc, qc, collision.origin_child)
end
if gradient == :parent
FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, x, qp, xc, qc), xp)
elseif gradient == :child
FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, xp, qp, x, qc), xc)
end
return FD
# @assert norm(D - FD, Inf) < 1.0e-5
return D
end
function ∂distance∂q(gradient::Symbol, collision::SphereSphereCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# distance between contact origins
d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = ∂norm∂d * 1.0 * ∂contact_point_origin∂q(xp, qp, collision.origin_parent)
elseif gradient == :child
D = ∂norm∂d * -1.0 * ∂contact_point_origin∂q(xc, qc, collision.origin_child)
end
if gradient == :parent
FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, Quaternion(q...), xc, qc), vector(qp))
elseif gradient == :child
FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, qp, xc, Quaternion(q...)), vector(qc))
end
return FD
# @assert norm(D - FD, Inf) < 1.0e-5
return D
end
# contact point in world frame
function contact_point(relative::Symbol, collision::SphereSphereCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
# contact point
if relative == :parent
return cop - collision.radius_parent * dir
elseif relative == :child
return coc + collision.radius_child * dir
end
end
function ∂contact_point∂x(relative::Symbol, jacobian::Symbol, collision::SphereSphereCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
if relative == :parent
# cop - collision.radius_parent * dir
if jacobian == :parent
∂c∂x = ∂contact_point_origin∂x(xp, qp, collision.origin_parent)
X = ∂c∂x
X -= collision.radius_parent * ∂normalize∂x(d) * ∂c∂x
elseif jacobian == :child
X = -1.0 * collision.radius_parent * ∂normalize∂x(d) * -1.0 * ∂contact_point_origin∂x(xc, qc, collision.origin_child)
end
elseif relative == :child
# coc + collision.radius_child * dir
if jacobian == :parent
X = 1.0 * collision.radius_child * ∂normalize∂x(d) * ∂contact_point_origin∂x(xp, qp, collision.origin_parent)
elseif jacobian == :child
∂c∂x = ∂contact_point_origin∂x(xc, qc, collision.origin_child)
X = ∂c∂x
X += collision.radius_child * ∂normalize∂x(d) * -1.0 * ∂c∂x
end
end
if jacobian == :parent
FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, x, qp, xc, qc), xp)
elseif jacobian == :child
FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, xp, qp, x, qc), xc)
end
return FD
# @assert norm(X - FD, Inf) < 1.0e-5
return X
end
function ∂contact_point∂q(relative::Symbol, jacobian::Symbol, collision::SphereSphereCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# direction of minimum distance (child to parent)
d = cop - coc
dir = normalize(d)
if relative == :parent
# cop - collision.radius_parent * dir
if jacobian == :parent
∂c∂q = ∂contact_point_origin∂q(xp, qp, collision.origin_parent)
Q = ∂c∂q
Q -= collision.radius_parent * ∂normalize∂x(d) * ∂c∂q
elseif jacobian == :child
Q = -1.0 * collision.radius_parent * ∂normalize∂x(d) * -1.0 * ∂contact_point_origin∂q(xc, qc, collision.origin_child)
end
elseif relative == :child
# coc + collision.radius_child * dir
if jacobian == :parent
Q = 1.0 * collision.radius_child * ∂normalize∂x(d) * ∂contact_point_origin∂q(xp, qp, collision.origin_parent)
elseif jacobian == :child
∂c∂q = ∂contact_point_origin∂q(xc, qc, collision.origin_child)
Q = ∂c∂q
Q += collision.radius_child * ∂normalize∂x(d) * -1.0 * ∂c∂q
end
end
if jacobian == :parent
FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, Quaternion(q...), xc, qc), vector(qp))
elseif jacobian == :child
FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, qp, xc, Quaternion(q...)), vector(qc))
end
return FD
# @assert norm(Q - FD, Inf) < 1.0e-5
return Q
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 8209 | #="""
StringCollision
string collision between contact points
origin_parent: position of contact on parent body relative to center of mass
origin_child: position of contact on parent body relative to center of mass
length: maximum distance between contact point
"""=#
mutable struct StringCollision{T,O,I,OI} <: Collision{T,O,I,OI}
origin_parent::SVector{I,T}
origin_child::SVector{I,T}
length::T
end
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, collision::StringCollision)
# summary(io, collision)
# println(io, "")
# println(io, "origin_parent: "*string(collision.origin_parent))
# println(io, "origin_child: "*string(collision.origin_child))
# println(io, "length: "*string(collision.length))
# end
# distance
function distance(collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# distance between contact origins
d = norm(cop - coc, 2)
# minimum distance between spheres
return collision.length - d
end
function ∂distance∂x(gradient::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# distance between contact origins
# d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = 1.0 * ∂norm∂d * 1.0 * ∂contact_point_origin∂x(xp, qp, collision.origin_parent)
elseif gradient == :child
D = 1.0 * ∂norm∂d * -1.0 * ∂contact_point_origin∂x(xc, qc, collision.origin_child)
end
# if gradient == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, x, qp, xc, qc), xp)
# elseif gradient == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> distance(collision, xp, qp, x, qc), xc)
# end
# @assert norm(-D - FD, Inf) < 1.0e-5
return -D
end
function ∂distance∂q(gradient::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# distance between contact origins
# d = norm(cop - coc, 2)
∂norm∂d = ∂norm∂x(cop - coc)
if gradient == :parent
D = 1.0 * ∂norm∂d * 1.0 * ∂contact_point_origin∂q(xp, qp, collision.origin_parent)
elseif gradient == :child
D = 1.0 * ∂norm∂d * -1.0 * ∂contact_point_origin∂q(xc, qc, collision.origin_child)
end
# if gradient == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, Quaternion(q...), xc, qc), vector(qp))
# elseif gradient == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> distance(collision, xp, qp, xc, Quaternion(q...)), vector(qc))
# end
# @assert norm(-D - FD, Inf) < 1.0e-5
return -D
end
# contact point in world frame
function contact_point(relative::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# direction of minimum distance (child to parent)
# d = cop - coc
# dir = normalize(d)
# contact point
if relative == :parent
return cop
elseif relative == :child
return coc
end
end
function ∂contact_point∂x(relative::Symbol, jacobian::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# direction of minimum distance (child to parent)
# d = cop - coc
# dir = normalize(d)
if relative == :parent
# cop
if jacobian == :parent
∂c∂x = ∂contact_point_origin∂x(xp, qp, collision.origin_parent)
X = ∂c∂x
elseif jacobian == :child
X = szeros(eltype(xc), 3, 3)
end
elseif relative == :child
# coc
if jacobian == :parent
X = szeros(eltype(xp), 3, 3)
elseif jacobian == :child
∂c∂x = ∂contact_point_origin∂x(xc, qc, collision.origin_child)
X = ∂c∂x
end
end
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, x, qp, xc, qc), xp)
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(x -> contact_point(relative, collision, xp, qp, x, qc), xc)
# end
# @assert norm(X - FD, Inf) < 1.0e-5
return X
end
function ∂contact_point∂q(relative::Symbol, jacobian::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point_origin(xp, qp, collision.origin_parent)
coc = contact_point_origin(xc, qc, collision.origin_child)
# direction of minimum distance (child to parent)
# d = cop - coc
# dir = normalize(d)
if relative == :parent
# cop
if jacobian == :parent
∂c∂q = ∂contact_point_origin∂q(xp, qp, collision.origin_parent)
Q = ∂c∂q
elseif jacobian == :child
Q = szeros(eltype(xc), 3, 4)
end
elseif relative == :child
# coc
if jacobian == :parent
Q = szeros(eltype(xp), 3, 4)
elseif jacobian == :child
∂c∂q = ∂contact_point_origin∂q(xc, qc, collision.origin_child)
Q = ∂c∂q
end
end
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, Quaternion(q...), xc, qc), vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_point(relative, collision, xp, qp, xc, Quaternion(q...)), vector(qc))
# end
# @assert norm(Q - FD, Inf) < 1.0e-5
return Q
end
function contact_normal(collision::StringCollision, xp, qp, xc, qc)
# contact points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
# distance
dis = distance(collision, xp, qp, xc, qc)
# normalized direction
# if dis >= 0.0
return -normalize(dir)'
# else
# return normalize(dir)'
# end
end
function ∂contact_normal_transpose∂x(jacobian::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
# Jacobians
X = ∂normalize∂x(dir) * (∂contact_point∂x(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂x(:child, jacobian, collision, xp, qp, xc, qc))
# distance
# dis = distance(collision, xp, qp, xc, qc)
# normalized direction
# if dis >= 0.0
return -X
# else
# return 1.0 * X
# end
end
function ∂contact_normal_transpose∂q(jacobian::Symbol, collision::StringCollision, xp, qp, xc, qc)
# contact origin points
cop = contact_point(:parent, collision, xp, qp, xc, qc)
coc = contact_point(:child, collision, xp, qp, xc, qc)
# unnormalized direction
dir = cop - coc
Q = ∂normalize∂x(dir) * (∂contact_point∂q(:parent, jacobian, collision, xp, qp, xc, qc) - ∂contact_point∂q(:child, jacobian, collision, xp, qp, xc, qc))
# Jacobians
# if jacobian == :parent
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_normal(collision, xp, Quaternion(q...), xc, qc)', vector(qp))
# elseif jacobian == :child
# FD = FiniteDiff.finite_difference_jacobian(q -> contact_normal(collision, xp, qp, xc, Quaternion(q...))', vector(qc))
# end
# distance
dis = distance(collision, xp, qp, xc, qc)
# @assert norm((dis >= 0.0 ? 1.0 : -1.0) * Q - FD, Inf) < 1.0e-2
# normalized direction
# if dis >= 0.0
return -Q
# else
# return Q
# end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3091 | function get_contact_gradients(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}) where {T,Nn,Ne,Nb,Ni}
timestep= mechanism.timestep
nc = sum(Dojo.data_dim.(mechanism.contacts))
for entry in mechanism.data_matrix.nzval # reset matrix
entry.value .= 0.0
end
jacobian_data!(mechanism.data_matrix, mechanism)
nodes = [mechanism.joints; mechanism.bodies; mechanism.contacts]
dimrow = length.(nodes)
dimcol = data_dim.(nodes)
index_row = [1+sum(dimrow[1:i-1]):sum(dimrow[1:i]) for i in 1:length(dimrow)]
index_col = [1+sum(dimcol[1:i-1]):sum(dimcol[1:i]) for i in 1:length(dimcol)]
index_state = [index_col[body.id][[14:16; 8:10; 17:19; 11:13]] for body in mechanism.bodies] # ∂ x2 v15 q2 ω15
# index_control = [index_col[joint.id][1:input_dimension(joint)] for joint in mechanism.joints] # ∂ u
index_contact = [index_col[contact.id][1:data_dim(contact)] for contact in mechanism.contacts] # ∂ θ
datamat = full_matrix(mechanism.data_matrix, false, dimrow, dimcol)
solmat = full_matrix(mechanism.system)
# data Jacobian
data_jacobian = solmat \ datamat #TODO: use pre-factorization
# Jacobian
jacobian_state = zeros(12Nb,12Nb)
# jacobian_control = zeros(12Nb,nu)
jacobian_contact = zeros(12Nb,nc)
for (i, body) in enumerate(mechanism.bodies)
id = body.id
# Fill in gradients of v25, ω25
jacobian_state[12*(i-1) .+ [4:6; 10:12],:] += data_jacobian[index_row[id], vcat(index_state...)]
# jacobian_control[12*(i-1) .+ [4:6; 10:12],:] += data_jacobian[index_row[id], vcat(index_control...)]
jacobian_contact[12*(i-1) .+ [4:6; 10:12],:] += data_jacobian[index_row[id], vcat(index_contact...)]
# Fill in gradients of x3, q3
x2 = body.state.x2
q2 = body.state.q2
v25 = body.state.vsol[2]
ω25 = body.state.ωsol[2]
q3 = next_orientation(q2, ω25, timestep)
jacobian_state[12*(i-1) .+ (1:3), :] += linear_integrator_jacobian_velocity(x2, v25, timestep) * data_jacobian[index_row[id][1:3], vcat(index_state...)]
jacobian_state[12*(i-1) .+ (1:3), 12*(i-1) .+ (1:3)] += linear_integrator_jacobian_position(x2, v25, timestep)
jacobian_state[12*(i-1) .+ (7:9), :] += LVᵀmat(q3)' * rotational_integrator_jacobian_velocity(q2, ω25, timestep) * data_jacobian[index_row[id][4:6], vcat(index_state...)]
jacobian_state[12*(i-1) .+ (7:9), 12*(i-1) .+ (7:9)] += LVᵀmat(q3)' * rotational_integrator_jacobian_orientation(q2, ω25, timestep, attjac=true)
# jacobian_control[12*(i-1) .+ (1:3),:] += linear_integrator_jacobian_velocity(x2, v25, timestep) * data_jacobian[index_row[id][1:3], vcat(index_control...)]
# jacobian_control[12*(i-1) .+ (7:9),:] += LVᵀmat(q3)' * rotational_integrator_jacobian_velocity(q2, ω25, timestep) * data_jacobian[index_row[id][4:6], vcat(index_control...)]
jacobian_contact[12*(i-1) .+ (1:3),:] += linear_integrator_jacobian_velocity(x2, v25, timestep) * data_jacobian[index_row[id][1:3], vcat(index_contact...)]
jacobian_contact[12*(i-1) .+ (7:9),:] += LVᵀmat(q3)' * rotational_integrator_jacobian_velocity(q2, ω25, timestep) * data_jacobian[index_row[id][4:6], vcat(index_contact...)]
end
return jacobian_state, jacobian_contact
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 16021 | ################################################################################
# Data Jacobians
################################################################################
function joint_constraint_jacobian_body_data(mechanism::Mechanism, joint::JointConstraint{T,N}, body::Body{T}) where {T,N}
Nd = data_dim(body)
∇m = szeros(T,N,1)
∇J = szeros(T,N,6)
∇v15 = szeros(T,N,3)
∇ω15 = szeros(T,N,3)
∇z2 = -constraint_jacobian_configuration(mechanism, joint, body) *
integrator_jacobian_configuration(body, mechanism.timestep, attjac=true)
∇g = [∇m ∇J ∇v15 ∇ω15 ∇z2]
return ∇g
end
function body_constraint_jacobian_body_data(mechanism::Mechanism, body::Body{T}) where T
Δt = mechanism.timestep
N = 6
x1, v15, q1, ω15 = previous_configuration_velocity(body.state)
x2, v25, q2, ω25 = current_configuration_velocity(body.state)
x3, q3 = next_configuration(body.state, Δt)
# Mass
gravity=mechanism.gravity
∇m = [1 / Δt * (x2 - x1) + Δt/2 * gravity - 1 / Δt * (x3 - x2) + Δt/2 * gravity;
szeros(T,3,1)]
# Inertia
∇J = 2 / Δt * LVᵀmat(q2)' * LVᵀmat(q1) * ∂Jp∂J(VLᵀmat(q1) * vector(q2))
∇J += 2 / Δt * LVᵀmat(q2)' * Tmat() * RᵀVᵀmat(q3) * ∂Jp∂J(VLᵀmat(q2) * vector(q3))
∇J = [szeros(T,3,6); ∇J]
# initial conditions: v15, ω15
∇v15 = body.mass * SMatrix{3,3,T,9}(Diagonal(sones(T,3)))
∇q1 = -2 / Δt * LVᵀmat(q2)' * ∂LVᵀmat∂q(body.inertia * VLᵀmat(q1) * vector(q2))
∇q1 += -2 / Δt * LVᵀmat(q2)' * LVᵀmat(q1) * body.inertia * ∂VLᵀmat∂q(vector(q2))
∇ω15 = ∇q1 * rotational_integrator_jacobian_velocity(q2, -ω15, Δt)
∇15 = [∇v15 szeros(T,3,3);
szeros(T,3,3) ∇ω15]
# current configuration: z2 = x2, q2
# manipulator's equation contribution
∇tra_x2 = - 2 / Δt * body.mass * SMatrix{3,3,T,9}(Diagonal(sones(T,3)))
∇tra_q2 = szeros(T,3,3)
∇rot_x2 = szeros(T,3,3)
∇rot_q2 = -2 / Δt * VLᵀmat(q2) * LVᵀmat(q1) * body.inertia * VLᵀmat(q1)
∇rot_q2 += -2 / Δt * VLᵀmat(q2) * Tmat() * RᵀVᵀmat(q3) * body.inertia * ∂VLᵀmat∂q(vector(q3))
∇rot_q2 += -2 / Δt * ∂VLᵀmat∂q(LVᵀmat(q1) * body.inertia * VLᵀmat(q1) * vector(q2) + Tmat() * RᵀVᵀmat(q3) * body.inertia * VLᵀmat(q2) * vector(q3))
∇rot_q2 *= LVᵀmat(q2)
∇z2 = [∇tra_x2 ∇tra_q2;
∇rot_x2 ∇rot_q2]
# @show ∇z2
# TODO
# # contact constraints impulses contribution
# @warn "000"
return [∇m ∇J ∇15 0.0000000000*∇z2] #TODO not sure why we need to zero out this block, maybe finite diff is not correct and we try to match finite diff
end
function body_constraint_jacobian_body_data(mechanism::Mechanism, pbody::Node{T},
cbody::Node{T}, joint::JointConstraint{T,N,Nc}) where {T,N,Nc}
# Jacobian of pbody's dynamics constraints wrt cbody's data (x2b, q2b)
# this comes from the fact that the Joint Constraint force mapping of pbody
# depends on cbody's data (x2b, q2b)
# This is the same for spring and damper forces.
timestep= mechanism.timestep
∇z2_aa = szeros(T,6,6)
∇z2_ab = szeros(T,6,6)
# joint constraints impulses contribution
for i = 1:Nc
λ = get_joint_impulses(joint, i)
if cbody.id == joint.child_id
∇z2_aa += impulse_map_jacobian(:parent, :parent, (joint.translational, joint.rotational)[i],
pbody, cbody, λ)
∇z2_ab += impulse_map_jacobian(:parent, :child, (joint.translational, joint.rotational)[i],
pbody, cbody, λ)
elseif pbody.id == joint.child_id
∇z2_aa += impulse_map_jacobian(:child, :child, (joint.translational, joint.rotational)[i],
cbody, pbody, λ)
∇z2_ab += impulse_map_jacobian(:child, :parent, (joint.translational, joint.rotational)[i],
cbody, pbody, λ)
end
end
# spring and damper impulses contribution
if joint.spring
for i = 1:Nc
λ = get_joint_impulses(joint, i)
if cbody.id == joint.child_id
∇z2_aa += spring_jacobian_configuration(
:parent, :parent,
(joint.translational, joint.rotational)[i], pbody, cbody, timestep)
∇z2_ab += spring_jacobian_configuration(
:parent, :child,
(joint.translational, joint.rotational)[i], pbody, cbody, timestep)
elseif pbody.id == joint.child_id
∇z2_aa += spring_jacobian_configuration(
:child, :child,
(joint.translational, joint.rotational)[i], cbody, pbody, timestep)
∇z2_ab += spring_jacobian_configuration(
:child, :parent,
(joint.translational, joint.rotational)[i], cbody, pbody, timestep)
end
end
end
if joint.damper
for i = 1:Nc
λ = get_joint_impulses(joint, i)
if cbody.id == joint.child_id
∇z2_aa += damper_jacobian_configuration(
:parent, :parent,
(joint.translational, joint.rotational)[i], pbody, cbody, timestep)
∇z2_ab += damper_jacobian_configuration(
:parent, :child,
(joint.translational, joint.rotational)[i], pbody, cbody, timestep)
elseif pbody.id == joint.child_id
∇z2_aa += damper_jacobian_configuration(
:child, :child,
(joint.translational, joint.rotational)[i], cbody, pbody, timestep)
∇z2_ab += damper_jacobian_configuration(
:child, :parent,
(joint.translational, joint.rotational)[i], cbody, pbody, timestep)
end
end
end
return [szeros(T,6,13) ∇z2_aa], [szeros(T,6,13) ∇z2_ab]
end
function body_constraint_jacobian_body_data(mechanism::Mechanism, body::Node{T},
contact::ContactConstraint{T,N,Nc}) where {T,N,Nc}
# Jacobian of the Body's dynamics constraints wrt the Body's data (x2, q2)
# this comes from the fact that the Contact Constraint force mapping depends
# on the Body's data (x2, q2)
# contact constraints impulses contribution
∇z3 = impulse_map_jacobian_configuration(mechanism, body, contact)
∇z2 = ∇z3 * integrator_jacobian_configuration(body, mechanism.timestep)
return [szeros(T,6,13) ∇z2]
end
function body_constraint_jacobian_joint_data(mechanism::Mechanism{T}, body::Body{T},
joint::JointConstraint{T}) where {T}
Δt = mechanism.timestep
Nd = data_dim(joint)
N = 6
x1, v15, q1, ω15 = previous_configuration_velocity(body.state)
x2, v25, q2, ω25 = current_configuration_velocity(body.state)
x3, q3 = next_configuration(body.state, Δt)
# ∇u = Diagonal(SVector{6,T}(1,1,1,2,2,2)) * input_jacobian_control(mechanism, joint, body)
∇u = Diagonal(SVector{6,T}(1,1,1,1,1,1)) * input_jacobian_control(mechanism, joint, body)
∇spring = joint.spring ? spring_impulses(mechanism, joint, body, unitary=true) : szeros(T,6,1)
∇damper = joint.damper ? damper_impulses(mechanism, joint, body, unitary=true) : szeros(T,6,1)
return [∇u ∇spring ∇damper]
end
function body_constraint_jacobian_contact_data(mechanism::Mechanism, body::Body{T},
contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:NonlinearContact{T,N},N½}
Nd = data_dim(contact)
model = contact.model
xp3, qp3 = next_configuration(get_body(mechanism, contact.parent_id).state, mechanism.timestep)
xc3, qc3 = next_configuration(get_body(mechanism, contact.child_id).state, mechanism.timestep)
γ = contact.impulses[2]
∇friction_coefficient = szeros(T,3,1)
X = force_mapping(:parent, model, xp3, qp3, xc3, qc3)
∇p = -∂skew∂p(VRmat(qp3) * LᵀVᵀmat(qp3) * X * γ)
cn = contact_normal(model.collision, xp3, qp3, xc3, qc3)
∇contact_radius = - ∂skew∂p(VRmat(qp3) * LᵀVᵀmat(qp3) * X * γ) * -rotation_matrix(inv(qp3)) * cn'
∇X = szeros(T,3,Nd)
∇Q = -[∇friction_coefficient ∇contact_radius ∇p]
return [∇X; ∇Q]
end
function contact_constraint_jacobian_contact_data(mechanism::Mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½}, body::Body{T}) where {T,N,Nc,Cs<:NonlinearContact{T,N},N½}
Nd = data_dim(contact)
model = contact.model
xp3, vp25, qp3, ωp25 = next_configuration_velocity(get_body(mechanism, contact.parent_id).state, mechanism.timestep)
xc3, vc25, qc3, ωc25 = next_configuration_velocity(get_body(mechanism, contact.child_id).state, mechanism.timestep)
γ = contact.impulses[2]
∇friction_coefficient = SA[0,γ[1],0,0]
cn = contact_normal(model.collision, xp3, qp3, xc3, qc3)
ct = contact_tangent(model.collision, xp3, qp3, xc3, qc3)
∇contact_radius = [-cn; szeros(T,1,3); -ct * skew(vector_rotate(ωp25, qp3))] * cn'
∇p = [cn * rotation_matrix(qp3); szeros(T,1,3); ct * skew(vector_rotate(ωp25, qp3)) * rotation_matrix(qp3)]
∇compμ = szeros(T,N½,Nd)
∇g = -[∇friction_coefficient ∇contact_radius ∇p]
return [∇compμ; ∇g]
end
function contact_constraint_jacobian_body_data(mechanism::Mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½}, body::Body{T}) where {T,N,Nc,Cs,N½}
Nd = data_dim(body)
∇compμ = szeros(T,N½,Nd)
∇m = szeros(T,N½,1)
∇J = szeros(T,N½,6)
∇v15 = szeros(T,N½,3)
∇ω15 = szeros(T,N½,3)
∇z3 = - constraint_jacobian_configuration(mechanism, contact, body) # minus sign coming from res = [-compμ; -constraint]
∇z2 = ∇z3 * integrator_jacobian_configuration(body, mechanism.timestep, attjac=true) # 4x7 * 7x6 = 4x6
∇g = [∇m ∇J ∇v15 ∇ω15 ∇z2]
return [∇compμ; ∇g]
end
################################################################################
# System Data Jacobians
################################################################################
function data_adjacency_matrix(joints::Vector{<:JointConstraint}, bodies::Vector{<:Body},
contacts::Vector{<:ContactConstraint})
# mode can be impulses or data depending on whi
nodes = [joints; bodies; contacts]
n = length(nodes)
A = zeros(Bool, n, n)
for node1 in nodes
for node2 in nodes
T1 = typeof(node1)
T2 = typeof(node2)
if T1 <: Body
if T2 <: Body
(node1.id == node2.id) && (A[node1.id, node2.id] = 1) # self loop
linked = length(indirect_link(node1.id, node2.id, [joints; contacts])) > 0
linked && (A[node1.id, node2.id] = 1) # linked through a common joint
elseif T2 <: JointConstraint
(node1.id == node2.parent_id || node1.id == node2.child_id) && (A[node1.id, node2.id] = 1) # linked
elseif T2 <: ContactConstraint
(node1.id == node2.parent_id || node1.id == node2.child_id) && (A[node1.id, node2.id] = 1) # linked
end
elseif T1 <: JointConstraint
if T2 <: Body
(node2.id == node1.parent_id || node2.id == node1.child_id) && (A[node1.id, node2.id] = 1) # linked
end
elseif T1 <: ContactConstraint
if T2 <: Body
(node2.id == node1.parent_id || node2.id == node1.child_id) && (A[node1.id, node2.id] = 1) # linked
elseif T2 <: ContactConstraint
(node1.id == node2.id) && (A[node1.id, node2.id] = 1) # self loop
end
end
end
end
A = convert(Matrix{Int64}, A)
return A
end
function indirect_link(id1, id2, nodes::Vector{S}) where {S<:Node}
ids = zeros(Int, 0)
for node in nodes
parent_id = node.parent_id
(parent_id === nothing) && (parent_id = 0) #handle the origin's corner case
linked = (id1 == node.child_id) && (id2 == parent_id)
linked |= (id2 == node.child_id) && (id1 == parent_id)
linked && push!(ids, node.id)
end
return ids
end
function create_data_matrix(joints::Vector{<:JointConstraint}, bodies::Vector{B}, contacts::Vector{<:ContactConstraint};
force_static::Bool=false) where {T,B<:Body{T}}
nodes = [joints; bodies; contacts]
A = data_adjacency_matrix(joints, bodies, contacts)
dimrow = length.(nodes)
dimcol = data_dim.(nodes)
N = length(dimrow)
static = force_static || (all(dimrow.<=10) && all(dimcol.<=10))
data_matrix = spzeros(Entry,N,N)
for i = 1:N
for j = 1:N
if A[i,j] == 1
data_matrix[i,j] = Entry{T}(dimrow[i], dimcol[j], static = static)
end
end
end
return data_matrix
end
function jacobian_data!(data_matrix::SparseMatrixCSC, mechanism::Mechanism)
jacobian_contact_data!(data_matrix, mechanism)
jacobian_body_data!(data_matrix, mechanism)
jacobian_joint_data!(data_matrix, mechanism)
return nothing
end
function jacobian_contact_data!(data_matrix::SparseMatrixCSC, mechanism::Mechanism{T}) where {T}
# ∂body∂ineqcdata
for contact in mechanism.contacts
pbody = get_body(mechanism, contact.parent_id)
data_matrix[pbody.id, contact.id].value += body_constraint_jacobian_contact_data(mechanism, pbody, contact)
end
# ∂contact∂contactdata
for contact in mechanism.contacts
pbody = get_body(mechanism, contact.parent_id)
data_matrix[contact.id, contact.id].value += contact_constraint_jacobian_contact_data(mechanism, contact, pbody)
end
return nothing
end
function jacobian_joint_data!(data_matrix::SparseMatrixCSC, mechanism::Mechanism{T}) where T
# ∂body∂jointdata
# TODO adapt this to handle cycles
for body in mechanism.bodies
for joint in mechanism.joints
if (body.id == joint.parent_id) || (body.id == joint.child_id)
data_matrix[body.id, joint.id].value += body_constraint_jacobian_joint_data(mechanism, body, joint)
end
end
end
return nothing
end
function jacobian_body_data!(data_matrix::SparseMatrixCSC, mechanism::Mechanism{T}) where T
# ∂joint∂bodydata
# TODO adapt this to handle cycles
for body in mechanism.bodies
for joint in mechanism.joints
if (body.id == joint.parent_id) || (body.id == joint.child_id)
data_matrix[joint.id, body.id].value += joint_constraint_jacobian_body_data(mechanism, joint, body)
end
end
end
# ∂body∂bodydata
for pbody in mechanism.bodies
data_matrix[pbody.id, pbody.id].value += body_constraint_jacobian_body_data(mechanism, pbody)
for cbody in [mechanism.bodies; mechanism.origin]
joint_links = indirect_link(pbody.id, cbody.id, mechanism.joints)
joints = [get_joint(mechanism, id) for id in joint_links]
for joint in joints
∇11, ∇12 = body_constraint_jacobian_body_data(mechanism, pbody, cbody, joint)
(typeof(pbody) <: Body) && (data_matrix[pbody.id, pbody.id].value += ∇11)
(typeof(pbody) <: Body && typeof(cbody) <: Body) && (data_matrix[pbody.id, cbody.id].value += ∇12)
end
# pretty sure this is useless because contact is never linked to two bodies
# contact_links = indirect_link(pbody.id, cbody.id, mechanism.contacts)
# contacts = [get_joint(mechanism, id) for id in contact_links]
# for contact in contacts
# data_matrix[pbody.id, cbody.id].value += body_constraint_jacobian_body_data(mechanism, pbody, cbody, contact)
# end
end
end
for contact in mechanism.contacts
body = get_body(mechanism, contact.parent_id)
data_matrix[body.id, body.id].value += body_constraint_jacobian_body_data(mechanism, body, contact)
end
# ∂contact∂bodydata
for contact in mechanism.contacts
pbody = get_body(mechanism, contact.parent_id)
data_matrix[contact.id, pbody.id].value += contact_constraint_jacobian_body_data(mechanism, contact, pbody)
end
return nothing
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2518 | function get_solution(mechanism::Mechanism{T}) where {T}
sol = T[]
for (i, joints) in enumerate(mechanism.joints)
λ = joints.impulses[2]
push!(sol, λ...)
end
for (i, body) in enumerate(mechanism.bodies)
v25 = body.state.vsol[2]
ω25 = body.state.ωsol[2]
push!(sol, [v25; ω25]...)
end
for (i, contacts) in enumerate(mechanism.contacts)
s = contacts.impulses_dual[2]
γ = contacts.impulses[2]
push!(sol, [s; γ]...)
end
return sol
end
function set_solution!(mechanism::Mechanism{T}, sol::AbstractVector) where T
off = 0
for (i,joints) in enumerate(mechanism.joints)
nλ = length(joints)
λ = sol[off .+ (1:nλ)]; off += nλ
joints.impulses[2] = λ
end
for (i,body) in enumerate(mechanism.bodies)
nv = 3
nω = 3
v25 = sol[off .+ (1:nv)]; off += nv
ω25 = sol[off .+ (1:nω)]; off += nω
body.state.vsol[2] = v25
body.state.ωsol[2] = ω25
end
for (i,contacts) in enumerate(mechanism.contacts)
N = length(contacts)
N½ = Int(N/2)
s = sol[off .+ (1:N½)]; off += N½
γ = sol[off .+ (1:N½)]; off += N½
contacts.impulses_dual[2] = s
contacts.impulses[2] = γ
end
return nothing
end
function evaluate_residual!(mechanism::Mechanism, data::AbstractVector, sol::AbstractVector)
system = mechanism.system
set_data!(mechanism, data)
set_solution!(mechanism, sol)
set_entries!(mechanism)
return full_vector(system)
end
function residual_dimension(mechanism::Mechanism)
return sum(Vector{Int}(length.(mechanism.joints))) +
sum(Vector{Int}(length.(mechanism.bodies))) +
sum(Vector{Int}(length.(mechanism.contacts)))
end
function finite_difference_data_jacobian(mechanism::Mechanism, data::AbstractVector,
sol::AbstractVector; δ = 1e-5, verbose=false)
mechanism = deepcopy(mechanism)
Nd = data_dim(mechanism, attjac=false)
Nr = residual_dimension(mechanism)
jac = zeros(Nr, Nd)
set_data!(mechanism, deepcopy(data))
set_solution!(mechanism, deepcopy(sol))
for i = 1:Nd
verbose && println("$i / $ndata")
datap = deepcopy(data)
datam = deepcopy(data)
datap[i] += δ
datam[i] -= δ
rp = evaluate_residual!(deepcopy(mechanism), datap, deepcopy(sol))
rm = evaluate_residual!(deepcopy(mechanism), datam, deepcopy(sol))
jac[:,i] = (rp - rm) / (2δ)
end
return jac
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 8451 | """
maximal_to_minimal_jacobian(mechanism, z)
Jacobian of mapping from maximal to minimal representation
mechanism: Mechanism
z: maximal state
"""
function maximal_to_minimal_jacobian(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, z::AbstractVector{Tz}) where {T,Nn,Ne,Nb,Ni,Tz}
J = zeros(minimal_dimension(mechanism), maximal_dimension(mechanism) - Nb)
timestep= mechanism.timestep
row_shift = 0
for joint in mechanism.joints
c_shift = 0
v_shift = input_dimension(joint)
ichild = joint.child_id - Ne
for element in (joint.translational, joint.rotational)
nu_element = input_dimension(element)
c_idx = row_shift + c_shift .+ (1:nu_element)
v_idx = row_shift + v_shift .+ (1:nu_element)
xb, vb, qb, ωb = unpack_maximal_state(z, ichild)
xb_idx = collect((ichild-1)*12 .+ (1:3))
vb_idx = collect((ichild-1)*12 .+ (4:6))
qb_idx = collect((ichild-1)*12 .+ (7:9))
ωb_idx = collect((ichild-1)*12 .+ (10:12))
if joint.parent_id != 0
iparent = joint.parent_id - Ne
xa, va, qa, ωa = unpack_maximal_state(z, iparent)
xa_idx = collect((iparent-1)*12 .+ (1:3))
va_idx = collect((iparent-1)*12 .+ (4:6))
qa_idx = collect((iparent-1)*12 .+ (7:9))
ωa_idx = collect((iparent-1)*12 .+ (10:12))
J[c_idx, [xa_idx; qa_idx]] = minimal_coordinates_jacobian_configuration(:parent, element, xa, qa, xb, qb)
J[v_idx, [xa_idx; qa_idx]] = minimal_velocities_jacobian_configuration(:parent, element, xa, va, qa, ωa, xb, vb, qb, ωb, timestep)
J[v_idx, [va_idx; ωa_idx]] = minimal_velocities_jacobian_velocity(:parent, element, xa, va, qa, ωa, xb, vb, qb, ωb, timestep)
else
xa, va, qa, ωa = current_configuration_velocity(mechanism.origin.state)
end
J[c_idx, [xb_idx; qb_idx]] = minimal_coordinates_jacobian_configuration(:child, element, xa, qa, xb, qb)
J[v_idx, [xb_idx; qb_idx]] = minimal_velocities_jacobian_configuration(:child, element, xa, va, qa, ωa, xb, vb, qb, ωb, timestep)
J[v_idx, [vb_idx; ωb_idx]] = minimal_velocities_jacobian_velocity(:child, element, xa, va, qa, ωa, xb, vb, qb, ωb, timestep)
c_shift += nu_element
v_shift += nu_element
end
row_shift += 2 * input_dimension(joint)
end
return J
end
"""
get_maximal_gradients!(mechanism, z, u; opts)
return maximal gradients for mechanism
note: this requires simulating the mechanism for one time step
mechanism: Mechanism
z: state
u: input
opts: SolverOptions
"""
function get_maximal_gradients!(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, z::AbstractVector{T}, u::AbstractVector{T};
opts=SolverOptions()) where {T,Nn,Ne,Nb,Ni}
step!(mechanism, z, u, opts=opts)
jacobian_state, jacobian_control = get_maximal_gradients(mechanism)
return jacobian_state, jacobian_control
end
function get_maximal_gradients(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}) where {T,Nn,Ne,Nb,Ni}
timestep= mechanism.timestep
nu = input_dimension(mechanism)
for entry in mechanism.data_matrix.nzval # reset matrix
entry.value .= 0.0
end
jacobian_data!(mechanism.data_matrix, mechanism)
nodes = [mechanism.joints; mechanism.bodies; mechanism.contacts]
dimrow = length.(nodes)
dimcol = data_dim.(nodes)
index_row = [1+sum(dimrow[1:i-1]):sum(dimrow[1:i]) for i in 1:length(dimrow)]
index_col = [1+sum(dimcol[1:i-1]):sum(dimcol[1:i]) for i in 1:length(dimcol)]
index_state = [index_col[body.id][[14:16; 8:10; 17:19; 11:13]] for body in mechanism.bodies] # ∂ x2 v15 q2 ω15
index_control = [index_col[joint.id][1:input_dimension(joint)] for joint in mechanism.joints] # ∂ u
datamat = full_matrix(mechanism.data_matrix, false, dimrow, dimcol)
solmat = full_matrix(mechanism.system)
# data Jacobian
data_jacobian = solmat \ datamat #TODO: use pre-factorization
# Jacobian
jacobian_state = zeros(12Nb,12Nb)
jacobian_control = zeros(12Nb,nu)
for (i, body) in enumerate(mechanism.bodies)
id = body.id
# Fill in gradients of v25, ω25
jacobian_state[12*(i-1) .+ [4:6; 10:12],:] += data_jacobian[index_row[id], vcat(index_state...)]
jacobian_control[12*(i-1) .+ [4:6; 10:12],:] += data_jacobian[index_row[id], vcat(index_control...)]
# Fill in gradients of x3, q3
x2 = body.state.x2
q2 = body.state.q2
v25 = body.state.vsol[2]
ω25 = body.state.ωsol[2]
q3 = next_orientation(q2, ω25, timestep)
jacobian_state[12*(i-1) .+ (1:3), :] += linear_integrator_jacobian_velocity(x2, v25, timestep) * data_jacobian[index_row[id][1:3], vcat(index_state...)]
jacobian_state[12*(i-1) .+ (1:3), 12*(i-1) .+ (1:3)] += linear_integrator_jacobian_position(x2, v25, timestep)
jacobian_state[12*(i-1) .+ (7:9), :] += LVᵀmat(q3)' * rotational_integrator_jacobian_velocity(q2, ω25, timestep) * data_jacobian[index_row[id][4:6], vcat(index_state...)]
jacobian_state[12*(i-1) .+ (7:9), 12*(i-1) .+ (7:9)] += LVᵀmat(q3)' * rotational_integrator_jacobian_orientation(q2, ω25, timestep, attjac=true)
jacobian_control[12*(i-1) .+ (1:3),:] += linear_integrator_jacobian_velocity(x2, v25, timestep) * data_jacobian[index_row[id][1:3], vcat(index_control...)]
jacobian_control[12*(i-1) .+ (7:9),:] += LVᵀmat(q3)' * rotational_integrator_jacobian_velocity(q2, ω25, timestep) * data_jacobian[index_row[id][4:6], vcat(index_control...)]
end
return jacobian_state, jacobian_control
end
"""
minimal_to_maximal_jacobian(mechanism, x)
Jacobian of mapping from minimal to maximal representation
mechanism: Mechanism
y: minimal state
"""
function minimal_to_maximal_jacobian(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, x::AbstractVector{Tx}) where {T,Nn,Ne,Nb,Ni,Tx}
timestep= mechanism.timestep
J = zeros(maximal_dimension(mechanism, attjac=true), minimal_dimension(mechanism))
# Compute partials
partials = Dict{Vector{Int}, Matrix{T}}()
for cnode in mechanism.bodies
for joint in parent_joints(mechanism, cnode)
pnode = get_node(mechanism, joint.parent_id, origin=true)
partials[[cnode.id, joint.id]] = set_minimal_coordinates_velocities_jacobian_minimal(joint, pnode, cnode, timestep) # 12 x 2nu (xvqω x Δxθvω)
partials[[cnode.id, pnode.id]] = set_minimal_coordinates_velocities_jacobian_parent(joint, pnode, cnode, timestep) # 12 x 12 (xvqω x xvqω)
end
end
# Index
row = [12(i-1)+1:12i for i = 1:Nb]
col = [] # ordering joints from root to tree
col_idx = zeros(Int,Ne)
cnt = 0
for joint in mechanism.joints
id = joint.id
nu = input_dimension(get_joint(mechanism, id))
nu == 0 && continue # ignore fixed joints
cnt += 1
if length(col) > 0
push!(col, col[end][end] .+ (1:2nu))
else
push!(col, 1:2nu)
end
col_idx[id] = cnt
end
# chain partials together
for body in mechanism.bodies
for joint in parent_joints(mechanism, body)
input_dimension(joint) == 0 && continue
pnode = get_node(mechanism, joint.parent_id, origin=true)
J[row[body.id-Ne], col[col_idx[joint.id]]] += partials[[body.id, joint.id]] # ∂zi∂θp(i)
(pnode.id == 0) && continue # avoid origin
J[row[body.id-Ne], :] += partials[[body.id, pnode.id]] * J[row[pnode.id-Ne], :] # ∂zi∂zp(p(i)) * ∂zp(p(i))/∂θ
end
end
return J
end
"""
get_minimal_gradients!(mechanism, y, u; opts)
return minimal gradients for mechanism
note: this requires simulating the mechanism for one time step
mechanism: Mechanism
y: state
u: input
opts: SolverOptions
"""
function get_minimal_gradients!(mechanism::Mechanism{T}, y::AbstractVector{T}, u::AbstractVector{T};
opts=SolverOptions()) where T
# simulate next state
step_minimal_coordinates!(mechanism, y, u, opts=opts)
return get_minimal_gradients!(mechanism)
end
function get_minimal_gradients!(mechanism::Mechanism{T}) where T
# current maximal state
z = get_maximal_state(mechanism)
# next maximal state
z_next = get_next_state(mechanism)
# current minimal state
x = maximal_to_minimal(mechanism, z)
# maximal dynamics Jacobians
maximal_jacobian_state, minimal_jacobian_control = get_maximal_gradients(mechanism)
# minimal to maximal Jacobian at current time step (rhs)
min_to_max_jacobian_current = minimal_to_maximal_jacobian(mechanism, x)
# maximal to minimal Jacobian at next time step (lhs)
max_to_min_jacobian_next = maximal_to_minimal_jacobian(mechanism, z_next)
# minimal state Jacobian
minimal_jacobian_state = max_to_min_jacobian_next * maximal_jacobian_state * min_to_max_jacobian_current
# minimal control Jacobian
minimal_jacobian_control = max_to_min_jacobian_next * minimal_jacobian_control
return minimal_jacobian_state, minimal_jacobian_control
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1194 | ################################################################################
# Inertia
################################################################################
function lift_inertia(j::SVector{6,T}) where T
J = SMatrix{3,3,T,9}(
[j[1] j[2] j[3];
j[2] j[4] j[5];
j[3] j[5] j[6]])
end
function flatten_inertia(J::SMatrix{3,3,T,9}) where T
j = SVector{6,T}([J[1,1], J[1,2], J[1,3], J[2,2], J[2,3], J[3,3]])
end
function ∂Jp∂J(p) #∂(J*p)/∂flatten(J)
SA[
p[1] p[2] p[3] 0 0 0;
0 p[1] 0 p[2] p[3] 0;
0 0 p[1] 0 p[2] p[3];
]
end
function attitude_jacobian(data::AbstractVector, Nb::Int)
G = zeros(0,0)
for i = 1:Nb
x2, v15, q2, ω15 = unpack_data(data[13 * (i-1) .+ (1:13)])
q2 = Quaternion(q2...)
G = cat(G, sI(6), LVᵀmat(q2), sI(3), dims = (1,2))
end
ndata = length(data)
nu = ndata - size(G)[1]
G = cat(G, I(nu), dims = (1,2))
return G
end
function unpack_data(data::AbstractVector)
x2 = data[SA[1;2;3]]
v15 = data[SA[4;5;6]]
q2 = data[SA[7;8;9;10]]
ω15 = data[SA[11;12;13]]
return x2, v15, q2, ω15
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2954 | function constraint(mechanism::Mechanism{T,Nn,Ne,Nb}, body::Body{T}) where {T,Nn,Ne,Nb}
state = body.state
timestep= mechanism.timestep
mass = body.mass
inertia = body.inertia
gravity = mechanism.gravity
x1, q1 = previous_configuration(state)
x2, q2 = current_configuration(state)
x3, q3 = next_configuration(state, timestep)
# dynamics
D1x = - 1.0 / timestep * mass * (x2 - x1) - 0.5 * timestep * (mass * gravity + state.Fext)
D2x = 1.0 / timestep * mass * (x3 - x2) - 0.5 * timestep * (mass * gravity + state.Fext)
D1q = -2.0 / timestep * LVᵀmat(q2)' * Lmat(q1) * Vᵀmat() * inertia * Vmat() * Lmat(q1)' * vector(q2) - 0.5 * timestep * state.τext
D2q = -2.0 / timestep * LVᵀmat(q2)' * Tmat() * Rmat(q3)' * Vᵀmat() * inertia * Vmat() * Lmat(q2)' * vector(q3) - 0.5 * timestep * state.τext
dynT = D2x + D1x
dynR = D2q + D1q
state.d = [dynT; dynR]
# inputs
state.d -= [state.JF2; state.Jτ2]
# impulses
for id in connections(mechanism.system, body.id)
Ne < id <= Ne + Nb && continue # body
impulses!(mechanism, body, get_node(mechanism, id))
end
return state.d
end
function constraint_jacobian_configuration(mechanism::Mechanism{T,Nn,Ne,Nb}, body::Body{T}; reg::T=Dojo.REG) where {T,Nn,Ne,Nb}
state = body.state
timestep = mechanism.timestep
mass = body.mass
inertia = body.inertia
x2, q2 = current_configuration(state)
x3, q3 = next_configuration(state, timestep)
I3 = SMatrix{3,3,T,9}(Diagonal(sones(T,3)))
Z33 = szeros(T, 3, 3)
Z34 = szeros(T, 3, 4)
# dynamics
dynT = I3 * mass / timestep
dynR = -2.0 / timestep * LVᵀmat(q2)' * Tmat() * (∂Rᵀmat∂q(Vᵀmat() * inertia * Vmat() * Lmat(q2)' * vector(q3)) + Rmat(q3)' * Vᵀmat() * inertia * Vmat() * Lmat(q2)')
state.D = [[dynT; Z33] [Z34; dynR]] * integrator_jacobian_velocity(body, timestep)
state.D += [[reg * I3; Z33] [Z33; reg * I3]]
# inputs
nothing
# impulses
for id in connections(mechanism.system, body.id)
Ne < id <= Ne + Nb && continue # body
impulses_jacobian_velocity!(mechanism, body, get_node(mechanism, id))
end
return state.D
end
function integrator_jacobian_velocity(body::Body{T}, timestep) where T
state = body.state
x2, v25, q2, ω25 = current_configuration_velocity(state)
integrator_jacobian_velocity(x2, v25, q2, ω25, timestep)
end
function integrator_jacobian_configuration(body::Body{T},
timestep; attjac::Bool=true) where T
state = body.state
x2, v25, q2, ω25 = current_configuration_velocity(state)
integrator_jacobian_configuration(x2, v25, q2, ω25, timestep; attjac=attjac)
end
# linear system
function set_matrix_vector_entries!(mechanism, matrix_entry::Entry, vector_entry::Entry, body::Body)
matrix_entry.value = constraint_jacobian_configuration(mechanism, body)
vector_entry.value = -constraint(mechanism, body)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3221 | # previous
previous_configuration(state::State) = (state.x1, state.q1)
previous_configuration_velocity(state::State) = (state.x1, state.v15, state.q1, state.ω15)
# current
current_position(state::State) = state.x2
current_orientation(state::State) = state.q2
current_configuration(state::State) = (current_position(state), current_orientation(state))
current_velocity(state::State) = (state.vsol[2], state.ωsol[2])
current_configuration_velocity(state::State) = (current_position(state), state.vsol[2], current_orientation(state), state.ωsol[2])
initial_configuration_velocity(state::State) = (current_position(state), state.v15, current_orientation(state), state.ω15)
# next
next_position(x2::SVector{3}, v25::SVector{3}, timestep::Real) = x2 + v25 * timestep
next_orientation(q2::Quaternion, ω25::SVector{3}, timestep::Real) = q2 * quaternion_map(ω25, timestep) * timestep / 2
next_position(state::State, timestep) = next_position(state.x2, state.vsol[2], timestep)
next_orientation(state::State, timestep) = next_orientation(state.q2, state.ωsol[2], timestep)
next_configuration(state::State, timestep) = (next_position(state, timestep), next_orientation(state, timestep))
next_configuration_velocity(state::State, timestep) = (next_position(state, timestep), state.vsol[2], next_orientation(state, timestep), state.ωsol[2])
# angular velocity
function angular_velocity(q1::Quaternion, q2::Quaternion, timestep)
2.0 / timestep * Vmat() * Lᵀmat(q1) * vector(q2)
end
function ∂angular_velocity∂q1(q1::Quaternion, q2::Quaternion, timestep)
2.0 / timestep * Vmat() * Rmat(q2) * Tmat()
end
function ∂angular_velocity∂q2(q1::Quaternion, q2::Quaternion, timestep)
2.0 / timestep * Vmat() * Lᵀmat(q1)
end
# Jacobians
function integrator_jacobian_velocity(x2::AbstractVector, v25::AbstractVector, q2::Quaternion, ω25::SVector{3}, timestep::T) where T
V = [linear_integrator_jacobian_velocity(x2, v25, timestep) szeros(T,3,3)]
Ω = [szeros(T,4,3) rotational_integrator_jacobian_velocity(q2, ω25, timestep)]
return [V; Ω] # 7x6
end
function integrator_jacobian_configuration(x2::AbstractVector, v25::AbstractVector, q2::Quaternion, ω25::SVector{3}, timestep::T;
attjac::Bool=true) where T
Z = attjac ? szeros(T,3,3) : szeros(T,3,4)
X = [linear_integrator_jacobian_position(x2, v25, timestep) Z]
Q = [szeros(T,4,3) rotational_integrator_jacobian_orientation(q2, ω25, timestep; attjac=attjac)]
return [X; Q] # 7x6 or 7x7
end
function linear_integrator_jacobian_position(x2::AbstractVector, v2::AbstractVector, timestep::T) where T
return SMatrix{3,3,T,9}(Diagonal(sones(T, 3)))
end
function linear_integrator_jacobian_velocity(x2::AbstractVector, v2::AbstractVector, timestep::T) where T
return timestep * SMatrix{3,3,T,9}(Diagonal(sones(T,3)))
end
function rotational_integrator_jacobian_orientation(q2::Quaternion, ω25::SVector{3}, timestep::Real;
attjac::Bool = true)
M = Rmat(quaternion_map(ω25, timestep) * timestep / 2)
attjac && (M *= LVᵀmat(q2))
return M
end
function rotational_integrator_jacobian_velocity(q2::Quaternion, ω25::SVector{3}, timestep::Real)
return Lmat(q2) * quaternion_map_jacobian(ω25, timestep) * timestep / 2
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 18278 | """
JointConstraint{T} <: Constraint{T}
constraint restricting translational and rotational degrees of freedom between two Body objects.
id: a unique identifying number
name: a unique identifying name
translational: Translational
rotational: Rotational
spring: flag for joint springs on
damper: flag for joint dampers on
parent_id: identifying number for parent Body{T}
child_id: identifying number for child Body{T}
minimal_index: indices for minimal coordinates
impulses: joint impulses that maintain constraint between two Body{T} objects
"""
mutable struct JointConstraint{T,N,Nc,TJ,RJ} <: Constraint{T,N}
# ID
id::Int64
name::Symbol
# joint constraints
translational::TJ
rotational::RJ
# springs and dampers
spring::Bool
damper::Bool
# neighbor IDs
parent_id::Int
child_id::Int
# indices
minimal_index::SVector{Nc,SVector{2,Int64}} # indices for minimal coordinates, assumes joints # Nc = 2 THIS IS SPECIAL CASED
# impulses
impulses::Vector{SVector{N,T}}
function JointConstraint(data;
name::Symbol=Symbol("joint_" * randstring(4)))
@assert data[1][2] == data[2][2] # check parent ids
@assert data[1][3] == data[2][3] # check child ids
# joints
translational = data[1][1]
rotational = data[2][1]
# IDs
parent_id = data[1][2]
child_id = data[1][3]
# data dype
T = typeof(data[1][1]).parameters[1]
# set springs & dampers off
spring = false
damper = false
minimal_index = Vector{Int64}[]
N = 0
for joint_data in data
joint = joint_data[1]
# set spring & damper on
joint.spring != 0 && (spring = true)
joint.damper != 0 && (damper = true)
# minimal-coordaintes indices
Nλ = joint_length(joint)
Nset = impulses_length(joint)
if isempty(minimal_index)
push!(minimal_index, [1;3-Nλ])
else
push!(minimal_index, [last(minimal_index)[2]+1; last(minimal_index)[2]+3-Nλ])
end
N += Nset
end
Nc = 2
impulses = [zeros(T, N) for i=1:2]
return new{T,N,Nc,typeof(translational),typeof(rotational)}(getGlobalID(), name, translational, rotational, spring, damper, parent_id, child_id, minimal_index, impulses)
end
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, constraint::JointConstraint)
summary(io, constraint)
println(io, "")
println(io, "id: "*string(constraint.id))
println(io, "name: "*string(constraint.name))
println(io, "spring: "*string(constraint.spring))
println(io, "damper: "*string(constraint.damper))
println(io, "parent_id: "*string(constraint.parent_id))
println(io, "child_id: "*string(constraint.child_id))
println(io, "minimal_index: "*string(constraint.minimal_index))
println(io, "impulses: "*string(constraint.impulses))
end
# constraints
# @generated function constraint(mechanism, joint::JointConstraint)
# pbody = :(get_body(mechanism, joint.parent_id))
# cbody = :(get_body(mechanism, joint.child_id))
# tra = :(constraint(joint.translational,
# $pbody, $cbody,
# joint.impulses[2][joint_impulse_index(joint,1)], mechanism.μ, mechanism.timestep))
# rot = :(constraint(joint.rotational,
# $pbody, $cbody,
# joint.impulses[2][joint_impulse_index(joint,2)], mechanism.μ, mechanism.timestep))
# return :(svcat($tra, $rot))
# end
function constraint(mechanism, joint::JointConstraint)
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
tra = constraint(joint.translational, pbody, cbody, joint.impulses[2][joint_impulse_index(joint,1)], mechanism.μ, mechanism.timestep)
rot = constraint(joint.rotational, pbody, cbody, joint.impulses[2][joint_impulse_index(joint,2)], mechanism.μ, mechanism.timestep)
return svcat(tra, rot)
end
# # constraints Jacobians
# @generated function constraint_jacobian(joint::JointConstraint)
# tra = :(constraint_jacobian(joint.translational, joint.impulses[2][joint_impulse_index(joint, 1)]))
# rot = :(constraint_jacobian(joint.rotational, joint.impulses[2][joint_impulse_index(joint, 2)]))
# return :(cat($tra, $rot, dims=(1,2)))
# end
function constraint_jacobian(joint::JointConstraint)
tra = constraint_jacobian(joint.translational, joint.impulses[2][joint_impulse_index(joint, 1)])
rot = constraint_jacobian(joint.rotational, joint.impulses[2][joint_impulse_index(joint, 2)])
return diagonal_cat(tra, rot)
end
@generated function constraint_jacobian_configuration(mechanism, joint::JointConstraint, body::Body)
relative = :(body.id == joint.parent_id ? :parent : :child)
pbody = :(get_body(mechanism, joint.parent_id))
cbody = :(get_body(mechanism, joint.child_id))
tra = :(constraint_jacobian_configuration($relative,
joint.translational,
$pbody, $cbody,
joint.impulses[2][joint_impulse_index(joint, 1)], mechanism.timestep))
rot = :(constraint_jacobian_configuration($relative,
joint.rotational,
$pbody, $cbody,
joint.impulses[2][joint_impulse_index(joint, 2)], mechanism.timestep))
return :(vcat($tra, $rot))
end
# impulses
function impulses!(mechanism, body::Body, joint::JointConstraint{T,Nλ}) where {T,Nλ}
(Nλ > 0) && (body.state.d -= impulse_map(mechanism, joint, body) * joint.impulses[2])
joint.spring && (body.state.d -= spring_impulses(mechanism, joint, body))
joint.damper && (body.state.d -= damper_impulses(mechanism, joint, body))
return
end
function impulse_map(mechanism, joint::JointConstraint, body::Body)
relative = body.id == joint.parent_id ? :parent : :child
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
tra = impulse_map(relative, joint.translational,
pbody, cbody,
joint.impulses[2][joint_impulse_index(joint, 1)])
rot = impulse_map(relative, joint.rotational,
pbody, cbody,
joint.impulses[2][joint_impulse_index(joint, 2)])
return hcat(tra, rot)
end
# @generated function impulse_map(mechanism, joint::JointConstraint, body::Body)
# relative = :(body.id == joint.parent_id ? :parent : :child)
# pbody = :(get_body(mechanism, joint.parent_id))
# cbody = :(get_body(mechanism, joint.child_id))
# tra = :(impulse_map($relative, joint.translational,
# $pbody, $cbody,
# joint.impulses[2][joint_impulse_index(joint, 1)]))
# rot = :(impulse_map($relative, joint.rotational,
# $pbody, $cbody,
# joint.impulses[2][joint_impulse_index(joint, 2)]))
# return :(hcat($tra, $rot))
# end
# impulses Jacobians
function impulses_jacobian_velocity!(mechanism, body::Body, joint::JointConstraint)
# relative
relative = (body.id == joint.parent_id ? :parent : (body.id == joint.child_id ? :child : error()))
# time step
timestep= mechanism.timestep
# bodies
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
# springs
joint.spring && (body.state.D -= spring_jacobian_velocity(relative, relative, joint.translational, pbody, cbody, timestep))
joint.spring && (body.state.D -= spring_jacobian_velocity(relative, relative, joint.rotational, pbody, cbody, timestep))
# dampers
joint.damper && (body.state.D -= damper_jacobian_velocity(relative, relative, joint.translational, pbody, cbody, timestep))
joint.damper && (body.state.D -= damper_jacobian_velocity(relative, relative, joint.rotational, pbody, cbody, timestep))
return
end
# off-diagonal Jacobians
function off_diagonal_jacobians(mechanism, body::Body, joint::JointConstraint)
return -impulse_map(mechanism, joint, body), constraint_jacobian_configuration(mechanism, joint, body) * integrator_jacobian_velocity(body, mechanism.timestep)
end
function off_diagonal_jacobians(mechanism, joint::JointConstraint, body::Body)
return constraint_jacobian_configuration(mechanism, joint, body) * integrator_jacobian_velocity(body, mechanism.timestep), -impulse_map(mechanism, joint, body)
end
function off_diagonal_jacobians(mechanism, pbody::Body, cbody::Body)
# time step
timestep = mechanism.timestep
# dimensions
Ne = length(mechanism.joints)
Nb = length(mechanism.bodies)
Nc = length(mechanism.contacts)
# Jacobian
jacobian_parent_child = szeros(6, 6)
jacobian_child_parent = szeros(6, 6)
for connectionid in connections(mechanism.system, pbody.id)
# joints
if connectionid <= Ne
joint = get_node(mechanism, connectionid)
if pbody.id == joint.parent_id
for element in (joint.translational, joint.rotational)
if cbody.id == joint.child_id
joint.damper && (jacobian_parent_child -= damper_jacobian_velocity(:parent, :child, element, pbody, cbody, timestep))
joint.damper && (jacobian_child_parent -= damper_jacobian_velocity(:child, :parent, element, pbody, cbody, timestep))
end
end
elseif cbody.id == joint.parent_id
for element in (joint.translational, joint.rotational)
if pbody.id == joint.child_id
joint.damper && (jacobian_parent_child -= damper_jacobian_velocity(:parent, :child, element, cbody, pbody, timestep))
joint.damper && (jacobian_child_parent -= damper_jacobian_velocity(:child, :parent, element, cbody, pbody, timestep))
end
end
end
end
# contacts
if connectionid > Ne + Nb
contact = get_node(mechanism, connectionid)
if pbody.id == contact.parent_id
if cbody.id == contact.child_id
Jpc = impulse_map_jacobian(:parent, :child, contact.model,
pbody,
cbody,
contact.impulses[2],
mechanism.timestep) * integrator_jacobian_velocity(cbody, timestep)
Jcp = impulse_map_jacobian(:child, :parent, contact.model,
pbody,
cbody,
contact.impulses[2],
mechanism.timestep) * integrator_jacobian_velocity(pbody, timestep)
# impulse_map_jacobian_configuration(mechanism, body, contact) * integrator_jacobian_velocity(body, timestep)
# impulse_map(mechanism, contact, body) * contact.impulses[2]
jacobian_parent_child -= Jpc#damper_jacobian_velocity(:parent, :child, element, pbody, cbody, timestep)
jacobian_child_parent -= Jcp#damper_jacobian_velocity(:child, :parent, element, pbody, cbody, timestep)
end
elseif cbody.id == contact.parent_id
if pbody.id == contact.child_id
Jpc = impulse_map_jacobian(:parent, :child, contact.model,
cbody,
pbody,
contact.impulses[2],
mechanism.timestep) * integrator_jacobian_velocity(pbody, timestep)
Jcp = impulse_map_jacobian(:child, :parent, contact.model,
cbody,
bbody,
contact.impulses[2],
mechanism.timestep) * integrator_jacobian_velocity(cbody, timestep)
jacobian_parent_child -= Jpc #damper_jacobian_velocity(:parent, :child, element, cbody, pbody, timestep)
jacobian_child_parent -= Jcp #damper_jacobian_velocity(:child, :parent, element, cbody, pbody, timestep)
end
end
end
end
return jacobian_parent_child, jacobian_child_parent
end
# linear system
function set_matrix_vector_entries!(mechanism, matrix_entry::Entry, vector_entry::Entry, joint::JointConstraint)
matrix_entry.value = constraint_jacobian(joint)
vector_entry.value = -constraint(mechanism, joint)
end
# springs
function spring_impulses(mechanism, joint::JointConstraint{T}, body::Body{T};
unitary::Bool=false) where T
relative = (body.id == joint.parent_id ? :parent : :child)
impulses = szeros(T,6)
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
impulses += spring_impulses(relative, joint.translational,
pbody,
cbody,
mechanism.timestep,
unitary=unitary)
impulses += spring_impulses(relative, joint.rotational,
pbody,
cbody,
mechanism.timestep,
unitary=unitary)
return impulses
end
# dampers
function damper_impulses(mechanism, joint::JointConstraint{T}, body::Body;
unitary::Bool=false) where T
relative = (body.id == joint.parent_id ? :parent : :child)
impulses = szeros(T,6)
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
impulses += damper_impulses(relative, joint.translational,
pbody,
cbody,
mechanism.timestep,
unitary=unitary)
impulses += damper_impulses(relative, joint.rotational,
pbody,
cbody,
mechanism.timestep,
unitary=unitary)
return impulses
end
# inputs
function set_input!(joint::JointConstraint{T,N,Nc}, input::AbstractVector) where {T,N,Nc}
@assert length(input) == input_dimension(joint)
# translational
r_idx = SUnitRange(joint.minimal_index[1][1], joint.minimal_index[1][2])
length(r_idx) > 0 && set_input!(joint.translational, input[r_idx])
# rotational
r_idx = SUnitRange(joint.minimal_index[2][1], joint.minimal_index[2][2])
length(r_idx) > 0 && set_input!(joint.rotational, input[r_idx])
return
end
function add_input!(joint::JointConstraint{T,N,Nc}, input::AbstractVector) where {T,N,Nc}
@assert length(input) == input_dimension(joint)
add_input!(joint.translational, input[SUnitRange(joint.minimal_index[1][1], joint.minimal_index[1][2])])
add_input!(joint.rotational, input[SUnitRange(joint.minimal_index[2][1], joint.minimal_index[2][2])])
return
end
@generated function input_jacobian_control(mechanism, joint::JointConstraint{T,N,Nc}, body::Body) where {T,N,Nc}
relative = :(body.id == joint.parent_id ? :parent : :child)
pbody = :(get_body(mechanism, joint.parent_id))
cbody = :(get_body(mechanism, joint.child_id))
rot = :(input_jacobian_control($relative, joint.translational, $pbody, $cbody, mechanism.input_scaling))
tra = :(input_jacobian_control($relative, joint.rotational, $pbody, $cbody, mechanism.input_scaling))
return :(hcat($rot, $tra))
end
function input_impulse!(joint::JointConstraint{T,N,Nc}, mechanism, clear::Bool=true) where {T,N,Nc}
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
input_impulse!(joint.translational, pbody, cbody, mechanism.input_scaling, clear)
input_impulse!(joint.rotational, pbody, cbody, mechanism.input_scaling, clear)
return
end
# minimal
@generated function minimal_coordinates(mechanism, joint::JointConstraint{T,N,Nc}) where {T,N,Nc}
pbody = :(get_body(mechanism, joint.parent_id))
cbody = :(get_body(mechanism, joint.child_id))
tra = :(minimal_coordinates(joint.translational, $pbody, $cbody))
rot = :(minimal_coordinates(joint.rotational, $pbody, $cbody))
return :(svcat($tra, $rot))
end
@generated function minimal_velocities(mechanism, joint::JointConstraint{T,N,Nc}) where {T,N,Nc}
pbody = :(get_body(mechanism, joint.parent_id))
cbody = :(get_body(mechanism, joint.child_id))
tra = :(minimal_velocities(joint.translational, $pbody, $cbody, mechanism.timestep))
rot = :(minimal_velocities(joint.rotational, $pbody, $cbody, mechanism.timestep))
return :(svcat($tra, $rot))
end
################################################################################
# Utilities
################################################################################
function get_joint_impulses(joint::JointConstraint{T,N,Nc}, i::Int) where {T,N,Nc}
n1 = 1
for j = 1:i-1
n1 += impulses_length((joint.translational, joint.rotational)[j])
end
n2 = n1 - 1 + impulses_length((joint.translational, joint.rotational)[i])
λi = SVector{n2-n1+1,T}(joint.impulses[2][SUnitRange(n1,n2)])
return λi
end
function joint_impulse_index(joint::JointConstraint{T,N,Nc}, i::Int) where {T,N,Nc}
s = 0
for j = 1:i-1
element = (joint.translational, joint.rotational)[j]
s += impulses_length(element)
end
joint_impulse_index((joint.translational, joint.rotational)[i], s)
end
# function reset!(joint::JointConstraint{T,N,Nc};
# scale::T=1.0) where {T,N,Nc}
# λ = []
# for (i, element) in enumerate((joint.translational, joint.rotational))
# Nλ = joint_length(element)
# Nb = limits_length(element)
# push!(λ, [scale * sones(2Nb); szeros(Nλ)])
# end
# joint.impulses[1] = vcat(λ...)
# joint.impulses[2] = vcat(λ...)
# return
# end
function reset!(joint::JointConstraint{T,N,Nc}; scale::T=1.0) where {T,N,Nc}
Nλ_tra = joint_length(joint.translational)
Nb_tra = limits_length(joint.translational)
Nλ_rot = joint_length(joint.rotational)
Nb_rot = limits_length(joint.rotational)
joint.impulses[1] = [scale * sones(2Nb_tra); szeros(Nλ_tra); scale * sones(2Nb_rot); szeros(Nλ_rot)]
joint.impulses[2] = [scale * sones(2Nb_tra); szeros(Nλ_tra); scale * sones(2Nb_rot); szeros(Nλ_rot)]
return
end
function input_dimension(joint::JointConstraint{T,N,Nc};
ignore_floating_base::Bool=false) where {T,N,Nc}
ignore_floating_base && (N == 0) && return 0
N̄ = 0
N̄ = input_dimension(joint.translational) + input_dimension(joint.rotational)
return N̄
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1023 | ################################################################################
# Impulse Transform
################################################################################
function impulse_transform(relative::Symbol, joint::Joint, xa::AbstractVector,
qa::Quaternion, xb::AbstractVector, qb::Quaternion)
X, Q = displacement_jacobian_configuration(relative, joint, xa, qa, xb, qb, attjac=true)
Diagonal([sones(3); 0.5 * sones(3)]) * transpose([X Q]) #TODO: 0.5 Q
end
################################################################################
# Derivatives
################################################################################
function impulse_map_jacobian(relative::Symbol, jacobian::Symbol, joint::Joint, pbody::Node{T}, cbody::Node{T}, λ) where T
# ∂(G*λ)/∂(x,q)
p = impulse_projector(joint) * λ
impulse_transform_jacobian(relative, jacobian,
joint,
current_configuration(pbody.state)...,
current_configuration(cbody.state)...,
p)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 6223 | """
Joint{T}
Abstract type for 3-dimensional constraint between two Body objects
"""
abstract type Joint{T,Nλ,Nb,N,Nb½} end
# joints
function joint_constraint(joint::Joint{T},
xa::AbstractVector, qa::Quaternion, xb::AbstractVector, qb::Quaternion, η) where {T}
return constraint_mask(joint) * displacement(joint, xa, qa, xb, qb)
end
function joint_constraint_jacobian_configuration(relative::Symbol, joint::Joint{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion, η) where {T}
X, Q = displacement_jacobian_configuration(relative, joint, xa, qa, xb, qb, attjac=false)
return constraint_mask(joint) * [X Q]
end
# constraints
function constraint(joint::Joint{T,Nλ,0},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion, η, μ) where {T,Nλ}
joint_constraint(joint, xa, qa, xb, qb, η)
end
constraint(joint::Joint, pbody::Node, cbody::Node, λ, μ, timestep) =
constraint(joint, next_configuration(pbody.state, timestep)...,
next_configuration(cbody.state, timestep)..., λ, μ)
# constraint Jacobians
function constraint_jacobian(joint::Joint{T,Nλ,0}, η; reg::T=Dojo.REG) where {T,Nλ}
return Diagonal(reg * sones(T,Nλ))
end
function constraint_jacobian(joint::Joint{T,Nλ,Nb}, η; reg::T=Dojo.REG) where {T,Nλ,Nb}
s, γ = split_impulses(joint, η)
c1 = [Diagonal(γ + reg * sones(T, Nb)); Diagonal(sones(Nb)); szeros(Nλ, Nb)]
c2 = [Diagonal(s + reg * sones(T, Nb)); szeros(Nb, Nb); szeros(Nλ, Nb)]
c3 = [szeros(Nb, Nλ); szeros(Nb, Nλ); Diagonal(reg * sones(T, Nλ))]
return [c1 c2 c3]
end
constraint_jacobian_configuration(relative::Symbol, joint::Joint, pbody::Node, cbody::Node, λ, timestep) =
constraint_jacobian_configuration(relative, joint, next_configuration(pbody.state, timestep)...,
next_configuration(cbody.state, timestep)..., λ)
function constraint_jacobian_configuration(relative::Symbol, joint::Joint{T,Nλ,0},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion, η) where {T,Nλ}
joint_constraint_jacobian_configuration(relative, joint, xa, qa, xb, qb, η)
end
# masks
constraint_mask(::Joint{T,0}) where T = szeros(T,0,3)
constraint_mask(joint::Joint{T,1}) where T = joint.axis_mask3
constraint_mask(joint::Joint{T,2}) where T = [joint.axis_mask1; joint.axis_mask2]
constraint_mask(::Joint{T,3}) where T = SMatrix{3,3,T,9}(I)
nullspace_mask(::Joint{T,0}) where T = SMatrix{3,3,T,9}(I)
nullspace_mask(joint::Joint{T,1}) where T = [joint.axis_mask1; joint.axis_mask2]
nullspace_mask(joint::Joint{T,2}) where T = joint.axis_mask3
nullspace_mask(::Joint{T,3}) where T = szeros(T,0,3)
# impulse maps
impulse_map(relative::Symbol, joint::Joint, pbody::Node, cbody::Node, λ) =
impulse_map(relative, joint, current_configuration(pbody.state)...,
current_configuration(cbody.state)..., λ)
function impulse_map(relative::Symbol, joint::Joint{T,Nλ,Nb},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
η) where {T,Nλ,Nb}
return impulse_transform(relative, joint, xa, qa, xb, qb) * impulse_projector(joint)
end
function impulse_map(relative::Symbol, joint::Joint{T,Nλ,0},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
η) where {T,Nλ}
J = constraint_jacobian_configuration(relative, joint, xa, qa, xb, qb, η)
G = [[Diagonal(sones(T,3)) szeros(T,3,3)]; [szeros(4,3) LVᵀmat(relative == :parent ? qa : qb)]]
return Diagonal([sones(3); 0.5 * sones(3)]) * transpose(J * G)
end
function impulse_projector(joint::Joint{T,Nλ,0}) where {T,Nλ}
zerodimstaticadjoint(constraint_mask(joint))
end
function impulse_projector(joint::Joint{T,Nλ,Nb}) where {T,Nλ,Nb}
zerodimstaticadjoint([szeros(Nb,3); -nullspace_mask(joint); nullspace_mask(joint); constraint_mask(joint)])
end
# inputs
function set_input!(joint::Joint, input::SVector)
joint.input = zerodimstaticadjoint(nullspace_mask(joint)) * input
return
end
set_input!(joint::Joint) = return
function add_input!(joint::Joint, input::SVector)
joint.input += zerodimstaticadjoint(nullspace_mask(joint)) * input
return
end
add_input!(joint::Joint) = return
function input_jacobian_control(relative::Symbol, joint::Joint, pbody::Node, cbody::Node, input_scaling)
return input_jacobian_control(relative, joint, current_configuration(pbody.state)...,
current_configuration(cbody.state)..., input_scaling) * zerodimstaticadjoint(nullspace_mask(joint))
end
# minimal coordinates
minimal_coordinates(joint::Joint{T,Nλ}) where {T,Nλ} = szeros(T, 3 - Nλ)
function minimal_coordinates(joint::Joint, pbody::Node, cbody::Node)
return minimal_coordinates(joint, current_configuration(pbody.state)..., current_configuration(cbody.state)...)
end
function minimal_velocities(joint::Joint, pnode::Node, cnode::Node, timestep)
minimal_velocities(joint, initial_configuration_velocity(pnode.state)...,
initial_configuration_velocity(cnode.state)..., timestep)
end
################################################################################
# Utilities
################################################################################
Base.length(joint::Joint{T,Nλ}) where {T,Nλ} = Nλ
Base.zero(joint::Joint{T,Nλ}) where {T,Nλ} = szeros(T, Nλ, 6)
joint_length(joint::Joint{T,Nλ}) where {T,Nλ} = Nλ
limits_length(joint::Joint{T,Nλ,Nb}) where {T,Nλ,Nb} = Nb
impulses_length(joint::Joint{T,Nλ,Nb,N}) where {T,Nλ,Nb,N} = N
function split_impulses(joint::Joint{T,Nλ,Nb}, η) where {T,Nλ,Nb}
s = η[SUnitRange(1,Nb)]
γ = η[SUnitRange(Nb+1,2*Nb)]
return s, γ
end
function joint_impulse_index(joint::Joint{T,Nλ,Nb,N}, s::Int) where {T,Nλ,Nb,N}
ind = SVector{N,Int}(s+1:s+N)
return ind
end
input_dimension(joint::Joint{T,N}) where {T,N} = 3 - N
function displacement_jacobian_configuration(relative::Symbol, joint::Joint{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
attjac::Bool=true) where T
X, Q = displacement_jacobian_configuration(relative, joint, xa, qa, xb, qb)
G = relative == :parent ? LVᵀmat(qa) : LVᵀmat(qb)
if attjac
Q = Q * G
return X, Q::SMatrix{3,3,T,9}
else
return X, Q::SMatrix{3,4,T,12}
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2235 | function constraint(joint::Joint{T,Nλ,Nb,N,Nb½},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
η, μ) where {T,Nλ,Nb,N,Nb½}
e1 = joint_constraint(joint, xa, qa, xb, qb, η)
e2 = minimal_coordinates(joint, xa, qa, xb, qb)
s, γ = split_impulses(joint, η)
return [
s .* γ .- μ;
s[SUnitRange(1,Nb½)] - (joint.joint_limits[2] .- e2);
s[SUnitRange(Nb½+1,Nb)] - (e2 .- joint.joint_limits[1]);
e1;
]
end
function constraint_jacobian_configuration(relative::Symbol, joint::Joint{T,Nλ,Nb},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
η) where {T,Nλ,Nb}
∇comp = szeros(T,Nb,7)
∇mincoord = minimal_coordinates_jacobian_configuration(relative, joint, xa, qa, xb, qb, attjac=false)
∇unlim = joint_constraint_jacobian_configuration(relative, joint, xa, qa, xb, qb, η)
return [∇comp; ∇mincoord; -∇mincoord; ∇unlim]
end
function add_limits(mech::Mechanism, joint::JointConstraint;
# NOTE: this only works for joints between serial chains (ie, single child joints)
tra_limits=joint.translational.joint_limits,
rot_limits=joint.rotational.joint_limits)
# update translational
tra = joint.translational
T = typeof(tra).parameters[1]
Nλ = typeof(tra).parameters[2]
Nb½ = length(tra_limits[1])
Nb = 2Nb½
N̄λ = 3 - Nλ
N = Nλ + 2Nb
tra_limit = (Translational{T,Nλ,Nb,N,Nb½,N̄λ}(tra.axis, tra.axis_mask1, tra.axis_mask2, tra.axis_mask3,
tra.vertices, tra.spring, tra.damper, tra.spring_offset, tra_limits,
tra.spring_type, tra.input), joint.parent_id, joint.child_id)
# update rotational
rot = joint.rotational
T = typeof(rot).parameters[1]
Nλ = typeof(rot).parameters[2]
Nb½ = length(rot_limits[1])
Nb = 2Nb½
N̄λ = 3 - Nλ
N = Nλ + 2Nb
rot_limit = (Rotational{T,Nλ,Nb,N,Nb½,N̄λ}(rot.axis, rot.axis_mask1, rot.axis_mask2, rot.axis_mask3,
rot.orientation_offset, rot.spring, rot.damper, rot.spring_offset, rot_limits,
rot.spring_type, rot.input), joint.parent_id, joint.child_id)
JointConstraint((tra_limit, rot_limit); name=joint.name)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 15419 | ################################################################################
# Coordinates
################################################################################
function minimal_coordinates(joint::JointConstraint, pbody::Node, cbody::Node)
Δx = minimal_coordinates(joint.translational, current_configuration(pbody.state)..., current_configuration(cbody.state)...)
Δθ = minimal_coordinates(joint.rotational, current_configuration(pbody.state)..., current_configuration(cbody.state)...)
return [Δx; Δθ]
end
function set_minimal_coordinates!(joint::JointConstraint, pnode::Node, cnode::Node,
timestep;
Δx::AbstractVector=szeros(input_dimension(joint.translational)),
Δθ::AbstractVector=szeros(input_dimension(joint.rotational)))
set_minimal_coordinates!(joint.rotational, pnode, cnode, timestep; Δθ=Δθ)
set_minimal_coordinates!(joint.translational, pnode, cnode, timestep; Δx=Δx)
return nothing
end
function set_minimal_coordinates!(mechanism, joint::JointConstraint{T,N,Nc}, xθ; iter=true, exclude_ids=Int64[]) where {T,N,Nc}
# bodies
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
# unpack
Δx = xθ[SUnitRange(joint.minimal_index[1][1], joint.minimal_index[1][2])]
Δθ = xθ[SUnitRange(joint.minimal_index[2][1], joint.minimal_index[2][2])]
# set
current_coordinates = get_minimal_coordinates(mechanism)
set_minimal_coordinates!(joint, pbody, cbody, mechanism.timestep, Δx=Δx, Δθ=Δθ)
# recursive update down the kinematic chain
if iter
for id in recursivedirectchildren!(mechanism.system, joint.id)
id in exclude_ids && continue # skip loop joints
node = get_node(mechanism, id)
if node isa JointConstraint
set_minimal_coordinates!(mechanism, node, current_coordinates[id])
end
end
end
end
################################################################################
# Velocities
################################################################################
function minimal_velocities(joint::JointConstraint, pnode::Node, cnode::Node, timestep)
Δv = minimal_velocities(joint.translational, pnode, cnode, timestep)
Δω = minimal_velocities(joint.rotational, pnode, cnode, timestep)
return [Δv; Δω]
end
function set_minimal_velocities!(joint::JointConstraint, pnode::Node, cnode::Node, timestep;
Δv=szeros(input_dimension(joint.translational)),
Δω=szeros(input_dimension(joint.rotational)))
# get
vb, ωb = get_child_velocity(joint,
initial_configuration_velocity(pnode.state)...,
current_configuration(cnode.state)...,
timestep,
Δv=Δv, Δω=Δω)
# set
set_maximal_velocities!(cnode; v=vb, ω=ωb)
set_previous_configuration!(cnode, timestep)
return nothing
end
function set_minimal_velocities!(mechanism, joint::JointConstraint{T,N,Nc}, vω) where {T,N,Nc}
# bodies
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
# unpack
Δv = vω[SUnitRange(joint.minimal_index[1][1], joint.minimal_index[1][2])]
Δω = vω[SUnitRange(joint.minimal_index[2][1], joint.minimal_index[2][2])]
# set
set_minimal_velocities!(joint, pbody, cbody, mechanism.timestep, Δv=Δv, Δω=Δω)
return
end
function get_child_velocity(joint::JointConstraint,
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, qb::Quaternion,
timestep;
Δv=szeros(input_dimension(joint.translational)),
Δω=szeros(input_dimension(joint.rotational)))
rot = joint.rotational
tra = joint.translational
pa = tra.vertices[1]
pb = tra.vertices[2]
orientation_offset = rot.orientation_offset
Arot = zerodimstaticadjoint(nullspace_mask(rot))
Atra = zerodimstaticadjoint(nullspace_mask(tra))
Δx = minimal_coordinates(joint.translational, xa, qa, xb, qb)
Δq = inv(orientation_offset) * inv(qa) * qb
# 1 step backward in time
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
# Finite difference
Δx1 = Δx .- Δv * timestep
Δq1 = Δq * inv(axis_angle_to_quaternion(Arot * Δω * timestep))
qb1 = qa1 * orientation_offset * Δq1
xb1 = xa1 + vector_rotate(pa + Atra * Δx1, qa1) - vector_rotate(pb, qb1)
# Finite difference
vb = (xb - xb1) / timestep
ωb = angular_velocity(qb1, qb, timestep)
return vb, ωb
end
################################################################################
# Coordinates and Velocities
################################################################################
function minimal_coordinates_velocities(joint::JointConstraint, pnode::Node, cnode::Node, timestep)
Δxθ = minimal_coordinates(joint, pnode, cnode)
Δvω = minimal_velocities(joint, pnode, cnode, timestep)
return [Δxθ; Δvω]
end
function set_minimal_coordinates_velocities!(mechanism::Mechanism, joint::JointConstraint;
xmin::AbstractVector=szeros(2*input_dimension(joint)))
pnode = get_body(mechanism, joint.parent_id)
cnode = get_body(mechanism, joint.child_id)
xa = pnode.state.x2
va = pnode.state.v15
qa = pnode.state.q2
ωa = pnode.state.ω15
za = [xa; va; vector(qa); ωa]
set_minimal_coordinates_velocities!(joint, pnode, cnode, mechanism.timestep; xmin=xmin, zp=za)
end
function set_minimal_coordinates_velocities!(joint::JointConstraint,
pbody::Node, cbody::Node,
timestep;
zp::AbstractVector=[pbody.state.x2; pbody.state.v15; vector(pbody.state.q2); pbody.state.ω15],
xmin::AbstractVector=szeros(2*input_dimension(joint)))
nu = input_dimension(joint)
Δx = xmin[SUnitRange(joint.minimal_index[1]...)]
Δθ = xmin[SUnitRange(joint.minimal_index[2]...)]
Δv = xmin[nu .+ SUnitRange(joint.minimal_index[1]...)]
Δω = xmin[nu .+ SUnitRange(joint.minimal_index[2]...)]
rot = joint.rotational
tra = joint.translational
pa = tra.vertices[1]
pb = tra.vertices[2]
orientation_offset = rot.orientation_offset
Arot = zerodimstaticadjoint(nullspace_mask(rot))
Atra = zerodimstaticadjoint(nullspace_mask(tra))
# parent state
xa = SVector{3}(zp[SA[1;2;3]])
va = SVector{3}(zp[SA[4;5;6]])
qa = Quaternion(zp[SA[7;8;9;10]]...)
ωa = SVector{3}(zp[SA[11;12;13]])
# positions
Δq = axis_angle_to_quaternion(Arot * Δθ)
qb = qa * orientation_offset * Δq
xb = xa + vector_rotate(pa + Atra * Δx, qa) - vector_rotate(pb, qb)
# previous configuration
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
# finite-difference configuration
Δx1 = Δx .- Δv * timestep
Δq1 = Δq * inv(axis_angle_to_quaternion(Arot * Δω * timestep))
qb1 = qa1 * orientation_offset * Δq1
xb1 = xa1 + vector_rotate(pa + Atra * Δx1, qa1) - vector_rotate(pb, qb1)
# finite-difference velocity
vb = (xb - xb1) / timestep
ωb = angular_velocity(qb1, qb, timestep)
# set child state
cbody.state.x2 = xb
cbody.state.v15 = vb
cbody.state.q2 = qb
cbody.state.ω15 = ωb
return [xb; vb; vector(qb); ωb]
end
function minimal_coordinates_velocities_jacobian_parent(joint::JointConstraint{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
timestep;
Δx=szeros(input_dimension(joint.translational)),
Δθ=szeros(input_dimension(joint.rotational)),
Δv=szeros(input_dimension(joint.translational)),
Δω=szeros(input_dimension(joint.rotational))) where T
rot = joint.rotational
tra = joint.translational
pa = tra.vertices[1]
pb = tra.vertices[2]
orientation_offset = rot.orientation_offset
Arot = zerodimstaticadjoint(nullspace_mask(rot))
Atra = zerodimstaticadjoint(nullspace_mask(tra))
# positions
Δq = axis_angle_to_quaternion(Arot * Δθ)
qb = qa * orientation_offset * Δq
xb = xa + vector_rotate(pa + Atra * Δx, qa) - vector_rotate(pb, qb)
# step backward in time
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
# step backward in time
Δx1 = Δx .- Δv * timestep
Δq1 = Δq * inv(axis_angle_to_quaternion(Arot * Δω * timestep))
qb1 = qa1 * orientation_offset * Δq1
xb1 = xa1 + vector_rotate(pa + Atra * Δx1, qa1) - vector_rotate(pb, qb1)
# Jacobians
∂xb∂xa = 1.0 * sI(3)
∂xb∂va = szeros(T, 3, 3)
∂xb∂qa = ∂vector_rotate∂q(pa + Atra * Δx, qa)
∂xb∂qa += -∂vector_rotate∂q(pb, qb) * Rmat(orientation_offset * axis_angle_to_quaternion(Arot * Δθ))
∂xb∂ωa = szeros(T, 3, 3)
∂qb∂xa = szeros(T, 4, 3)
∂qb∂va = szeros(T, 4, 3)
∂qb∂qa = Rmat(orientation_offset * axis_angle_to_quaternion(Arot * Δθ))
∂qb∂ωa = szeros(T, 4, 3)
∂vb∂xa = szeros(T, 3, 3)
∂vb∂va = 1.0 * sI(3)
∂vb∂qa = 1.0 / timestep * ∂vector_rotate∂q(pa + Atra * Δx, qa)
∂vb∂qa -= 1.0 / timestep * ∂vector_rotate∂q(pb, qb) * Rmat(orientation_offset * Δq)
∂vb∂qa += -1.0 / timestep * ∂vector_rotate∂q(pa + Atra * Δx1, qa1) * rotational_integrator_jacobian_orientation(qa, -ωa, timestep, attjac=false)
∂vb∂qa += 1.0 / timestep * ∂vector_rotate∂q(pb, qb1) * Rmat(orientation_offset * Δq1) * rotational_integrator_jacobian_orientation(qa, -ωa, timestep, attjac=false)
∂vb∂ωa = 1.0 / timestep * ∂vector_rotate∂q(pa + Atra * Δx1, qa1) * rotational_integrator_jacobian_velocity(qa, -ωa, timestep)
∂vb∂ωa += -1.0 / timestep * ∂vector_rotate∂q(pb, qb1) * Rmat(orientation_offset * Δq1) * rotational_integrator_jacobian_velocity(qa, -ωa, timestep)
∂ωb∂xa = szeros(T, 3, 3)
∂ωb∂va = szeros(T, 3, 3)
∂ωb∂qa = ∂angular_velocity∂q1(qb1, qb, timestep) * Rmat(orientation_offset * Δq1) * rotational_integrator_jacobian_orientation(qa, -ωa, timestep, attjac=false)
∂ωb∂qa += ∂angular_velocity∂q2(qb1, qb, timestep) * Rmat(orientation_offset * Δq)
∂ωb∂ωa = -1.0 * ∂angular_velocity∂q1(qb1, qb, timestep) * Rmat(orientation_offset * Δq1) * rotational_integrator_jacobian_velocity(qa, -ωa, timestep)
[
∂xb∂xa ∂xb∂va ∂xb∂qa ∂xb∂ωa;
∂vb∂xa ∂vb∂va ∂vb∂qa ∂vb∂ωa;
∂qb∂xa ∂qb∂va ∂qb∂qa ∂qb∂ωa;
∂ωb∂xa ∂ωb∂va ∂ωb∂qa ∂ωb∂ωa;
]
end
function set_minimal_coordinates_velocities_jacobian_parent(joint::JointConstraint,
pnode::Node, cnode::Node, timestep)
xmin = minimal_coordinates_velocities(joint, pnode, cnode, timestep)
qb = current_orientation(cnode.state)
xa, va, qa, ωa = initial_configuration_velocity(pnode.state)
za = [xa; va; vector(qa); ωa]
nu = input_dimension(joint)
Δx = xmin[SUnitRange(joint.minimal_index[1]...)]
Δθ = xmin[SUnitRange(joint.minimal_index[2]...)]
Δv = xmin[nu .+ SUnitRange(joint.minimal_index[1]...)]
Δω = xmin[nu .+ SUnitRange(joint.minimal_index[2]...)]
J = minimal_coordinates_velocities_jacobian_parent(joint,
xa, va, qa, ωa,
timestep;
Δx=Δx,
Δθ=Δθ,
Δv=Δv,
Δω=Δω)
J = cat(Diagonal(sones(6)), LVᵀmat(qb)', Diagonal(sones(3)), dims=(1,2)) * J
J = J * cat(Diagonal(sones(6)), LVᵀmat(qa), Diagonal(sones(3)), dims=(1,2))
return J
end
function minimal_coordinates_velocities_jacobian_minimal(joint::JointConstraint{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
timestep;
Δx=szeros(input_dimension(joint.translational)),
Δθ=szeros(input_dimension(joint.rotational)),
Δv=szeros(input_dimension(joint.translational)),
Δω=szeros(input_dimension(joint.rotational))) where T
rot = joint.rotational
tra = joint.translational
pa = tra.vertices[1]
pb = tra.vertices[2]
orientation_offset = rot.orientation_offset
Arot = zerodimstaticadjoint(nullspace_mask(rot))
Atra = zerodimstaticadjoint(nullspace_mask(tra))
# positions
Δq = axis_angle_to_quaternion(Arot * Δθ)
qb = qa * orientation_offset * Δq
xb = xa + vector_rotate(pa + Atra * Δx, qa) - vector_rotate(pb, qb)
# step backward in time
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
# step backward in time
Δq = axis_angle_to_quaternion(Arot * Δθ)
Δx1 = Δx .- Δv * timestep
Δq1 = Δq * inv(axis_angle_to_quaternion(Arot * Δω * timestep))
qb1 = qa1 * orientation_offset * Δq1
xb1 = xa1 + vector_rotate(pa + Atra * Δx1, qa1) - vector_rotate(pb, qb1)
# Jacobians
∂xb∂Δx = rotation_matrix(qa) * Atra
∂xb∂Δθ = -∂vector_rotate∂q(pb, qb) * Lmat(qa * orientation_offset) * daxis_angle_to_quaterniondx(Arot * Δθ) * Arot
∂xb∂Δv = szeros(T, 3, input_dimension(joint.translational))
∂xb∂Δω = szeros(T, 3, input_dimension(joint.rotational))
∂qb∂Δx = szeros(T, 4, input_dimension(joint.translational))
∂qb∂Δθ = Lmat(qa * orientation_offset) * daxis_angle_to_quaterniondx(Arot * Δθ) * Arot
∂qb∂Δv = szeros(T, 4, input_dimension(joint.translational))
∂qb∂Δω = szeros(T, 4, input_dimension(joint.rotational))
∂vb∂Δx = 1 / timestep * rotation_matrix(qa) * Atra
∂vb∂Δx += -1 / timestep * rotation_matrix(qa1) * Atra
∂vb∂Δθ = -1.0 / timestep * ∂vector_rotate∂q(pb, qb) * Lmat(qa * orientation_offset) * daxis_angle_to_quaterniondx(Arot * Δθ) * Arot
∂vb∂Δθ += 1.0 / timestep * ∂vector_rotate∂q(pb, qb1) * Rmat(inv(axis_angle_to_quaternion(Arot * Δω * timestep))) * Lmat(qa1 * orientation_offset) * daxis_angle_to_quaterniondx(Arot * Δθ) * Arot
∂vb∂Δv = rotation_matrix(qa1) * Atra
∂vb∂Δω = ∂vector_rotate∂q(pb, qb1) * Lmat(qa1 * orientation_offset * Δq) * Tmat() * daxis_angle_to_quaterniondx(Arot * Δω * timestep) * Arot
∂ωb∂Δx = szeros(T, 3, input_dimension(joint.translational))
∂ωb∂Δθ = ∂angular_velocity∂q1(qb1, qb, timestep) * Rmat(inv(axis_angle_to_quaternion(Arot * Δω * timestep))) * Lmat(qa1 * orientation_offset) * daxis_angle_to_quaterniondx(Arot * Δθ) * Arot
∂ωb∂Δθ += ∂angular_velocity∂q2(qb1, qb, timestep) * Lmat(qa * orientation_offset) * daxis_angle_to_quaterniondx(Arot * Δθ) * Arot
∂ωb∂Δv = szeros(3, input_dimension(joint.translational))
∂ωb∂Δω = ∂angular_velocity∂q1(qb1, qb, timestep) * Lmat(qa1 * orientation_offset * Δq) * Tmat() * daxis_angle_to_quaterniondx(Arot * Δω * timestep) * Arot * timestep
[
∂xb∂Δx ∂xb∂Δθ ∂xb∂Δv ∂xb∂Δω;
∂vb∂Δx ∂vb∂Δθ ∂vb∂Δv ∂vb∂Δω;
∂qb∂Δx ∂qb∂Δθ ∂qb∂Δv ∂qb∂Δω;
∂ωb∂Δx ∂ωb∂Δθ ∂ωb∂Δv ∂ωb∂Δω;
]
end
function set_minimal_coordinates_velocities_jacobian_minimal(joint::JointConstraint,
pnode::Node, cnode::Node, timestep)
xmin = minimal_coordinates_velocities(joint, pnode, cnode, timestep)
qb = current_orientation(cnode.state)
xa, va, qa, ωa = initial_configuration_velocity(pnode.state)
za = [xa; va; vector(qa); ωa]
nu = input_dimension(joint)
Δx = xmin[SUnitRange(joint.minimal_index[1]...)]
Δθ = xmin[SUnitRange(joint.minimal_index[2]...)]
Δv = xmin[nu .+ SUnitRange(joint.minimal_index[1]...)]
Δω = xmin[nu .+ SUnitRange(joint.minimal_index[2]...)]
J = minimal_coordinates_velocities_jacobian_minimal(joint,
xa, va, qa, ωa,
timestep;
Δx=Δx,
Δθ=Δθ,
Δv=Δv,
Δω=Δω)
J = cat(Diagonal(sones(6)), LVᵀmat(qb)', Diagonal(sones(3)), dims=(1,2)) * J
return J
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 420 | function orthogonal_rows(axis::AbstractVector)
if norm(axis) > 0
axis = normalize(axis)
end
A = svd(skew(axis)).Vt
inds = SA[1; 2; 3]
V1 = A[1,inds]'
V2 = A[2,inds]'
V3 = axis' # instead of A[3,:] for correct sign: abs(axis) = abs(A[3,:])
return V1, V2, V3
end
function orthogonal_columns(axis::AbstractVector)
V1, V2, V3 = orthogonal_rows(axis)
return V1', V2', V3'
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 20121 | """
Fixed{T} <: JointConstraint{T}
fixed connection between two bodies
"""
Fixed(pbody::Node{T}, cbody::Node{T};
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T})) where T =
Translational{T,3}(pbody, cbody;
parent_vertex,
child_vertex),
Rotational{T,3}(pbody, cbody;
orientation_offset)
"""
Prismatic{T} <: JointConstraint{T}
one translational degree of freedom between two bodies
"""
Prismatic(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,1),
tra_joint_limits=[szeros(T,0), szeros(T,0)]) where T =
Translational{T,2}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,3}(pbody, cbody;
orientation_offset,
spring,
damper)
"""
Planar{T} <: JointConstraint{T}
two translational degree of freedom between two bodies
"""
Planar(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,2),
tra_joint_limits=[szeros(T,0), szeros(T,0)]) where T =
Translational{T,1}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,3}(pbody, cbody;
orientation_offset,
spring,
damper)
"""
FixedOrientation{T} <: JointConstraint{T}
three translational degree of freedom between two bodies
"""
FixedOrientation(pbody::Node{T}, cbody::Node{T};
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,3),
tra_joint_limits=[szeros(T,0), szeros(T,0)]) where T =
Translational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,3}(pbody, cbody;
orientation_offset,
spring,
damper)
"""
Revolute{T} <: JointConstraint{T}
one rotational degree of freedom between two bodies
"""
Revolute(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
rot_spring_offset=szeros(T,1),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,3}(pbody, cbody;
parent_vertex,
child_vertex,
spring,
damper),
Rotational{T,2}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
Cylindrical{T} <: JointConstraint{T}
one translational and one rotational degree of freedom between two bodies
"""
Cylindrical(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,1),
rot_spring_offset=szeros(T,1),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,2}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,2}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
PlanarAxis{T} <: JointConstraint{T}
two translational and one rotational degree of freedom between two bodies
"""
PlanarAxis(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,2),
rot_spring_offset=szeros(T,1),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,1}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,2}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
FreeRevolute{T} <: JointConstraint{T}
free translation with rotation along one axis
"""
FreeRevolute(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,3),
rot_spring_offset=szeros(T,1),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,2}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
Orbital{T} <: JointConstraint{T}
two rotational degrees of freedom between two bodies
"""
Orbital(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
rot_spring_offset=szeros(T,2),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,3}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper),
Rotational{T,1}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
PrismaticOrbital{T} <: JointConstraint{T}
one translational and two rotational degrees of freedom between two bodies
"""
PrismaticOrbital(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,1),
rot_spring_offset=szeros(T,2),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,2}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,1}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
PlanarOrbital{T} <: JointConstraint{T}
two translational and two rotational degrees of freedom between two bodies
"""
PlanarOrbital(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,2),
rot_spring_offset=szeros(T,2),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,1}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,1}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
FreeOrbital{T} <: JointConstraint{T}
three translational and two rotational degrees of freedom between two bodies
"""
FreeOrbital(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,3),
rot_spring_offset=szeros(T,2),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,1}(pbody, cbody;
axis,
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
Spherical{T} <: JointConstraint{T}
three rotational degrees of freedom between two bodies
"""
Spherical(pbody::Node{T}, cbody::Node{T};
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
rot_spring_offset=szeros(T,3),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,3}(pbody, cbody;
parent_vertex,
child_vertex,
spring,
damper),
Rotational{T,0}(pbody, cbody;
orientation_offset,
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
CylindricalFree{T} <: JointConstraint{T}
one translational and three rotational degrees of freedom between two bodies
"""
CylindricalFree(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
spring=zero(T), damper=zero(T),
tra_spring_offset=szeros(T,1),
rot_spring_offset=szeros(T,3),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,2}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
PlanarFree{T} <: JointConstraint{T}
two translational and three rotational degrees of freedom between two bodies
"""
PlanarFree(pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
spring=zero(T),
damper= zero(T),
tra_spring_offset=szeros(T,2),
rot_spring_offset=szeros(T,3),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,1}(pbody, cbody;
parent_vertex,
child_vertex,
axis,
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
"""
Floating{T} <: JointConstraint{T}
no restricted degrees of freedom between two bodies
"""
Floating(pbody::Node{T}, cbody::Node{T};
spring=zero(T),
damper=zero(T),
tra_spring_offset=szeros(T,3),
rot_spring_offset=szeros(T,3),
rot_joint_limits=[szeros(T,0), szeros(T,0)],
tra_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T =
Translational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=tra_spring_offset,
joint_limits=tra_joint_limits),
Rotational{T,0}(pbody, cbody;
spring,
damper,
spring_offset=rot_spring_offset,
joint_limits=rot_joint_limits,
spring_type=spring_type)
function Prototype(joint_type::Symbol, pbody::Node{T}, cbody::Node{T}, axis;
parent_vertex=szeros(T, 3),
child_vertex=szeros(T, 3),
orientation_offset=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
tra_spring_offset=nothing,
rot_spring_offset=nothing,
tra_joint_limits=[szeros(T,0), szeros(T,0)],
rot_joint_limits=[szeros(T,0), szeros(T,0)],
spring_type=:linear) where T
N̄tra, N̄rot = nullspace_dimension(joint_type)
(tra_spring_offset === nothing) && (tra_spring_offset = szeros(T,N̄tra))
(rot_spring_offset === nothing) && (rot_spring_offset = szeros(T,N̄rot))
(joint_type == :Fixed) && (return Fixed(pbody, cbody; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset))
(joint_type == :Prismatic) && (return Prismatic(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, tra_joint_limits=tra_joint_limits))
(joint_type == :Planar) && (return Planar(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, tra_joint_limits=tra_joint_limits))
(joint_type == :FixedOrientation) && (return FixedOrientation(pbody, cbody; orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, tra_joint_limits=tra_joint_limits))
(joint_type == :Revolute) && (return Revolute(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, rot_spring_offset=rot_spring_offset, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :Cylindrical) && (return Cylindrical(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :PlanarAxis) && (return PlanarAxis(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :FreeRevolute) && (return FreeRevolute(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :Orbital) && (return Orbital(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, rot_spring_offset=rot_spring_offset, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :PrismaticOrbital) && (return PrismaticOrbital(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :PlanarOrbital) && (return PlanarOrbital(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :FreeOrbital) && (return FreeOrbital(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :Spherical) && (return Spherical(pbody, cbody; parent_vertex=parent_vertex, child_vertex=child_vertex, orientation_offset=orientation_offset, spring=spring, damper=damper, rot_spring_offset=rot_spring_offset, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :CylindricalFree) && (return CylindricalFree(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :PlanarFree) && (return PlanarFree(pbody, cbody, axis; parent_vertex=parent_vertex, child_vertex=child_vertex, spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
(joint_type == :Floating) && (return Floating(pbody, cbody; spring=spring, damper=damper, tra_spring_offset=tra_spring_offset, rot_spring_offset=rot_spring_offset, tra_joint_limits=tra_joint_limits, rot_joint_limits=rot_joint_limits, spring_type=spring_type))
end
function nullspace_dimension(joint_type::Symbol)
(joint_type == :Fixed) && (return 0, 0)
(joint_type == :Prismatic) && (return 1, 0)
(joint_type == :Planar) && (return 2, 0)
(joint_type == :FixedOrientation) && (return 3, 0)
(joint_type == :Revolute) && (return 0, 1)
(joint_type == :Cylindrical) && (return 1, 1)
(joint_type == :PlanarAxis) && (return 2, 1)
(joint_type == :FreeRevolute) && (return 3, 1)
(joint_type == :Orbital) && (return 0, 2)
(joint_type == :PrismaticOrbital) && (return 1, 2)
(joint_type == :PlanarOrbital) && (return 2, 2)
(joint_type == :FreeOrbital) && (return 3, 2)
(joint_type == :Spherical) && (return 0, 3)
(joint_type == :CylindricalFree) && (return 1, 3)
(joint_type == :PlanarFree) && (return 2, 3)
(joint_type == :Floating) && (return 3, 3)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3038 | """
Rotational{T} <: Joint{T}
constraint limiting rotational degrees of freedom
axis: rotation axis in parent offset frame
axis_mask1: rotation axis mask in pbody's frame
axis_mask2: rotation axis mask in pbody's frame
axis_mask3: rotation axis mask in pbody's frame
orientation_offset: rotation axis offset from pbody's frame
spring :coefficient for joint spring
damper: coefficient for joint damper
spring_offset: nominal joint configuration
joint_limits: lower and upper limits on the joint configuration
spring_type: can be :linear or :sinusoidal (currently not implemented), if linear then we need joint_limits to avoid the 360° singularity.
input: external impulse torque
"""
mutable struct Rotational{T,Nλ,Nb,N,Nb½,N̄λ} <: Joint{T,Nλ,Nb,N,Nb½}
axis::SVector{3,T} # rotation axis in parent offset frame
axis_mask1::Adjoint{T,SVector{3,T}} # in pbody's frame
axis_mask2::Adjoint{T,SVector{3,T}} # in pbody's frame
axis_mask3::Adjoint{T,SVector{3,T}} # in pbody's frame
orientation_offset::Quaternion{T} # in pbody's frame
spring::T
damper::T
spring_offset::SVector{N̄λ,T}
joint_limits::Vector{SVector{Nb½,T}} # lower and upper limits on the joint minimal coordinate angles
spring_type::Symbol # the rotational springs can be :linear or :sinusoidal (currently not implemented), if linear then we need joint_limits to avoid the 360° singularity.
input::SVector{3,T} # joint input. torque if mechanism.input_scaling = timestep, impulse if mechanism.input_scaling = 1
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, joint::Rotational{T,N}) where {T,N}
summary(io, joint)
println(io,"")
println(io, " axis: "*string(joint.axis))
println(io, " axis_mask1: "*string(joint.axis_mask1))
println(io, " axis_mask2: "*string(joint.axis_mask2))
println(io, " axis_mask3: "*string(joint.axis_mask3))
println(io, " orientation_offset: "*string(joint.orientation_offset))
println(io, " spring: "*string(joint.spring))
println(io, " damper: "*string(joint.damper))
println(io, " spring_offset: "*string(joint.spring_offset))
println(io, " joint_limits: "*string(joint.joint_limits))
println(io, " spring_type: "*string(joint.spring_type))
println(io, " input: "*string(joint.input))
end
function Rotational{T,Nλ}(pbody::Node, cbody::Node;
axis::AbstractVector=szeros(T,3),
orientation_offset::Quaternion=one(Quaternion{T}),
spring=zero(T),
damper=zero(T),
spring_offset=szeros(T,3-Nλ),
joint_limits=[szeros(T,0), szeros(T,0)],
spring_type::Symbol=:linear) where {T,Nλ}
V1, V2, V3 = orthogonal_rows(axis)
input = zeros(T,3)
Nb½ = length(joint_limits[1])
Nb = 2Nb½
N̄λ = 3 - Nλ
N = Nλ + 2Nb
Rotational{T,Nλ,Nb,N,Nb½,N̄λ}(axis, V1, V2, V3, orientation_offset, spring, damper, spring_offset, joint_limits, spring_type, input), pbody.id, cbody.id
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4606 | ###############################################################################
# Damper Force
###############################################################################
function damper_force(relative::Symbol, joint::Rotational{T}, qa::Quaternion, ωa::AbstractVector,
qb::Quaternion, ωb::AbstractVector, timestep;
rotate::Bool=true,
unitary::Bool=false) where T
damper = unitary ? 1.0 : joint.damper
A = nullspace_mask(joint)
Aᵀ = zerodimstaticadjoint(A)
orientation_offset = joint.orientation_offset
velocity = minimal_velocities(joint, szeros(3), szeros(3), qa, ωa, szeros(3), szeros(3), qb, ωb, timestep)
if relative == :parent
force = 1.0 * damper * Aᵀ * velocity # currently assumes same damper constant in all directions
rotate && (force = vector_rotate(force, orientation_offset)) # rotate back to frame a
return [szeros(T, 3); force]
elseif relative == :child
force = - 1.0 * damper * Aᵀ * velocity # currently assumes same damper constant in all directions
rotate && (force = vector_rotate(force, inv(qb) * qa * orientation_offset)) # rotate back to frame b
return [szeros(T, 3); force]
end
end
damper_impulses(relative::Symbol, joint::Rotational, pbody::Node, cbody::Node, timestep; unitary::Bool=false) =
timestep * damper_force(relative, joint, current_configuration(pbody.state)[2], pbody.state.ωsol[2],
current_configuration(cbody.state)[2], cbody.state.ωsol[2], timestep, unitary=unitary)
damper_impulses(relative::Symbol, joint::Rotational{T,3}, pbody::Node, cbody::Node, timestep; unitary::Bool=false) where T = szeros(T, 6)
###############################################################################
# Damper Jacobians
################################################################################
function damper_jacobian_configuration(relative::Symbol, jacobian::Symbol,
joint::Rotational, pbody::Node, cbody::Node,
timestep::T;
) where T
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
xa, va, qa, ωa = current_configuration_velocity(pbody.state)
xb, vb, qb, ωb = current_configuration_velocity(cbody.state)
orientation_offset = joint.orientation_offset
X = szeros(T, 3, 3)
Z = szeros(T, 3, 6)
force = damper_force(relative, joint, qa, ωa, qb, ωb, timestep; rotate = false)[SUnitRange(4,6)]
∂vel = minimal_velocities_jacobian_configuration(jacobian, joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep)[:, SUnitRange(4,6)]
if relative == :parent
Q = rotation_matrix(orientation_offset) * 1.0000 * joint.damper * Aᵀ * ∂vel
elseif relative == :child
Q = rotation_matrix(inv(qb) * qa * orientation_offset) * -1.0000 * joint.damper * Aᵀ * ∂vel
if jacobian == :parent
# Q += rotation_matrix(inv(qb)) * ∂rotation_matrix∂q(qa, vector_rotate(force, orientation_offset), attjac=true)
Q += rotation_matrix(inv(qb)) * ∂rotation_matrix∂q(qa, vector_rotate(force, orientation_offset)) * LVᵀmat(qa) # ATTJAC
elseif jacobian == :child
# Q += ∂rotation_matrix_inv∂q(qb, vector_rotate(force, qa * orientation_offset), attjac=true)
Q += ∂rotation_matrix_inv∂q(qb, vector_rotate(force, qa * orientation_offset)) * LVᵀmat(qb) # ATTJAC
end
end
return timestep * [Z; X Q]
end
function damper_jacobian_velocity(relative::Symbol, jacobian::Symbol,
joint::Rotational, pbody::Node, cbody::Node,
timestep::T) where T
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
xa, va, qa, ωa = current_configuration_velocity(pbody.state)
xb, vb, qb, ωb = current_configuration_velocity(cbody.state)
orientation_offset = joint.orientation_offset
force = damper_force(relative, joint, qa, ωa, qb, ωb, timestep; rotate = false)[SUnitRange(4,6)]
∂vel = minimal_velocities_jacobian_velocity(jacobian, joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep)
if relative == :parent
VΩ = rotation_matrix(orientation_offset) * 1.0000 * joint.damper * Aᵀ * ∂vel
elseif relative == :child
VΩ = rotation_matrix(inv(qb) * qa * orientation_offset) * -1.0000 * joint.damper * Aᵀ * ∂vel
end
return timestep * [szeros(T, 3, 6); VΩ]
end
damper_jacobian_configuration(relative::Symbol, jacobian::Symbol, joint::Rotational{T,3}, pbody::Node, cbody::Node, timestep::T; attjac::Bool = true) where T = attjac ? szeros(T, 6, 6) : szeros(T, 6, 7)
damper_jacobian_velocity(relative::Symbol, jacobian::Symbol, joint::Rotational{T,3}, pbody::Node, cbody::Node, timestep::T) where T = szeros(T, 6, 6)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1753 | ################################################################################
# Impulses
################################################################################
# see joints/joint.jl method
################################################################################
# Derivatives
################################################################################
function impulse_transform_jacobian(relative::Symbol, jacobian::Symbol,
joint::Rotational{T,Nλ},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion, p; attjac=true) where {T,Nλ}
if relative == :parent
if jacobian == :parent
# ∂(Ja'*p)/∂(xa,qa)
Z3 = szeros(T,3,3)
∂Q∂qa = ∂VLᵀmat∂q(Tmat() * Rᵀmat(qb) * LVᵀmat(joint.orientation_offset) * p) * LVᵀmat(qa)
return cat(sI(3), 0.5 * sI(3), dims=(1,2)) * [Z3 Z3; Z3 ∂Q∂qa]
elseif jacobian == :child
# ∂(Ja'*p)/∂(xb,qb)
Z3 = szeros(T,3,3)
∇Qqb = VLᵀmat(qa) * Tmat(T) * ∂Rᵀmat∂q(LVᵀmat(joint.orientation_offset) * p) * LVᵀmat(qb)
return cat(sI(3), 0.5 * sI(3), dims=(1,2)) * [Z3 Z3; Z3 ∇Qqb]
end
elseif relative == :child
if jacobian == :parent
# ∂(Jb'*p)/∂(xa,qa)
Z3 = szeros(T,3,3)
∇Qqa = VLᵀmat(qb) * ∂Lmat∂q(LVᵀmat(joint.orientation_offset) * p) * LVᵀmat(qa)
return cat(sI(3), 0.5 * sI(3), dims=(1,2)) * [Z3 Z3; Z3 ∇Qqa]
elseif jacobian == :child
# ∂(Jb'*p)/∂(xb,qb)
Z3 = szeros(T,3,3)
∇Qqb = ∂VLᵀmat∂q(Lmat(qa) * LVᵀmat(joint.orientation_offset) * p) * LVᵀmat(qb)
return cat(sI(3), 0.5 * sI(3), dims=(1,2)) * [Z3 Z3; Z3 ∇Qqb]
end
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2457 | ################################################################################
# Control Input
################################################################################
function input_impulse!(joint::Rotational{T}, pbody::Node, cbody::Node,
input_scaling::T, clear::Bool) where T
orientation_offset = joint.orientation_offset
τ = joint.input * input_scaling
xa, qa = current_configuration(pbody.state)
xb, qb = current_configuration(cbody.state)
pbody.state.Jτ2 += vector_rotate(-τ, orientation_offset)
cbody.state.Jτ2 += vector_rotate(τ, inv(qb) * qa * orientation_offset)
clear && (joint.input = szeros(T,3))
return
end
################################################################################
# Control Jacobian
################################################################################
function input_jacobian_control(relative::Symbol,
joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
input_scaling) where T
orientation_offset = joint.orientation_offset
if relative == :parent
BFa = szeros(T, 3, 3)
Bτa = - rotation_matrix(orientation_offset)
return [BFa; Bτa] * input_scaling
elseif relative == :child
BFb = szeros(T, 3, 3)
Bτb = rotation_matrix(inv(qb) * qa * orientation_offset)
return [BFb; Bτb] * input_scaling
end
end
function input_jacobian_configuration(relative::Symbol,
joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion) where T
orientation_offset = joint.orientation_offset
τ = joint.input
if relative == :parent
FaXa = szeros(T,3,3)
FaQa = szeros(T,3,4)
τaXa = szeros(T,3,3)
τaQa = szeros(T,3,4)
FbXa = szeros(T,3,3)
FbQa = szeros(T,3,4)
τbXa = szeros(T,3,3)
τbQa = rotation_matrix(inv(qb)) * ∂rotation_matrix∂q(qa * orientation_offset, τ)#*LVᵀmat(qa)
return FaXa, FaQa, τaXa, τaQa, FbXa, FbQa, τbXa, τbQa
elseif relative == :child
FaXb = szeros(T,3,3)
FaQb = szeros(T,3,4)
τaXb = szeros(T,3,3)
τaQb = szeros(T,3,4)
FbXb = szeros(T,3,3)
FbQb = szeros(T,3,4)
τbXb = szeros(T,3,3)
τbQb = ∂rotation_matrix_inv∂q(qb, vector_rotate(τ, qa * orientation_offset))#*LVᵀmat(qb)
return FaXb, FaQb, τaXb, τaQb, FbXb, FbQb, τbXb, τbQb
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 6589 | ################################################################################
# Displacements
################################################################################
function displacement(joint::Rotational,
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
vmat=true)
q = inv(joint.orientation_offset) * inv(qa) * qb
vmat ? (return Vmat(q)) : (return q)
end
function displacement_jacobian_configuration_unstable(relative::Symbol, joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
attjac::Bool=true, vmat::Bool=true) where T
X = szeros(T, 3, 3)
if relative == :parent
Q = Lᵀmat(joint.orientation_offset) * Rmat(qb) * Tmat()
attjac && (Q *= LVᵀmat(qa))
elseif relative == :child
Q = Lᵀmat(joint.orientation_offset) * Lᵀmat(qa)
attjac && (Q *= LVᵀmat(qb))
end
vmat && (Q = Vmat() * Q)
return X, Q
end
function displacement_jacobian_configuration(relative::Symbol, joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
) where T
X = szeros(T, 3, 3)
if relative == :parent
Q = Lᵀmat(joint.orientation_offset) * Rmat(qb) * Tmat()
elseif relative == :child
Q = Lᵀmat(joint.orientation_offset) * Lᵀmat(qa)
end
return X, Vmat() * Q
end
# function displacement_jacobian_configuration(relative::Symbol, joint::Rotational{T},
# xa::AbstractVector, qa::Quaternion,
# xb::AbstractVector, qb::Quaternion;
# attjac::Bool=true, vmat=true) where T
# X = szeros(T, 3, 3)
# if relative == :parent
# Q = Lᵀmat(joint.orientation_offset) * Rmat(qb) * Tmat()
# attjac && (Q *= LVᵀmat(qa))
# elseif relative == :child
# Q = Lᵀmat(joint.orientation_offset) * Lᵀmat(qa)
# attjac && (Q *= LVᵀmat(qb))
# end
# vmat && (Q = Vmat() * Q)
# return X, Q
# end
################################################################################
# Coordinates
################################################################################
function minimal_coordinates(joint::Rotational,
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion)
return nullspace_mask(joint) * rotation_vector(displacement(joint, xa, qa, xb, qb, vmat=false))
end
function minimal_coordinates_jacobian_configuration(relative::Symbol, joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
attjac::Bool=true) where T
A = nullspace_mask(joint)
q = displacement(joint, xa, qa, xb, qb, vmat=false)
X, Q = displacement_jacobian_configuration_unstable(relative, joint, xa, qa, xb, qb, attjac=attjac, vmat=false)
∂rv∂q = drotation_vectordq(q)
return A * [X ∂rv∂q * Q]
end
################################################################################
# Set Coordinates
################################################################################
function set_minimal_coordinates!(joint::Rotational,
pnode::Node, cnode::Node,
timestep;
Δθ::AbstractVector=szeros(input_dimension(joint)))
orientation_offset = joint.orientation_offset
qa = pnode.state.q2
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
Δq = axis_angle_to_quaternion(Aᵀ * Δθ)
qb = qa * orientation_offset * Δq
set_maximal_configurations!(cnode; x=cnode.state.x2, q = qb)
set_previous_configuration!(cnode, timestep)
return nothing
end
################################################################################
# Velocities
################################################################################
function minimal_velocities(joint::Rotational,
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep)
orientation_offset = joint.orientation_offset
A = nullspace_mask(joint)
# 1 step backward in time
qa1 = next_orientation(qa, -ωa, timestep)
qb1 = next_orientation(qb, -ωb, timestep)
q = inv(orientation_offset) * inv(qa) * qb
q1 = inv(orientation_offset) * inv(qa1) * qb1
return A * rotation_vector(inv(q1) * q) ./ timestep
end
function minimal_velocities_jacobian_configuration(relative::Symbol, joint::Rotational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep) where T
orientation_offset = joint.orientation_offset
A = nullspace_mask(joint)
nu = input_dimension(joint)
# 1 step backward in time
qa1 = next_orientation(qa, -ωa, timestep)
qb1 = next_orientation(qb, -ωb, timestep)
q = inv(orientation_offset) * inv(qa) * qb
q1 = inv(orientation_offset) * inv(qa1) * qb1
X = szeros(T, nu, 3)
if relative == :parent
Q = 1.0 / timestep * A * drotation_vectordq(inv(q1) * q) * Rmat(q) * Tmat() * Rmat(qb1) * Lmat(inv(orientation_offset)) * Tmat() * rotational_integrator_jacobian_orientation(qa, -ωa, timestep, attjac=false)
Q += 1.0 / timestep * A * drotation_vectordq(inv(q1) * q) * Lmat(inv(q1)) * Rmat(qb) * Lmat(inv(orientation_offset)) * Tmat()
Q *= LVᵀmat(qa)
elseif relative == :child
Q = 1.0 / timestep * A * drotation_vectordq(inv(q1) * q) * Rmat(q) * Tmat() * Lmat(inv(orientation_offset) * inv(qa1)) * rotational_integrator_jacobian_orientation(qb, -ωb, timestep, attjac=false)
Q += 1.0 / timestep * A * drotation_vectordq(inv(q1) * q) * Lmat(inv(q1) * inv(orientation_offset) * inv(qa))
Q *= LVᵀmat(qb)
end
return [X Q]
end
function minimal_velocities_jacobian_velocity(relative::Symbol, joint::Rotational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep) where T
orientation_offset = joint.orientation_offset
A = nullspace_mask(joint)
nu = input_dimension(joint)
# 1 step backward in time
qa1 = next_orientation(qa, -ωa, timestep)
qb1 = next_orientation(qb, -ωb, timestep)
q = inv(orientation_offset) * inv(qa) * qb
q1 = inv(orientation_offset) * inv(qa1) * qb1
V = szeros(T, nu, 3)
if relative == :parent
Ω = 1.0 / timestep * A * drotation_vectordq(inv(q1) * q) * Rmat(q) * Tmat() * Lmat(inv(orientation_offset)) * Rmat(qb1) * Tmat() * -rotational_integrator_jacobian_velocity(qa, -ωa, timestep)
elseif relative == :child
Ω = 1.0 / timestep * A * drotation_vectordq(inv(q1) * q) * Rmat(q) * Tmat() * Lmat(inv(orientation_offset) * inv(qa1)) * -rotational_integrator_jacobian_velocity(qb, -ωb, timestep)
end
return [V Ω]
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4362 | ################################################################################
# Spring Impulses
################################################################################
function spring_force(relative::Symbol, joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
rotate::Bool=true,
unitary::Bool=false) where T
spring = unitary ? 1.0 : joint.spring
distance = joint.spring_offset .- minimal_coordinates(joint, xa, qa, xb, qb)
force = -spring * zerodimstaticadjoint(nullspace_mask(joint)) * distance # force in offset frame
if relative == :parent
rotate ? (output = vector_rotate(force, joint.orientation_offset)) : (output = force) # rotate into a frame
elseif relative == :child
rotate ? (output = vector_rotate(-force, inv(qb) * qa * joint.orientation_offset)) : (output = -force) # rotate back to b frame
end
return [szeros(T, 3); output]
end
function spring_impulses(relative::Symbol, joint::Rotational, pbody::Node, cbody::Node, timestep;
unitary::Bool=false)
spring_impulses(relative, joint,
current_configuration(pbody.state)...,
current_configuration(cbody.state)...,
timestep, unitary=unitary)
end
function spring_impulses(relative::Symbol, joint::Rotational,
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
timestep;
unitary::Bool=false)
timestep * spring_force(relative, joint, xa, qa, xb, qb; unitary=unitary)
end
spring_impulses(relative::Symbol, joint::Rotational{T,3}, pbody::Node, cbody::Node, timestep; unitary::Bool=false) where T = szeros(T, 6)
################################################################################
# Spring Jacobians
################################################################################
function spring_jacobian_configuration(relative::Symbol, jacobian::Symbol, joint::Rotational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
timestep::T;
rotate::Bool=true,
unitary::Bool=false,
attjac=true) where T
Z = attjac ? szeros(T, 3, 6) : szeros(T, 3, 7)
force = spring_force(relative, joint, xa, qa, xb, qb, rotate=false)
spring = unitary ? 1.0 : joint.spring
if relative == :parent
J = timestep * rotation_matrix(joint.orientation_offset) * spring * zerodimstaticadjoint(nullspace_mask(joint)) * minimal_coordinates_jacobian_configuration(jacobian, joint, xa, qa, xb, qb, attjac=attjac)
elseif relative == :child
X = szeros(T, 3, 3)
if rotate
J1 = timestep * rotation_matrix(inv(qb) * qa * joint.orientation_offset) * -spring * zerodimstaticadjoint(nullspace_mask(joint)) * minimal_coordinates_jacobian_configuration(jacobian, joint, xa, qa, xb, qb, attjac=attjac)
if jacobian == :parent
Q2 = timestep * ∂vector_rotate∂q(force[SA[4;5;6]], inv(qb) * qa * joint.orientation_offset) * Rmat(joint.orientation_offset) * Lmat(inv(qb))
attjac && (Q2 *= LVᵀmat(qa))
J2 = [X Q2]
elseif jacobian == :child
Q2 = timestep * ∂vector_rotate∂q(force[SA[4;5;6]], inv(qb) * qa * joint.orientation_offset) * Rmat(qa * joint.orientation_offset) * Tmat()
attjac && (Q2 *= LVᵀmat(qb))
J2 = [X Q2]
end
J = J1 + J2
else
J = timestep * -spring * zerodimstaticadjoint(nullspace_mask(joint)) * minimal_coordinates_jacobian_configuration(jacobian, joint, xa, qa, xb, qb, attjac=attjac)
end
end
return [Z; J]
end
function spring_jacobian_configuration(relative::Symbol, jacobian::Symbol,
joint::Rotational, pbody::Node, cbody::Node,
timestep::T;
attjac::Bool = true) where T
spring_jacobian_configuration(relative, jacobian, joint,
current_configuration(pbody.state)...,
current_configuration(cbody.state)...,
timestep; attjac=attjac)
end
spring_jacobian_configuration(relative::Symbol, jacobian::Symbol, joint::Rotational{T,3}, pbody::Node, cbody::Node, timestep::T; attjac::Bool = true) where T = attjac ? szeros(T, 6, 6) : szeros(T, 6, 7)
spring_jacobian_velocity(relative::Symbol, jacobian::Symbol, joint::Rotational, pbody::Node, cbody::Node, timestep::T) where T = szeros(T, 6, 6)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3126 | """
Translational{T} <: Joint{T}
constraint limiting translational degrees of freedom
axis: translational axis in parent offset frame
axis_mask1: translational axis mask in pbody's frame
axis_mask2: translational axis mask in pbody's frame
axis_mask3: translational axis mask in pbody's frame
vertices: points in parent can child frames
spring: coefficient for joint spring
damper: coefficient for joint damper
spring_offset: nominal joint configuration
joint_limits: lower and upper limits on the joint configuration
spring_type: can be :linear or :sinusoidal (currently not implemented), if linear then we need joint_limits to avoid the 360° singularity.
input: external impulse force
"""
mutable struct Translational{T,Nλ,Nb,N,Nb½,N̄λ} <: Joint{T,Nλ,Nb,N,Nb½}
axis::SVector{3,T} # translation axis in parent frame
axis_mask1::Adjoint{T,SVector{3,T}} # in pbody's frame
axis_mask2::Adjoint{T,SVector{3,T}} # in pbody's frame
axis_mask3::Adjoint{T,SVector{3,T}} # in pbody's frame
vertices::NTuple{2,SVector{3,T}} # in pbody's & cbody's frames
spring::T
damper::T
spring_offset::SVector{N̄λ,T}
joint_limits::Vector{SVector{Nb½,T}} # lower and upper limits on the joint minimal coordinate angles
spring_type::Symbol # the rotational springs can be :linear or :sinusoidal, if linear then we need joint_limits to avoid the 180° singularity.
input::SVector{3,T} # joint input. force if mechanism.input_scaling = timestep, impulse if mechanism.input_scaling = 1
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, joint::Translational{T,N}) where {T,N}
summary(io, joint)
println(io,"")
println(io, " axis: "*string(joint.axis))
println(io, " axis_mask1: "*string(joint.axis_mask1))
println(io, " axis_mask2: "*string(joint.axis_mask2))
println(io, " axis_mask3: "*string(joint.axis_mask3))
println(io, " vertices: "*string(joint.vertices))
println(io, " spring: "*string(joint.spring))
println(io, " damper: "*string(joint.damper))
println(io, " spring_offset: "*string(joint.spring_offset))
println(io, " joint_limits: "*string(joint.joint_limits))
println(io, " spring_type: "*string(joint.spring_type))
println(io, " input: "*string(joint.input))
end
function Translational{T,Nλ}(pbody::Node, cbody::Node;
parent_vertex::AbstractVector=szeros(T,3),
child_vertex::AbstractVector=szeros(T,3),
axis::AbstractVector=szeros(T,3),
spring=zero(T),
damper=zero(T),
spring_offset=szeros(T,3-Nλ),
joint_limits=[szeros(T,0), szeros(T,0)],
spring_type::Symbol = :linear) where {T,Nλ} #TODO: reimplement sinusoidal
vertices = (parent_vertex, child_vertex)
V1, V2, V3 = orthogonal_rows(axis)
input = zeros(T,3)
Nb½ = length(joint_limits[1])
Nb = 2Nb½
N̄λ = 3 - Nλ
N = Nλ + 2Nb
Translational{T,Nλ,Nb,N,Nb½,N̄λ}(axis, V1, V2, V3, vertices, spring, damper, spring_offset, joint_limits, spring_type, input), pbody.id, cbody.id
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 5535 | ################################################################################
# Damper Force
################################################################################
function damper_force(joint::Translational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep;
unitary::Bool=false) where T
damper = unitary ? 1.0 : joint.damper
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
input = damper * Aᵀ * -minimal_velocities(joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep) # in the a frame
return input
end
function damper_force(relative::Symbol, joint::Translational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep;
unitary::Bool=false) where T
input = damper_force(joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep, unitary=unitary) # in the a frame
inputa = impulse_transform(relative, joint, xa, qa, xb, qb) * input
return inputa
end
damper_impulses(relative::Symbol, joint::Translational, pbody::Node, cbody::Node, timestep;
unitary::Bool=false) =
timestep * damper_force(relative, joint,
current_configuration_velocity(pbody.state)...,
current_configuration_velocity(cbody.state)...,
timestep;
unitary=unitary)
damper_impulses(relative::Symbol, joint::Translational{T,3}, pbody::Node, cbody::Node, timestep; unitary::Bool=false) where T = szeros(T, 6)
################################################################################
# Damper Jacobian
################################################################################
function damper_force_jacobian_configuration(jacobian_relative::Symbol,
joint::Translational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep;
unitary::Bool=false) where T
damper = unitary ? 1.0 : joint.damper
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
∇input = damper * Aᵀ * -minimal_velocities_jacobian_configuration(jacobian_relative, joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep) # in the a frame
return ∇input
end
function damper_force_jacobian_velocity(jacobian_relative::Symbol,
joint::Translational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep;
unitary::Bool=false) where T
damper = unitary ? 1.0 : joint.damper
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
∇input = damper * Aᵀ * -minimal_velocities_jacobian_velocity(jacobian_relative, joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep) # in the a frame
return ∇input
end
function damper_jacobian_configuration(relative::Symbol, jacobian_relative::Symbol,
joint::Translational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep::T;
unitary::Bool=false) where T
input = damper_force(joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep, unitary=unitary)
∇xq = impulse_transform(relative, joint, xa, qa, xb, qb) *
damper_force_jacobian_configuration(jacobian_relative, joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep, unitary=unitary)
∇xq += impulse_transform_jacobian(relative, jacobian_relative, joint, xa, qa, xb, qb, input)
return timestep * ∇xq
end
function damper_jacobian_configuration(relative::Symbol, jacobian::Symbol,
joint::Translational,
pbody::Node, cbody::Node,
timestep::T;
attjac::Bool = true) where T
return damper_jacobian_configuration(relative, jacobian,
joint,
current_configuration_velocity(pbody.state)...,
current_configuration_velocity(cbody.state)...,
timestep; unitary=false)
end
function damper_jacobian_velocity(relative::Symbol, jacobian_relative::Symbol,
joint::Translational{T},
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep::T;
unitary::Bool=false) where T
∇xq = impulse_transform(relative, joint, xa, qa, xb, qb) *
damper_force_jacobian_velocity(jacobian_relative, joint, xa, va, qa, ωa, xb, vb, qb, ωb, timestep, unitary=unitary)
return timestep * ∇xq
end
function damper_jacobian_velocity(relative::Symbol, jacobian::Symbol,
joint::Translational,
pbody::Node, cbody::Node,
timestep::T, attjac::Bool=true) where T
return damper_jacobian_velocity(relative, jacobian,
joint,
current_configuration_velocity(pbody.state)...,
current_configuration_velocity(cbody.state)...,
timestep; unitary=false)
end
damper_jacobian_configuration(relative::Symbol, jacobian::Symbol, joint::Translational{T,3}, pbody::Node, cbody::Node, timestep::T; attjac::Bool = true, unitary::Bool=false) where T = attjac ? szeros(T, 6, 6) : szeros(T, 6, 7)
damper_jacobian_velocity(relative::Symbol, jacobian::Symbol, joint::Translational{T,3}, pbody::Node, cbody::Node, timestep::T, unitary::Bool=false) where T = szeros(T, 6, 6)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2206 | ################################################################################
# Impulses
################################################################################
# see joints/joint.jl method
################################################################################
# Impulse Transform Derivatives
################################################################################
function impulse_transform_jacobian(relative::Symbol, jacobian::Symbol,
joint::Translational{T,Nλ},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion, p;
attjac=true) where {T,Nλ}
Z3 = szeros(T,3,3)
if relative == :parent
if jacobian == :parent
# ∂(impulse_transform_a'*p)/∂(xa,qa)
∇Xqa = -∂rotation_matrix∂q(qa, p) * LVᵀmat(qa)
∇Qxa = ∂skew∂p(p) * rotation_matrix(inv(qa))
∇Qqa = -∂skew∂p(p) * ∂rotation_matrix_inv∂q(qa, xb - xa + rotation_matrix(qb) * joint.vertices[2]) * LVᵀmat(qa)
return [Z3 ∇Xqa; ∇Qxa ∇Qqa]
elseif jacobian == :child
# ∂(impulse_transform_a'*p)/∂(xb,qb)
∇Qxb = -∂skew∂p(p) * rotation_matrix(inv(qa))
∇Qqb = -∂skew∂p(p) * rotation_matrix(inv(qa)) * ∂rotation_matrix∂q(qb, joint.vertices[2]) * LVᵀmat(qb)
return [Z3 Z3; ∇Qxb ∇Qqb]
end
elseif relative == :child
if jacobian == :parent
# ∂(impulse_transform_b'*p)/∂(xa,qa)
cbpb_w = rotation_matrix(qb) * joint.vertices[2] # body b kinematics point
∇Xqa = ∂rotation_matrix∂q(qa, p) * LVᵀmat(qa)
∇Qqa = rotation_matrix(inv(qb)) * skew(cbpb_w) * ∂rotation_matrix∂q(qa, p) * LVᵀmat(qa)
return [Z3 ∇Xqa; Z3 ∇Qqa]
elseif jacobian == :child
# ∂(impulse_transform_b'*p)/∂(xb,qb)
cbpb_w = rotation_matrix(qb) * joint.vertices[2] # body b kinematics point
∇Qqb = ∂rotation_matrix_inv∂q(qb, skew(cbpb_w) * rotation_matrix(qa) * p)
∇Qqb += rotation_matrix(inv(qb)) * ∂skew∂p(rotation_matrix(qa) * p) * ∂rotation_matrix∂q(qb, joint.vertices[2])
∇Qqb *= LVᵀmat(qb)
return [Z3 Z3; Z3 ∇Qqb]
end
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2232 | ################################################################################
# Control Input
################################################################################
function input_impulse!(joint::Translational{T},
pbody::Node, cbody::Node,
input_scaling::T, clear::Bool) where T
xa, qa = current_configuration(pbody.state)
xb, qb = current_configuration(cbody.state)
input = joint.input * input_scaling
Ta = impulse_transform(:parent, joint, xa, qa, xb, qb)
Tb = impulse_transform(:child, joint, xa, qa, xb, qb)
JFaw = Ta[SA[1;2;3],SA[1;2;3]] * input
Jτaa = Ta[SA[4;5;6],SA[1;2;3]] * input
JFbw = Tb[SA[1;2;3],SA[1;2;3]] * input
Jτbb = Tb[SA[4;5;6],SA[1;2;3]] * input
pbody.state.JF2 += JFaw
pbody.state.Jτ2 += Jτaa/2
cbody.state.JF2 += JFbw
cbody.state.Jτ2 += Jτbb/2
clear && (joint.input = szeros(T,3))
return
end
################################################################################
# Control Jacobian
################################################################################
function input_jacobian_control(relative::Symbol,
joint::Translational,
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
input_scaling)
Ta = impulse_transform(relative, joint, xa, qa, xb, qb)
X = Ta[SA[1;2;3],SA[1;2;3]]
Q = 0.5 * Ta[SA[4;5;6],SA[1;2;3]]
return [X; Q] * input_scaling
end
function input_jacobian_configuration(relative::Symbol,
joint::Translational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion) where T
# d[Faw;2τaa]/d[xa,qa]
∇aa = impulse_transform_jacobian(:parent, relative, joint, xa, qa, xb, qb, joint.input)
FaXa = ∇aa[SA[1;2;3], SA[1;2;3]]
FaQa = ∇aa[SA[1;2;3], SA[4;5;6]]
τaXa = 0.5 * ∇aa[SA[4;5;6], SA[1;2;3]]
τaQa = 0.5 * ∇aa[SA[4;5;6], SA[4;5;6]]
# d[Fbw;2τbb]/d[xa,qa]
∇ba = impulse_transform_jacobian(:child, relative, joint, xa, qa, xb, qb, joint.input)
FbXa = ∇ba[SA[1;2;3],SA[1;2;3]]
FbQa = ∇ba[SA[1;2;3],SA[4;5;6]]
τbXa = 0.5 * ∇ba[SA[4;5;6],SA[1;2;3]]
τbQa = 0.5 * ∇ba[SA[4;5;6],SA[4;5;6]]
return FaXa, FaQa, τaXa, τaQa, FbXa, FbQa, τbXa, τbQa
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 7231 | ################################################################################
# Displacements
################################################################################
function displacement(joint::Translational,
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
rotate::Bool = true)
vertices = joint.vertices
d = xb + vector_rotate(vertices[2], qb) - (xa + vector_rotate(vertices[1], qa))
rotate && (return vector_rotate(d, inv(qa))) : (return d)
end
function displacement_jacobian_configuration(relative::Symbol, joint::Translational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion) where T
vertices = joint.vertices
if relative == :parent
d = xb + vector_rotate(vertices[2], qb) - (xa + vector_rotate(vertices[1], qa)) # in the world frame
X = -rotation_matrix(inv(qa))
Q = -rotation_matrix(inv(qa)) * ∂rotation_matrix∂q(qa, vertices[1])
Q += ∂rotation_matrix_inv∂q(qa, d)
elseif relative == :child
X = rotation_matrix(inv(qa))
Q = rotation_matrix(inv(qa)) * ∂rotation_matrix∂q(qb, vertices[2])
end
return X, Q
end
# function displacement_jacobian_configuration(relative::Symbol, joint::Translational{T},
# xa::AbstractVector, qa::Quaternion,
# xb::AbstractVector, qb::Quaternion;
# attjac=true) where T
#
# vertices = joint.vertices
#
# if relative == :parent
# d = xb + vector_rotate(vertices[2], qb) - (xa + vector_rotate(vertices[1], qa)) # in the world frame
# X = -rotation_matrix(inv(qa))
# Q = -rotation_matrix(inv(qa)) * ∂rotation_matrix∂q(qa, vertices[1])
# Q += ∂rotation_matrix_inv∂q(qa, d)
# attjac && (Q *= LVᵀmat(qa))
# elseif relative == :child
# X = rotation_matrix(inv(qa))
# Q = rotation_matrix(inv(qa)) * ∂rotation_matrix∂q(qb, vertices[2])
# attjac && (Q *= LVᵀmat(qb))
# end
#
# return X, Q
# end
################################################################################
# Coordinates
################################################################################
function minimal_coordinates(joint::Translational, xa::AbstractVector, qa::Quaternion, xb::AbstractVector, qb::Quaternion)
return nullspace_mask(joint) * displacement(joint, xa, qa, xb, qb)
end
function minimal_coordinates_jacobian_configuration(relative::Symbol, joint::Translational,
xa::AbstractVector, qa::Quaternion, xb::AbstractVector, qb::Quaternion; attjac::Bool=true)
X, Q = displacement_jacobian_configuration(relative, joint, xa, qa, xb, qb, attjac=attjac)
return nullspace_mask(joint) * [X Q]
end
################################################################################
# Coordinates
################################################################################
function set_minimal_coordinates!(joint::Translational,
pnode::Node, cnode::Node,
timestep;
Δx::AbstractVector=szeros(input_dimension(joint)))
pa = joint.vertices[1]
pb = joint.vertices[2]
qa = pnode.state.q2
xa = pnode.state.x2
qb = cnode.state.q2
Aᵀ = zerodimstaticadjoint(nullspace_mask(joint))
xb = xa + vector_rotate(pa + Aᵀ * Δx, qa) - vector_rotate(pb, qb)
set_maximal_configurations!(cnode; x=xb, q=cnode.state.q2)
set_previous_configuration!(cnode, timestep)
return nothing
end
################################################################################
# Velocities
################################################################################
function minimal_velocities(joint::Translational,
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep)
A = nullspace_mask(joint)
# 1 step backward in time
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
xb1 = next_position(xb, -vb, timestep)
qb1 = next_orientation(qb, -ωb, timestep)
# Coordinates
Δx = A * displacement(joint, xa, qa, xb, qb)
# Previous step coordinates
Δx1 = A * displacement(joint, xa1, qa1, xb1, qb1)
# Finite difference
Δv = (Δx - Δx1) / timestep
return Δv
end
function minimal_velocities_jacobian_configuration(relative::Symbol, joint::Translational,
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep)
A = nullspace_mask(joint)
# 1 step backward in time
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
xb1 = next_position(xb, -vb, timestep)
qb1 = next_orientation(qb, -ωb, timestep)
# Coordinates
Δx = A * displacement(joint, xa, qa, xb, qb)
# Previous step coordinates
Δx1 = A * displacement(joint, xa1, qa1, xb1, qb1)
# Finite difference
# Δv = (Δx - Δx1) / timestep
if relative == :parent
X, Q = displacement_jacobian_configuration(:parent, joint, xa, qa, xb, qb, attjac=false)
X1, Q1 = displacement_jacobian_configuration(:parent, joint, xa1, qa1, xb1, qb1, attjac=false)
X1 *= -1.0
Q1 *= -1.0 * rotational_integrator_jacobian_orientation(qa, -ωa, timestep, attjac=false)
Q *= LVᵀmat(qa)
Q1 *= LVᵀmat(qa)
J = 1.0 / timestep * A * [X Q]
J += 1.0 / timestep * A * [X1 Q1]
elseif relative == :child
1.0 / timestep * (Δx - Δx1)
X, Q = displacement_jacobian_configuration(:child, joint, xa, qa, xb, qb, attjac=false)
X1, Q1 = displacement_jacobian_configuration(:child, joint, xa1, qa1, xb1, qb1, attjac=false)
X1 *= -1.0
Q1 *= -1.0 * rotational_integrator_jacobian_orientation(qb, -ωb, timestep, attjac=false)
Q *= LVᵀmat(qb)
Q1 *= LVᵀmat(qb)
J = 1.0 / timestep * A * [X Q]
J += 1.0 / timestep * A * [X1 Q1]
end
return J
end
function minimal_velocities_jacobian_velocity(relative::Symbol, joint::Translational,
xa::AbstractVector, va::AbstractVector, qa::Quaternion, ωa::AbstractVector,
xb::AbstractVector, vb::AbstractVector, qb::Quaternion, ωb::AbstractVector,
timestep)
A = nullspace_mask(joint)
# 1 step backward in time
xa1 = next_position(xa, -va, timestep)
qa1 = next_orientation(qa, -ωa, timestep)
xb1 = next_position(xb, -vb, timestep)
qb1 = next_orientation(qb, -ωb, timestep)
# Coordinates
Δx = A * displacement(joint, xa, qa, xb, qb)
# Previous step coordinates
Δx1 = A * displacement(joint, xa1, qa1, xb1, qb1)
# Finite difference
Δv = (Δx - Δx1) / timestep
if relative == :parent
X1, Q1 = displacement_jacobian_configuration(:parent, joint, xa1, qa1, xb1, qb1, attjac=false)
X1 *= -timestep
Q1 *= -rotational_integrator_jacobian_velocity(qa, -ωa, timestep)
J = -1.0 / timestep * A * [X1 Q1]
elseif relative == :child
X1, Q1 = displacement_jacobian_configuration(:child, joint, xa1, qa1, xb1, qb1, attjac=false)
X1 *= -timestep
Q1 *= -rotational_integrator_jacobian_velocity(qb, -ωb, timestep)
J = -1.0 / timestep * A * [X1 Q1]
end
return J
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3508 | ################################################################################
# Spring Impulses
################################################################################
function spring_force(relative::Symbol, joint::Translational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
unitary::Bool=false) where T
spring = unitary ? 1.0 : joint.spring
distance = joint.spring_offset .- minimal_coordinates(joint, xa, qa, xb, qb)
force = spring * zerodimstaticadjoint(nullspace_mask(joint)) * distance
return [force; szeros(T, 3)]
end
function spring_impulses(relative::Symbol, joint::Translational, pbody::Node, cbody::Node, timestep; unitary::Bool=false)
spring_impulses(relative, joint,
current_configuration(pbody.state)...,
current_configuration(cbody.state)...,
timestep, unitary=unitary)
end
function spring_impulses(relative::Symbol, joint::Translational,
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
timestep; unitary::Bool=false)
timestep * impulse_transform(relative, joint, xa, qa, xb, qb) * spring_force(relative, joint, xa, qa, xb, qb; unitary=unitary)[SA[1;2;3]]
end
spring_impulses(relative::Symbol, joint::Translational{T,3}, pbody::Node, cbody::Node, timestep; unitary::Bool=false) where T = szeros(T, 6)
################################################################################
# Spring Jacobians
################################################################################
function spring_force_jacobian_configuration(jacobian_relative::Symbol,
joint::Translational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion;
unitary::Bool=false,
attjac=true) where T
spring = unitary ? 1.0 : joint.spring
return -spring * zerodimstaticadjoint(nullspace_mask(joint)) * minimal_coordinates_jacobian_configuration(jacobian_relative, joint, xa, qa, xb, qb, attjac=attjac)
end
function spring_jacobian_configuration(relative::Symbol, jacobian_relative::Symbol,
joint::Translational{T},
xa::AbstractVector, qa::Quaternion,
xb::AbstractVector, qb::Quaternion,
timestep::T;
unitary::Bool=false,
attjac=true) where T
force = spring_force(relative, joint, xa, qa, xb, qb, unitary=unitary)[SA[1;2;3]]
J = impulse_transform(relative, joint, xa, qa, xb, qb) *
spring_force_jacobian_configuration(jacobian_relative, joint, xa, qa, xb, qb, unitary=unitary, attjac=attjac)
J += impulse_transform_jacobian(relative, jacobian_relative, joint, xa, qa, xb, qb, force, attjac=attjac)
return timestep * J
end
function spring_jacobian_configuration(relative::Symbol, jacobian::Symbol,
joint::Translational,
pbody::Node, cbody::Node,
timestep::T;
attjac::Bool=true,
unitary=false) where T
return spring_jacobian_configuration(relative, jacobian,
joint,
current_configuration(pbody.state)...,
current_configuration(cbody.state)...,
timestep; unitary=false, attjac=attjac)
end
spring_jacobian_configuration(relative::Symbol, jacobian::Symbol, joint::Translational{T,3}, pbody::Node, cbody::Node, timestep::T; attjac::Bool = true, unitary::Bool=false) where T = attjac ? szeros(T, 6, 6) : szeros(T, 6, 7)
spring_jacobian_velocity(relative::Symbol, jacobian::Symbol, joint::Translational, pbody::Node, cbody::Node, timestep::T, unitary::Bool=false) where T = szeros(T, 6, 6)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2754 |
"""
mechanical_energy(mechanism, storage)
mechanism's total mechanical energy
mechanism: Mechanism
storage: Storage
"""
function mechanical_energy(mechanism::Mechanism, storage::Storage)
ke = kinetic_energy(mechanism, storage)
pe = potential_energy(mechanism, storage)
me = ke + pe
return me
end
"""
kinetic_energy(mechanism, storage)
mechanism's kinetic energy from linear and angular velocity
mechanism: Mechanism
storage: Storage
"""
function kinetic_energy(mechanism::Mechanism, storage::Storage{T,N}) where {T,N}
ke = zeros(T,N)
for i = 1:N
ke[i] = kinetic_energy(mechanism, storage, i)
end
return ke
end
function kinetic_energy(mechanism::Mechanism, storage::Storage{T,N}, t::Int) where {T,N}
ke = 0.0
for (i,body) in enumerate(mechanism.bodies)
vl = storage.vl[i][t]
ωl = storage.ωl[i][t]
ke += 0.5 * body.mass * vl' * vl
ke += 0.5 * ωl' * body.inertia * ωl
end
return ke
end
"""
potential_energy(mechanism, storage)
mechanism's potential energy from gravity and springs
mechanism: Mechanism
storage: Storage
"""
function potential_energy(mechanism::Mechanism, storage::Storage{T,N}) where {T,N}
pe = zeros(T,N)
for i = 1:N
pe[i] = potential_energy(mechanism, storage, i)
end
return pe
end
function potential_energy(mechanism::Mechanism{T,Nn,Ne,Nb}, storage::Storage{T,Ns}, t::Int) where {T,Nn,Ne,Nb,Ns}
pe = 0.0
# Gravity
for (i,body) in enumerate(mechanism.bodies)
pe -= body.mass * dot(mechanism.gravity, storage.x[i][t]) # TODO: confirm this is correct
end
# Springs
for joint in mechanism.joints
parent_id = joint.parent_id
child_id = joint.child_id
if joint.spring
for element in (joint.translational, joint.rotational)
if element.spring > 0
xb = storage.x[child_id - Ne][t] # TODO this is sketchy way to get the correct index
qb = storage.q[child_id - Ne][t] # TODO this is sketchy way to get the correct index
if parent_id != 0
xa = storage.x[parent_id - Ne][t] # TODO this is sketchy way to get the correct index
qa = storage.q[parent_id - Ne][t] # TODO this is sketchy way to get the correct index
else
xa, qa = current_configuration(mechanism.origin.state)
end
force = spring_force(:parent, element, xa, qa, xb, qb)
pe += 0.5 * dot(force, force) ./ element.spring
end
end
end
end
return pe
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3018 | """
momentum(mechanism, storage)
mechanism's linear and angular momentum
mechanism: Mechanism
storage: Storage
"""
function momentum(mechanism::Mechanism, storage::Storage{T,N}) where {T,N}
m = [szeros(T,6) for i = 1:N]
for i = 1:N
m[i] = momentum(mechanism, storage, i)
end
return m # in world frame
end
function momentum(mechanism::Mechanism{T}, body::Body{T}) where T
timestep = mechanism.timestep
state = body.state
mass = body.mass
inertia = body.inertia
# x1, q1 = previous_configuration(state)
x2, q2 = current_configuration(state)
x3, q3 = next_configuration(state, timestep)
v15 = body.state.vsol[2] # v1.5
ω15 = body.state.ωsol[2] # ω1.5
D2x = 1 / timestep * mass * (x3 - x2) - 0.5 * timestep * (mass * mechanism.gravity + state.Fext)
D2q = -2.0 / timestep * LVᵀmat(q2)' * Tmat() * Rmat(q3)' * Vᵀmat() * inertia * Vmat() * Lmat(q2)' * vector(q3) - 0.5 * timestep * state.τext
p_linear_body = D2x - 0.5 * state.JF2
p_angular_body = D2q - 0.5 * state.Jτ2
for joint in mechanism.joints
f_joint = joint_impulses(mechanism, joint, body)
p_linear_body -= 0.5 * f_joint[SA[1;2;3]]
p_angular_body -= 0.5 * f_joint[SA[4;5;6]]
end
return p_linear_body, vector_rotate(p_angular_body, q2)
end
function joint_impulses(mechanism, joint::JointConstraint{T,N}, body) where {T,N}
f_joint = szeros(T,6)
if body.id ∈ (joint.parent_id, joint.child_id)
(N > 0) && (f_joint += impulse_map(mechanism, joint, body) * joint.impulses[2]) # computed at t = 1.5
joint.spring && (f_joint += spring_impulses(mechanism, joint, body)) # computed at t = 1.5
joint.damper && (f_joint += damper_impulses(mechanism, joint, body)) # computed at t = 1.5
end
return f_joint
end
function momentum(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, storage::Storage{T,Ns}, t::Int) where {T,Nn,Ne,Nb,Ni,Ns}
p = zeros(T, 6)
com = center_of_mass(mechanism, storage, t)
mass = total_mass(mechanism)
p_linear_body = [storage.px[i][t] for i = 1:Nb] # in world frame
p_angular_body = [storage.pq[i][t] for i = 1:Nb] # in world frame
p_linear = sum(p_linear_body)
p_angular = zeros(T, 3)
v_com = p_linear ./ mass
for (i, body) in enumerate(mechanism.bodies)
r = storage.x[i][t] - com
v_body = p_linear_body[i] ./ body.mass
p_angular += p_angular_body[i]
p_angular += cross(r, body.mass * (v_body - v_com)) #TODO maybe there is cleaner way to handle the factor 2
end
return [p_linear; p_angular] # in world frame
end
function center_of_mass(mechanism::Mechanism{T}, storage::Storage{T,N}, t::Int) where {T,N}
r = zeros(T, 3)
for (i,body) in enumerate(mechanism.bodies)
r += body.mass * storage.x[i][t]
end
return r ./ total_mass(mechanism)
end
function total_mass(mechanism::Mechanism{T}) where T
w = 0.0
for body in mechanism.bodies
w += body.mass
end
return w
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3649 | """
Mechanism{T}
Multi-rigid-body system.
origin: global reference frame represented with Origin
joints: list of JointConstraint objects
bodies: list of Body objects
contacts: list of ContactConstraint objects
system: graph-based representation for mechanism
residual_entries: containt entries for linear system residual
data_matrix: contains parameter information that is fixed during simulation
root_to_leaves: list of node connections traversing from root node to leaves
timestep: time discretization
input_scaling: input scaling for internal use of impulses (default: timestep)
gravity: force vector resulting from gravitational potential
μ: complementarity violation (contact softness)
"""
mutable struct Mechanism{T,Nn,Ne,Nb,Ni}
origin::Origin{T}
joints::Vector{<:JointConstraint{T}}
bodies::Vector{Body{T}}
contacts::Vector{<:ContactConstraint{T}}
system::System{Nn}
residual_entries::Vector{Entry}
data_matrix::SparseMatrixCSC{Entry,Int64}
root_to_leaves::Vector{Int64}
timestep::T
input_scaling::T
gravity::SVector{3,T}
μ::T
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, mechanism::Mechanism{T,Nn,Nb,Ne,Ni}) where {T,Nn,Nb,Ne,Ni}
summary(io, mechanism)
println(io, " with ", Nb, " bodies, ", Ne, " joints, and ", Ni, " contacts")
println(io, " root_to_leaves: "*string(mechanism.root_to_leaves))
println(io, " timestep: "*string(mechanism.timestep))
println(io, " gravity: "*string(mechanism.gravity))
println(io, " μ: "*string(mechanism.μ))
end
function Mechanism(origin::Origin{T}, bodies::Vector{Body{T}}, joints::Vector{<:JointConstraint{T}}, contacts::Vector{<:ContactConstraint{T}};
timestep=0.01, input_scaling=timestep, gravity=[0.0; 0.0;-9.81]) where T
# reset ids
resetGlobalID()
# check body inertia parameters
check_body.(bodies)
# dimensions
Ne = length(joints)
Nb = length(bodies)
Ni = length(contacts)
Nn = Ne + Nb + Ni
# nodes
nodes = [joints; bodies; contacts]
# set IDs
global_id!(nodes)
origin.id = 0
# graph system
system = create_system(origin, joints, bodies, contacts)
residual_entries = deepcopy(system.vector_entries)
# data gradient system
data_matrix = create_data_matrix(joints, bodies, contacts)
# Node ordering from root to leaves, loop joints at the end
loop_joints = get_loop_joints(bodies, joints)
nodes = [origin; bodies; joints; contacts]
root_to_leaves = root_to_leaves_ordering(nodes, loop_joints,
exclude_origin=true,
exclude_loop_joints=false)
Mechanism{T,Nn,Ne,Nb,Ni}(origin, joints, bodies, contacts, system, residual_entries,
data_matrix, root_to_leaves, timestep, input_scaling, get_gravity(gravity), 0.0)
end
Mechanism(origin::Origin{T}, bodies::Vector{Body{T}}, joints::Vector{<:JointConstraint{T}}; kwargs...) where T =
Mechanism(origin, bodies, joints, ContactConstraint{T}[]; kwargs...)
function Mechanism(filename::String;
floating::Bool=false,
T=Float64,
parse_dampers=true,
keep_fixed_joints=true,
kwargs...)
# parse urdf
origin, links, joints, loopjoints = parse_urdf(filename, floating, T, parse_dampers)
# create mechanism
mechanism = Mechanism(origin, links, [joints; loopjoints]; kwargs...)
# initialize mechanism
set_parsed_values!(mechanism, loopjoints)
if !keep_fixed_joints
mechanism = reduce_fixed_joints(mechanism; kwargs...)
end
return mechanism
end
Base.length(mechanism::Mechanism{T,N}) where {T,N} = N
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 6280 | ################################################################################
# Dimension
################################################################################
# Mechanism
data_dim(mechanism::Mechanism; attjac::Bool=true) =
sum(Vector{Int64}(data_dim.(mechanism.joints))) +
sum(Vector{Int64}(data_dim.(mechanism.bodies, attjac=attjac))) +
sum(Vector{Int64}(data_dim.(mechanism.contacts)))
# Joints
data_dim(joint::JointConstraint) = 2 + sum(data_dim.((joint.translational, joint.rotational))) # [utra, urot, spring, damper]
data_dim(joint::Translational{T,Nλ,Nb,N,Nb½,N̄λ}) where {T,Nλ,Nb,N,Nb½,N̄λ} = N̄λ # [utra]
data_dim(joint::Rotational{T,Nλ,Nb,N,Nb½,N̄λ}) where {T,Nλ,Nb,N,Nb½,N̄λ} = N̄λ # [urot]
# Body
data_dim(body::Body; attjac::Bool=true) = attjac ? 19 : 20 # 1+6+6+6 or 1+6+6+7 [m,flat(J),v15,ω15,x2,q2] with attjac
# Contact
data_dim(contact::ContactConstraint) = data_dim(contact.model)
data_dim(model::NonlinearContact) = 5 # [friction_coefficient, contact_radius, p]
data_dim(model::LinearContact) = 5 # [friction_coefficient, contact_radius, p]
data_dim(model::ImpactContact) = 4 # [contact_radius, p]
################################################################################
# Attitude Jacobian
################################################################################
# Mechanism
function data_attitude_jacobian(mechanism::Mechanism)
attjacs = [data_attitude_jacobian.(mechanism.joints);
data_attitude_jacobian.(mechanism.bodies);
data_attitude_jacobian.(mechanism.contacts)]
attjac = cat(attjacs..., dims=(1,2))
return attjac
end
# Joints
function data_attitude_jacobian(joint::JointConstraint)
return I(data_dim(joint))
end
# Body
function data_attitude_jacobian(body::Body)
# [m,flat(J),x1,q1,x2,q2]
x2, q2 = current_configuration(body.state)
attjac = cat(I(1+6+6+3), LVᵀmat(q2), dims=(1,2))
return attjac
end
# Contacts
function data_attitude_jacobian(contact::ContactConstraint)
return I(data_dim(contact))
end
################################################################################
# Get Data
################################################################################
# Mechanism
get_data(mechanism::Mechanism) = vcat([get_data.(mechanism.joints);
get_data.(mechanism.bodies); get_data.(mechanism.contacts)]...)
# Joints
function get_data(joint::JointConstraint)
joints = (joint.translational, joint.rotational)
u = vcat(nullspace_mask.(joints) .* getfield.(joints, :input)...)
spring = joints[1].spring # assumes we have the same spring and dampers for translational and rotational joint.
damper = joints[1].damper # assumes we have the same spring and dampers for translational and rotational joint.
return [u; spring; damper]
end
# Body
function get_data(body::Body)
m = body.mass
j = flatten_inertia(body.inertia)
v15 = body.state.v15
ω15 = body.state.ω15
x2, q2 = current_configuration(body.state)
return [m; j; v15; ω15; x2; vector(q2)]
end
# Contacts
get_data(model::NonlinearContact) = [model.friction_coefficient; model.collision.contact_radius; model.collision.contact_origin]
get_data(model::LinearContact) = [model.friction_coefficient; model.collision.contact_radius; model.collision.contact_origin]
get_data(model::ImpactContact) = [model.collision.contact_radius; model.collision.contact_origin]
get_data(contact::ContactConstraint) = get_data(contact.model)
################################################################################
# Set Data
################################################################################
# Mechanism
function set_data!(mechanism::Mechanism, data::AbstractVector)
# It's important to treat bodies before eqcs
# set_data!(body) will erase state.JF2 and state.Jτ2
# set_data!(eqc) using applyinput!, will write in state.JF2 and state.Jτ2
c = 0
for joint in mechanism.joints
Nd = data_dim(joint)
set_data!(joint, data[SUnitRange(c+1,c+Nd)]); c += Nd
end
for body in mechanism.bodies
Nd = data_dim(body, attjac=false)
set_data!(body, data[SUnitRange(c+1,c+Nd)], mechanism.timestep); c += Nd
end
for contact in mechanism.contacts
Nd = data_dim(contact)
set_data!(contact, data[SUnitRange(c+1,c+Nd)]); c += Nd
end
for joint in mechanism.joints
input_impulse!(joint, mechanism, false)
end
return nothing
end
# Joints
function set_data!(joint::JointConstraint, data::AbstractVector)
nu = input_dimension(joint)
u = data[SUnitRange(1,nu)]
spring = data[nu+1]
damper = data[nu+2]
set_input!(joint, u)
for joint in (joint.translational, joint.rotational)
joint.spring=spring
joint.damper=damper
end
return nothing
end
# Body
function set_data!(body::Body, data::AbstractVector, timestep)
# [m,flat(J),x2,v15,q2,ω15]
m = data[1]
J = lift_inertia(data[SUnitRange(2,7)])
v15 = data[SUnitRange(8,10)]
ω15 = data[SUnitRange(11,13)]
x2 = data[SUnitRange(14,16)]
q2 = Quaternion(data[17:20]...)
x1 = next_position(x2, -v15, timestep)
q1 = next_orientation(q2, -ω15, timestep)
body.mass = m
body.inertia = J
body.state.x1 = x1
body.state.v15 = v15
body.state.q1 = q1
body.state.ω15 = ω15
body.state.x2 = x2
body.state.q2 = q2
body.state.JF2 = SVector{3}(0,0,0.)
body.state.Jτ2 = SVector{3}(0,0,0.)
return nothing
end
# Contact
function set_data!(model::NonlinearContact, data::AbstractVector)
model.friction_coefficient = data[1]
model.collision.contact_radius = data[2]
model.collision.contact_origin = data[SA[3;4;5]]
return nothing
end
function set_data!(model::LinearContact, data::AbstractVector)
model.friction_coefficient = data[1]
model.collision.contact_radius = data[2]
model.collision.contact_origin = data[SA[3;4;5]]
return nothing
end
function set_data!(model::ImpactContact, data::AbstractVector)
model.collision.contact_radius = data[1]
model.collision.contact_origin = data[SA[2;3;4]]
return nothing
end
function set_data!(contact::ContactConstraint, data::AbstractVector)
model = contact.model
N = data_dim(model)
set_data!(model, data[SUnitRange(1,N)])
return nothing
end
function set_data!(contacts::Vector{<:ContactConstraint}, data::AbstractVector)
c = 0
for contact in contacts
Nd = data_dim(contact)
set_data!(contact, data[SUnitRange(c+1,c+Nd)])
c += Nd
end
return nothing
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 158 | """
Constraint{T}
Abstract type for graph edge object
"""
abstract type Constraint{T,N} <: Node{T} end
Base.length(::Constraint{T,N}) where {T,N} = N | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4054 | # constraints
"""
get_joint(mechanism, name)
return JointConstraint from Mechanism
mechanism: Mechanism
name: unique identifier for joint
"""
function get_joint(mechanism::Mechanism, name::Symbol)
for joint in mechanism.joints
if joint.name == name
return joint
end
end
return
end
get_joint(mechanism::Mechanism, id::Integer) = mechanism.joints[id]
# bodies
"""
get_body(mechanism, name)
returns Body from Mechanism
mechanism: Mechanism
name: unique identifier for body
"""
function get_body(mechanism::Mechanism, name::Symbol)
if name == :origin
return mechanism.origin
else
for body in mechanism.bodies
if body.name == name
return body
end
end
end
return
end
get_body(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, id::Integer) where {T,Nn,Ne,Nb,Ni} = id == 0 ? mechanism.origin : mechanism.bodies[id-Ne]
# contacts
"""
get_contact(mechanism, name)
returns ContactConstraint from Mechanism
mechanism: Mechanism
name: unique identifier for contact
"""
function get_contact(mechanism::Mechanism, name::Symbol)
for contact in mechanism.contacts
if contact.name == name
return contact
end
end
return
end
get_contact(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, id::Integer) where {T,Nn,Ne,Nb,Ni} = mechanism.contacts[id-Ne-Nb]
# nodes
"""
get_node(mechanism, name)
return Node from Mechanism
mechanism: Mechanism
name: unique identifier for node
"""
function get_node(mechanism::Mechanism, name::Symbol)
node = get_body(mechanism, name)
if node === nothing
node = get_joint(mechanism,name)
end
if node === nothing
node = get_contact(mechanism,name)
end
return node
end
function get_node(mechanism::Mechanism{T,Nn,Ne,Nb}, id::Integer;
origin::Bool=false) where {T,Nn,Ne,Nb}
(origin && id == 0) && return mechanism.origin
if id <= Ne
return get_joint(mechanism, id)
elseif id <= Ne+Nb
return get_body(mechanism, id)
else
return get_contact(mechanism, id)
end
end
# maximal
"""
get_maximal_state(mechanism)
return the current maximal state of mechanism
mechanism: Mechanism
"""
function get_maximal_state(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}) where {T,Nn,Ne,Nb,Ni}
z = zeros(T, 13Nb)
for (i, body) in enumerate(mechanism.bodies)
x2 = body.state.x2
v15 = body.state.v15
q2 = body.state.q2
ω15 = body.state.ω15
pack_maximal_state!(z, x2, v15, q2, ω15, i)
end
return z
end
"""
get_next_state(mechanism)
return the maximal state of mechanism after one simulation step
mechanism: Mechanism
"""
function get_next_state(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}) where {T,Nn,Ne,Nb,Ni}
timestep= mechanism.timestep
z_next = zeros(T, 13Nb)
for (i, body) in enumerate(mechanism.bodies)
x3, v25, q3, ω25 = next_configuration_velocity(body.state, timestep)
z_next[13 * (i-1) .+ (1:13)] = [x3; v25; vector(q3); ω25]
end
return z_next
end
# minimal
"""
get_minimal_state(mechanism)
return minimal state for mechanism
mechanism: Mechanism
"""
function get_minimal_state(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}) where {T,Nn,Ne,Nb,Ni}
x = []
mechanism = deepcopy(mechanism)
timestep = mechanism.timestep
for joint in mechanism.joints
c = zeros(T,0)
v = zeros(T,0)
pbody = get_body(mechanism, joint.parent_id)
cbody = get_body(mechanism, joint.child_id)
for element in (joint.translational, joint.rotational)
pos = minimal_coordinates(element, pbody, cbody)
vel = minimal_velocities(element, pbody, cbody, timestep)
push!(c, pos...)
push!(v, vel...)
end
push!(x, [c; v]...)
end
x = [x...]
return x
end
function get_minimal_coordinates(mechanism::Mechanism{T}) where T
d = Dict{Int,Vector{T}}()
for joint in mechanism.joints
push!(d, joint.id => minimal_coordinates(mechanism, joint))
end
return d
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 153 | # gravity
get_gravity(g::T) where T <: Real = SVector{3,T}([0.0; 0.0; g])
get_gravity(g::Vector{T}) where T = SVector{3,T}(g)
get_gravity(g::SVector) = g | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 477 | global CURRENTID = -1
getGlobalID() = (global CURRENTID -= 1; return CURRENTID + 1)
resetGlobalID() = (global CURRENTID = -1; return)
function global_id!(nodes)
oldnewid = Dict([node.id => i for (i, node) in enumerate(nodes)]...)
for node in nodes
node.id = oldnewid[node.id]
if typeof(node) <: Constraint
node.parent_id = get(oldnewid, node.parent_id, 0)
node.child_id = get(oldnewid, node.child_id, 0)
end
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 8529 | function velocity_index(mechanism::Mechanism{T,Nn,Ne}) where {T,Nn,Ne}
ind = []
off = 0
for joint in mechanism.joints
nu = input_dimension(joint)
push!(ind, Vector(off + nu .+ (1:nu)))
off += 2nu
end
return vcat(ind...)
end
# find all the joints parents of a body
function parent_joints(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, body::Body) where {T,Nn,Ne,Nb,Ni}
ids = parents(mechanism.system, body.id)
ids = intersect(ids, 1:Ne) # filter out the bodies
return [get_node(mechanism, id) for id in ids]
end
# dimensions
"""
minimal_dimension(mechanism)
dimension of a mechanism's minimal representation
mechanism: Mechanism
"""
function minimal_dimension(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}) where {T,Nn,Ne,Nb,Ni}
nx = 0
free_rot_base = false # we are going to check if the link attached to the base has free orientation
nx = 2 * input_dimension(mechanism,
ignore_floating_base=false)
free_rot_base && (nx += 1)
return nx
end
"""
maximal_dimension(mechanism)
dimension of a mechanism's maximal representation
mechanism: Mechanism
"""
maximal_dimension(mechanism::Mechanism{T,Nn,Ne,Nb}; attjac::Bool=false) where {T,Nn,Ne,Nb} = attjac ? 12Nb : 13Nb
"""
input_dimension(mechanism)
return the number of inputs for mechanism
mechanism: Mechanism
"""
function input_dimension(mechanism::Mechanism; ignore_floating_base::Bool=false)
nu = 0
for joint in mechanism.joints
nu += input_dimension(joint; ignore_floating_base)
end
return nu
end
"""
input_dimensions(mechanism)
return an array with the input dimensions of all joints
mechanism: Mechanism
"""
function input_dimensions(mechanism::Mechanism; ignore_floating_base::Bool=false)
nus = Int64[]
for joint in mechanism.joints
push!(nus,input_dimension(joint; ignore_floating_base))
end
return nus
end
"""
set_floating_base(mechanism, name)
returns a mechanism with modified joints having body identified with 'name' as the floating base
mechanism: Mechanism
name: Symbol, identifier for floating-base body
"""
function set_floating_base(mechanism::Mechanism, name::Symbol)
# copy
mechanism = deepcopy(mechanism)
# original floating base
body1 = mechanism.origin
# new floating base
body2 = get_body(mechanism, name)
# find joint for new floating base
body = body2
joint = mechanism.joints[findall(j -> j.child_id == body.id, mechanism.joints)[1]]
joint_list = JointConstraint[]
push!(joint_list, joint)
while joint_list[end].parent_id != body1.id
push!(joint_list, mechanism.joints[findall(j -> j.child_id == joint_list[end].parent_id, mechanism.joints)[1]])
end
# reverse JointConstraint (p_old -> c_old) to (c_old -> p_old)
new_joint_list = JointConstraint[]
for j in joint_list
j = deepcopy(j)
if j.parent_id == body1.id
j.child_id = body2.id
push!(new_joint_list, j)
continue
else
parent_id = j.parent_id
child_id = j.child_id
pbody = get_body(mechanism, parent_id)
cbody = get_body(mechanism, child_id)
# translational conversion
t = j.translational
t_reverse = Translational{typeof(t).parameters[1], typeof(t).parameters[2]}(cbody, pbody;
parent_vertex=t.vertices[2],
child_vertex=t.vertices[1],
axis=-t.axis,
spring=t.spring,
damper=t.damper,
spring_offset=t.spring_offset,
joint_limits=t.joint_limits,
spring_type=t.spring_type)[1]
r = j.rotational
r_reverse = Rotational{typeof(r).parameters[1], typeof(r).parameters[2]}(cbody, pbody;
axis=-r.axis,
orientation_offset=inv(r.orientation_offset),
spring=r.spring,
damper=r.damper,
spring_offset=r.spring_offset,
joint_limits=r.joint_limits,
spring_type=r.spring_type)[1]
j.parent_id = child_id
j.child_id = parent_id
j.translational = t_reverse
j.rotational = r_reverse
end
push!(new_joint_list, j)
end
# set joints
for j in new_joint_list
mechanism.joints[j.id] = j
end
return Mechanism(mechanism.origin, mechanism.bodies, mechanism.joints, mechanism.contacts,
gravity=mechanism.gravity,
timestep=mechanism.timestep)
end
function reduce_fixed_joints(mechanism; kwargs...)
mechanism = Mechanism(reduce_fixed_joints(mechanism.origin, mechanism.bodies, mechanism.joints)...; kwargs...)
zero_coordinates!(mechanism)
return mechanism
end
# TODO currently only for non-contact mechanisms
function reduce_fixed_joints(origin, bodies, joints; merge_names=false)
remaining_bodies = ones(Bool,length(bodies))
remaining_joints = ones(Bool,length(joints))
for (j,joint) in enumerate(joints)
if typeof(joint) <: JointConstraint{T,6} where T # i.e., fixed joint
parent_body = get_origin_or_body_from_id(joint.parent_id, origin, bodies)
child_body = get_origin_or_body_from_id(joint.child_id, origin, bodies)
v1, v2 = joint.translational.vertices
q_offset = joint.rotational.orientation_offset
child_body_com = v1 - vector_rotate(v2,q_offset) # in parent_body's frame
if parent_body == origin
new_body_com = zeros(3)
else
parent_m, child_m = parent_body.mass, child_body.mass
parent_J, child_J = parent_body.inertia, child_body.inertia
new_body_com = child_body_com*child_m/(parent_m+child_m) # in parent_body's frame
parent_body.mass = parent_m + child_m
new_body_J1 = parent_J + parent_m*skew(-new_body_com)'*skew(-new_body_com) # in new_body's frame
new_body_J2 = matrix_transform(child_J,q_offset) + child_m*skew(child_body_com-new_body_com)'*skew(child_body_com-new_body_com) # in new_body's frame
parent_body.inertia = new_body_J1 + new_body_J2 # in new_body's frame
end
if !(typeof(parent_body.shape) <: EmptyShape)
parent_body.shape.position_offset += -new_body_com # in new_body's frame
end
if !(typeof(child_body.shape) <: EmptyShape)
child_body.shape.position_offset += child_body_com-new_body_com # in new_body's frame
child_body.shape.orientation_offset *= q_offset
end
parent_body.shape = CombinedShapes([parent_body.shape;child_body.shape])
merge_names && (parent_body.name = Symbol(parent_body.name,"_merged_with_",child_body.name))
for joint2 in joints
joint2 == joint && continue
v21, v22 = joint2.translational.vertices
q_offset2 = joint2.rotational.orientation_offset
if joint2.parent_id == parent_body.id
joint2.translational.vertices = (v21-new_body_com, v22)
elseif joint2.child_id == parent_body.id
joint2.translational.vertices = (v21,v22-new_body_com)
elseif joint2.parent_id == child_body.id
joint2.parent_id = parent_body.id
joint2.translational.vertices = (vector_rotate(v21,q_offset)+child_body_com-new_body_com, v22)
joint2.rotational.orientation_offset = q_offset*q_offset2 # correct?
elseif joint2.child_id == child_body.id
joint2.child_id = parent_body.id
joint2.translational.vertices = (v21,vector_rotate(v22,q_offset)+child_body_com-new_body_com)
joint2.rotational.orientation_offset = q_offset*q_offset2 # correct?
end
end
remaining_joints[j] = false
remaining_bodies[findfirst(x->x==child_body,bodies)] = false
end
end
return origin, bodies[remaining_bodies], joints[remaining_joints]
end
function get_origin_or_body_from_id(id, origin, bodies)
origin.id == id && (return origin)
for body in bodies
body.id == id && (return body)
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 87 | """
Node{T}
Abstract type for graph node object
"""
abstract type Node{T} end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3621 | # maximal
"""
set_maximal_state(mechanism, z)
set the maximal state of a mechanism
mechanism: Mechanism
z: state
"""
function set_maximal_state!(mechanism::Mechanism, z::AbstractVector)
off = 0
for body in mechanism.bodies
x2, v15, q2, ω15 = unpack_data(z[SUnitRange(off+1,end)]); off += 13
q2 = Quaternion(q2...)
body.state.v15 = v15
body.state.ω15 = ω15
body.state.x2 = x2
body.state.q2 = q2
initialize_state!(mechanism) # set x1, q1 and zeroes out JF2 Jτ2
end
# warm-start solver
for body in mechanism.bodies
set_velocity_solution!(body)
end
end
function initialize_state!(mechanism::Mechanism)
for body in mechanism.bodies initialize_state!(body, mechanism.timestep) end
end
# inputs
"""
set_input(mechanism, u)
set input for each joint in mechanism
mechanism: Mechanism
u: input
"""
function set_input!(mechanism::Mechanism{T}, u::AbstractVector) where T
joints = mechanism.joints
# set the controls in the equality constraints
off = 0
for joint in joints
nu = input_dimension(joint)
set_input!(joint, SVector{nu,T}(u[SUnitRange(off+1,off+nu)]))
off += nu
end
# apply the controls to each body's state
for joint in joints
input_impulse!(joint, mechanism)
end
end
function set_input!(mechanism::Mechanism, dict::Dict)
for (id, joint) in pairs(mechanism.joints)
set_input!(joint, dict[id])
end
end
# minimal
"""
set_minimal_state(mechanism, y)
set the minimal state of a mechanism
mechanism: Mechanism
y: state
"""
function set_minimal_state!(mechanism::Mechanism, y::AbstractVector)
z = minimal_to_maximal(mechanism, y)
set_maximal_state!(mechanism, z)
end
function set_minimal_coordinates!(mechanism::Mechanism, dict::Dict)
for (id, joint) in pairs(mechanism.joints)
set_minimal_coordinates!(mechanism, joint, dict[id])
end
end
function set_minimal_velocities!(mechanism::Mechanism, dict::Dict)
for (id, joint) in pairs(mechanism.joints)
set_minimal_velocities!(mechanism, joint, dict[id])
end
end
"""
zero_coordinates!(mechanism)
set all mechanism body coordinates to zero
mechanism: Mechanism
"""
function zero_coordinates!(mechanism::Mechanism)
for id in root_to_leaves_ordering(mechanism, exclude_origin=true, exclude_loop_joints=true)
joint = get_node(mechanism, id)
!(joint isa JointConstraint) && continue
cnode = get_node(mechanism, joint.child_id)
pnode = get_node(mechanism, joint.parent_id, origin=true)
parent_vertex, child_vertex = joint.translational.vertices
Δq = joint.rotational.orientation_offset
set_maximal_configurations!(cnode) # set everything to zero
set_maximal_configurations!(pnode, cnode; parent_vertex, child_vertex, Δq)
end
end
# velocity
"""
zero_velocities!(mechanism)
set all mechanism body velocities to zero
mechanism: Mechanism
"""
function zero_velocities!(mechanism::Mechanism)
for (i, body) in enumerate(mechanism.bodies)
try
set_maximal_velocities!(body, v=zeros(3), ω=zeros(3))
set_previous_configuration!(body, mechanism.timestep)
catch
nothing
end
end
end
# springs + dampers
function set_spring_offset!(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, x::AbstractVector) where {T,Nn,Ne,Nb,Ni}
off = 0
for joint in mechanism.joints
N̄ = 3 - length(joint)
joint.spring_offset = x[SUnitRange(off+1,off+N̄)]
off += 2N̄
end
return
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2468 | """
minimal_to_maximal(mechanism, y)
convert minimal to maximal representation
mechanism: Mechanism
y: minimal state
"""
function minimal_to_maximal(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, y::AbstractVector) where {T,Nn,Ne,Nb,Ni}
temp_mechanism = deepcopy(mechanism)
nus = input_dimensions(mechanism)
for id in temp_mechanism.root_to_leaves
(id > Ne) && continue # only treat joints
joint = temp_mechanism.joints[id]
nu = input_dimension(joint)
off = sum(nus[SUnitRange(1,id-1)])*2
set_minimal_coordinates_velocities!(temp_mechanism, joint, xmin=y[SUnitRange(off+1,off+2nu)]) # TODO does this actually set a state and not just convert min to max?
end
return get_maximal_state(temp_mechanism)
end
function joint_indices(mechanism::Mechanism{T,Nn,Ne}) where {T,Nn,Ne}
ind = []
off = 0
for joint in mechanism.joints
nu = input_dimension(joint)
push!(ind, Vector(off + nu .+ (1:nu)))
off += 2nu
end
return vcat(ind...)
end
"""
maximal_to_minimal(mechanism, z)
convert maximal to minimal representation
mechanism: Mechanism
z: maximal state
"""
function maximal_to_minimal(mechanism::Mechanism{T,Nn,Ne,Nb,Ni}, z::AbstractVector{Tz}) where {T,Nn,Ne,Nb,Ni,Tz}
x = []
for joint in mechanism.joints
c = zeros(Tz,0)
v = zeros(Tz,0)
i_child = joint.child_id - Ne
for element in (joint.translational, joint.rotational)
xb, vb, qb, ωb = unpack_maximal_state(z, i_child)
if joint.parent_id != 0
i_parent = joint.parent_id - Ne
xa, va, qa, ωa = unpack_maximal_state(z, i_parent)
else
xa, va, qa, ωa = current_configuration_velocity(mechanism.origin.state)
end
push!(c, minimal_coordinates(element, xa, qa, xb, qb)...)
push!(v, minimal_velocities(element, xa, va, qa, ωa, xb, vb, qb, ωb, mechanism.timestep)...)
end
push!(x, [c; v]...)
end
x = [x...]
return x
end
function unpack_maximal_state(z::AbstractVector, i::Int)
zi = z[SUnitRange((i-1)*13+1,i*13)]
x2 = zi[SUnitRange(1,3)]
v15 = zi[SUnitRange(4,6)]
q2 = Quaternion(zi[SUnitRange(7,10)]...)
ω15 = zi[SUnitRange(11,13)]
return x2, v15, q2, ω15
end
function pack_maximal_state!(z::AbstractVector,
x2::AbstractVector, v15::AbstractVector, q2::Quaternion, ω15::AbstractVector,
i::Int)
z[SUnitRange((i-1)*13+1,(i-1)*13+3)] = x2
z[SUnitRange((i-1)*13+4,(i-1)*13+6)] = v15
z[SUnitRange((i-1)*13+7,(i-1)*13+10)] = vector(q2)
z[SUnitRange((i-1)*13+11,(i-1)*13+13)] = ω15
return nothing
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2343 | function create_system(origin::Origin{T}, joints::Vector{<:JointConstraint}, bodies::Vector{<:Body}, contacts::Vector{<:ContactConstraint}) where T
adjacency = adjacency_matrix(joints, bodies, contacts)
dims = length.([joints; bodies; contacts])
system = System{T}(adjacency, dims)
for joint in joints
joint.parent_id == origin.id && (joint.parent_id = 0)
end
origin.id = 0
return system
end
function adjacency_matrix(joints::Vector{<:JointConstraint}, bodies::Vector{<:Body}, contacts::Vector{<:ContactConstraint})
nodes = [joints; bodies; contacts]
n = length(nodes)
A = zeros(Bool, n, n)
for node1 in nodes
for node2 in nodes
if typeof(node1) <: Constraint
node2.id == node1.child_id && (A[node1.id, node2.id] = 1)
elseif typeof(node2) <: Constraint
node1.id == node2.parent_id && (A[node1.id, node2.id] = 1)
# TODO these entries linking two bodies should be removed,
# not sure why this is breaking some of the tests
elseif typeof(node1) <: Body && typeof(node2) <: Body
for joint in joints
if node1.id == joint.parent_id && node2.id == joint.child_id
A[node1.id, node2.id] = 1
end
if node2.id == joint.parent_id && node1.id == joint.child_id
A[node2.id, node1.id] = 1
end
end
# for contact in contacts
# if node1.id == contact.parent_id && node2.id == contact.child_id
# A[node1.id, node2.id] = 1
# end
# if node2.id == contact.parent_id && node1.id == contact.child_id
# A[node2.id, node1.id] = 1
# end
# end
end
end
end
A = convert(Matrix{Int64}, A .| A')
return A
end
get_entry(system, id1, id2) = system.matrix_entries[id1, id2]
get_entry(system, id) = system.vector_entries[id]
function recursivedirectchildren!(system, id::Integer)
dirs = copy(children(system, id))
dirslocal = copy(dirs)
for child_id in dirslocal
append!(dirs, recursivedirectchildren!(system, child_id))
end
return dirs
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2713 | """
root_to_leaves_ordering(mechanism; exclude_origin, exclude_loop_joints)
ordered list of ids from root to leaves, all nodes are visited a single time
excluding: origin, joints forming a loop which are not visited
mechanism: Mechanism
exclude_origin: flag to exclude origin from traversal
exclude_loop_joints: flag to exclude loop joints from traversal
"""
function root_to_leaves_ordering(mechanism::Mechanism{T};
exclude_origin::Bool=true,
exclude_loop_joints::Bool=true) where T
nodes = [mechanism.origin; mechanism.bodies; mechanism.joints; mechanism.contacts]
loop_joints = get_loop_joints(mechanism.bodies, mechanism.joints)
return root_to_leaves_ordering(nodes, loop_joints,
exclude_origin=exclude_origin, exclude_loop_joints=exclude_loop_joints)
end
function root_to_leaves_ordering(nodes::Vector{Node{T}}, loop_joints;
exclude_origin::Bool=true,
exclude_loop_joints::Bool=true) where T
ids = Vector{Int64}()
stack = [0]
while length(stack) > 0
ids, stack = explore(ids, stack, nodes, loop_joints)
end
exclude_origin && (ids = ids[2:end]) # remove origin
!exclude_loop_joints && push!(ids, getfield.(loop_joints, :id)...) # add loop_joints
return ids
end
function explore(ids::Vector{Int}, stack::Vector{Int}, nodes::Vector{Node{T}}, loop_joints) where T
loop_joints_ids = getfield.(loop_joints, :id)
id = pop!(stack)
push!(ids, id)
node = nodes[findfirst(n -> n.id == id, nodes)]
child_ids = get_child_ids(node, nodes)
setdiff!(child_ids, loop_joints_ids)
push!(stack, child_ids...)
return ids, stack
end
function get_child_ids(joint::JointConstraint, nodes::Vector{Node{T}}) where T
[joint.child_id]
end
function get_child_ids(node::Node, nodes::Vector{Node{T}}) where T
child_ids = Vector{Int64}()
for cnode in nodes
if !(cnode isa Origin) && !(cnode isa Body)
(cnode.parent_id == node.id) && push!(child_ids, cnode.id)
end
end
return child_ids
end
function get_child_ids(body::Contact, nodes::Vector{Node{T}}) where T
Vector{Int64}()
end
function get_loop_joints(bodies::Vector{<:Body}, joints::Vector{<:JointConstraint})
# Assumes that the Origin cannot be the child of a joint.
# the results is dependent on the ordering of the joints provided to the method.
loop_joints = []
body_ids = getfield.(bodies, :id)
visited_bodies = zeros(Int,0)
for joint in joints
if joint.child_id in visited_bodies
push!(loop_joints, joint)
else
push!(visited_bodies, joint.child_id)
end
end
return [loop_joints...]
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 22653 | ### Before parsing
unsafeattribute(::Nothing, ::Core.AbstractString) = nothing
unsafeattribute(x::LightXML.XMLElement, name::Core.AbstractString) = attribute(x, name)
function parse_scalar(xel, name::String, T; default::Union{String,Nothing}=nothing)
scalarstr = unsafeattribute(xel, name)
if scalarstr === nothing
if default === nothing
@error "no parsable scalar found"
else
scalarstr = default
end
end
return parse(T, scalarstr)
end
function parse_vector(xel, name::String, T; default::Union{String,Nothing}=nothing)
vectorstr = unsafeattribute(xel, name)
if vectorstr === nothing
if default === nothing
@error "no parsable vector found"
else
vectorstr = default
end
end
return parse.(T,split(vectorstr))
end
function parse_inertiamatrix(xinertia, T)
if xinertia === nothing
J = zeros(T, 3, 3)
else
ixx = parse_scalar(xinertia, "ixx", T)
ixy = parse_scalar(xinertia, "ixy", T; default = "0")
ixz = parse_scalar(xinertia, "ixz", T; default = "0")
iyy = parse_scalar(xinertia, "iyy", T)
iyz = parse_scalar(xinertia, "iyz", T; default = "0")
izz = parse_scalar(xinertia, "izz", T)
J = [ixx ixy ixz; ixy iyy iyz; ixz iyz izz]
end
return J
end
function parse_pose(xpose, T)
if xpose === nothing
x, q = zeros(T, 3), one(Quaternion{T})
else
x = parse_vector(xpose, "xyz", T; default = "0 0 0")
rpy = parse_vector(xpose, "rpy", T; default = "0 0 0")
q = RotZ(rpy[3])*RotY(rpy[2])*RotX(rpy[1])
end
return x, q
end
function parse_inertia(xinertial, T)
if xinertial === nothing
x = zeros(T, 3)
q = one(Quaternion{T})
m = zero(T)
J = zeros(T, 3, 3)
else
x, q = parse_pose(find_element(xinertial, "origin"), T)
J = parse_inertiamatrix(find_element(xinertial, "inertia"), T)
m = parse_scalar(find_element(xinertial, "mass"), "value", T; default = "0")
end
return x, q, m, J
end
function parse_robotmaterials(xroot, T)
xmaterials = get_elements_by_tagname(xroot, "material")
mdict = Dict{String,Vector{T}}()
for xmaterial in xmaterials
name = attribute(xmaterial, "name")
colornode = find_element(xmaterial, "color")
colorvec = parse_vector(colornode, "rgba", T)
mdict[name] = colorvec
end
return mdict
end
function parse_xmaterial(xmaterial, materialdict, T)
if xmaterial === nothing
color = RGBA(0.75, 0.75, 0.75)
else
name = unsafeattribute(xmaterial, "name")
if haskey(materialdict, name)
colorvec = materialdict[name]
else
colorvec = [0.75; 0.75; 0.75; 1.0]
end
colornode = find_element(xmaterial, "color")
colorvec = parse_vector(colornode, "rgba", T; default = string(colorvec[1]," ",colorvec[2]," ",colorvec[3]," ",colorvec[4]))
color = RGBA(colorvec...)
end
return color
end
# function parse_shape(xvisual, materialdict, T, xb, qb)
function parse_shape(xvisual, materialdict, T; path_prefix)
if xvisual === nothing
shape = nothing
else
xgeometry = find_element(xvisual, "geometry")
@assert xgeometry !== nothing
color = parse_xmaterial(find_element(xvisual, "material"), materialdict, T)
x, q = parse_pose(find_element(xvisual, "origin"), T)
shapenodes = LightXML.XMLElement[]
for node in child_nodes(xgeometry) # node is an instance of XMLNode
if is_elementnode(node)
push!(shapenodes, XMLElement(node))
end
end
if length(shapenodes) == 0
shape = nothing
else
if length(shapenodes) > 1
@warn "Multiple geometries."
end
shapenode = shapenodes[1]
shape = get_shape(shapenode, x, q, color, T; path_prefix)
end
end
return shape
end
function get_shape(shapenode, x, q, color, T; path_prefix)
if name(shapenode) == "box"
xyz = parse_vector(shapenode, "size", T; default = "1 1 1")
shape = Box(xyz..., zero(T); color, position_offset = x, orientation_offset = q)
elseif name(shapenode) == "cylinder"
r = parse_scalar(shapenode, "radius", T; default = "0.5")
l = parse_scalar(shapenode, "length", T; default = "1")
shape = Cylinder(r, l, zero(T); color, position_offset = x, orientation_offset = q)
elseif name(shapenode) == "pyramid"
w = parse_scalar(shapenode, "width", T; default = "1")
h = parse_scalar(shapenode, "height", T; default = "1")
shape = Cylinder(w, h, zero(T); color, position_offset = x, orientation_offset = q)
elseif name(shapenode) == "sphere"
r = parse_scalar(shapenode, "radius", T; default = "0.5")
shape = Sphere(r, zero(T); color, position_offset = x, orientation_offset = q)
elseif name(shapenode) == "mesh"
path = attribute(shapenode, "filename")
scale = parse_vector(shapenode, "scale", T; default = "1 1 1")
shape = Mesh(normpath(joinpath(path_prefix, path)), zero(T), zeros(T, 3, 3); scale, color, position_offset = x, orientation_offset = q)
elseif name(shapenode) == "capsule"
r = parse_scalar(shapenode, "radius", T; default = "0.5")
l = parse_scalar(shapenode, "length", T; default = "1")
shape = Capsule(r, l, zero(T); color, position_offset = x, orientation_offset = q)
else
@info "Unknown geometry."
shape = nothing
end
end
function parse_link(xlink, materialdict, T; path_prefix)
x, q, m, J = parse_inertia(find_element(xlink, "inertial"), T)
xvisuals = get_elements_by_tagname(xlink, "visual")
shapes = [parse_shape(xvisual, materialdict, T; path_prefix) for xvisual in xvisuals]
# shapes = [parse_shape(xvisual, materialdict, T, x, q) for xvisual in xvisuals]
if length(shapes) == 0
shape = nothing
elseif length(shapes) > 1
s = [s.shape for s in shapes]
shape = CombinedShapes(s, 0.0, szeros(3,3))
else
shape = shapes[1]
end
name = attribute(xlink, "name")
if shape === nothing
link = Body(m, J, name=Symbol(name))
else
link = shape
link.mass = m
link.inertia = J
link.name = Symbol(name)
end
link.state.x2 = x
link.state.q2 = q
return link
end
function parse_links(xlinks, materialdict, T; path_prefix)
ldict = Dict{Symbol,Body{T}}()
for xlink in xlinks
link = parse_link(xlink, materialdict, T; path_prefix)
ldict[link.name] = link
end
return ldict
end
# TODO: fix axis
function joint_selector(joint_type, pbody, cbody, T;
axis = SA{T}[1;0;0], parent_vertex = szeros(T,3), child_vertex = szeros(T,3), orientation_offset = one(Quaternion{T}), name = Symbol("joint_" * randstring(4)), damper = zero(T))
# TODO @warn "this is not great"
# axis = vector_rotate(axis, orientation_offset) # inv(orientation_offset) * axis
# TODO limits for revolute joint?
if joint_type == "revolute" || joint_type == "continuous"
joint = JointConstraint(Revolute(pbody, cbody, axis; parent_vertex, child_vertex, orientation_offset, damper); name)
elseif joint_type == "prismatic"
joint = JointConstraint(Prismatic(pbody, cbody, axis; parent_vertex, child_vertex, orientation_offset, damper); name)
elseif joint_type == "planar"
joint = JointConstraint(Planar(pbody, cbody, axis; parent_vertex, child_vertex, orientation_offset, damper); name)
elseif joint_type == "planarfree"
joint = JointConstraint(PlanarFree(pbody, cbody, axis; parent_vertex, child_vertex, damper); name)
elseif joint_type == "fixed"
joint = JointConstraint(Fixed(pbody, cbody; parent_vertex, child_vertex, orientation_offset); name)
elseif joint_type == "floating"
joint = JointConstraint(Floating(pbody, cbody; damper); name)
elseif joint_type == "orbital"
joint = JointConstraint(Orbital(pbody, cbody, axis; parent_vertex, child_vertex, orientation_offset, damper); name)
elseif joint_type == "ball"
joint = JointConstraint(Spherical(pbody, cbody; parent_vertex, child_vertex, orientation_offset, damper); name)
elseif joint_type == "fixedorientation"
joint = JointConstraint(FixedOrientation(pbody, cbody; orientation_offset, damper); name)
elseif joint_type == "cylindrical"
joint = JointConstraint(Cylindrical(pbody, cbody, axis; parent_vertex, child_vertex, orientation_offset, damper); name)
elseif joint_type == "cylindricalfree"
joint = JointConstraint(CylindricalFree(pbody, cbody, axis; parent_vertex, child_vertex, damper); name)
elseif joint_type == "planaraxis"
joint = JointConstraint(PlanarAxis(pbody, cbody, axis; parent_vertex, child_vertex, orientation_offset, damper); name)
else
@error "Unknown joint type"
end
return joint
end
function parse_joint(xjoint, plink, clink, T, parse_dampers)
joint_type = attribute(xjoint, "type")
x, q = parse_pose(find_element(xjoint, "origin"), T)
axis = parse_vector(find_element(xjoint, "axis"), "xyz", T; default = "1 0 0")
parent_vertex = x
name = Symbol(attribute(xjoint, "name"))
parse_dampers ? damper = parse_scalar(find_element(xjoint, "dynamics"), "damping", T; default = "0") : damper = 0
return joint_selector(joint_type, plink, clink, T; axis, parent_vertex, orientation_offset = q, name, damper)
end
function parse_loop_joint(xjoint, pbody, cbody, T, parse_dampers)
find_element(xjoint, "link1")
find_element(xjoint, "link2")
joint_type = attribute(xjoint, "type")
axis = parse_vector(find_element(xjoint, "axis"), "xyz", T, default = "1 0 0")
x1, q1 = parse_pose(find_element(xjoint, "link1"), T)
x2, _ = parse_pose(find_element(xjoint, "link2"), T) # The orientation q2 of the second body is ignored because it is determined by the mechanism's structure
parent_vertex = x1
child_vertex = x2
name = Symbol(attribute(xjoint, "name"))
parse_dampers ? damper = parse_scalar(find_element(xjoint, "dynamics"), "damping", T; default = "0") : damper = 0
return joint_selector(joint_type, pbody, cbody, T; axis, parent_vertex, child_vertex, orientation_offset = q1, name, damper)
end
function parse_joints(xjoints, ldict, floating, T, parse_dampers)
origins = Origin{T}[]
links = Body{T}[]
joints = JointConstraint{T}[]
floatingname = ""
for name in keys(ldict)
childflag = false
for xjoint in xjoints
xchild = find_element(xjoint, "child")
childname = attribute(xchild, "link")
if Symbol(childname) == name
childflag = true
break
end
end
if childflag
push!(links, ldict[name])
else
origin = Origin{T}()
if floating # keep current link and create new origin
push!(links, ldict[name])
floatingname = name
else # make current link origin
origin = Origin(ldict[name])
end
push!(origins, origin)
end
end
@assert length(origins) == 1 "Multiple origins"
origin = origins[1]
for xjoint in xjoints
xplink = find_element(xjoint, "parent")
xclink = find_element(xjoint, "child")
clink = ldict[Symbol(attribute(xclink, "link"))]
plink = ldict[Symbol(attribute(xplink, "link"))]
if plink.id == origin.id
plink = origin
joint = parse_joint(xjoint, plink, clink, T, parse_dampers)
joints = [joint; joints] # For proper parsing the first joint must be connected to the origin
else
joint = parse_joint(xjoint, plink, clink, T, parse_dampers)
push!(joints, joint)
end
end
if floating
originjoint = JointConstraint(Floating(origin, ldict[Symbol(floatingname)]), name=:floating_base)
joints = [originjoint; joints] # For proper parsing the first joint must be connected to the origin
end
return origin, links, joints
end
# TODO This might be missing the detection of a direct loop, i.e., only two links connected by two joints
# TODO Also only works for a single loop closure in a cycle (so no ladders)
function parse_loop_joints(xloopjoints, origin, joints, ldict, T, parse_dampers)
loopjoints = JointConstraint{T}[]
for xloopjoint in xloopjoints
xpbody = find_element(xloopjoint, "link1")
xcbody = find_element(xloopjoint, "link2")
pbody = ldict[Symbol(attribute(xpbody, "link"))]
cbody = ldict[Symbol(attribute(xcbody, "link"))]
predlist = Tuple{Int64,Int64}[]
jointlist = [(joints[i].id,joints[i].parent_id, joints[i].child_id) for i in eachindex(joints)]
linkid = pbody.id
while true # create list of predecessor joints and parent links for pbody
for (i,jointdata) in enumerate(jointlist)
if linkid ∈ jointdata[3]
push!(predlist,(jointdata[1],jointdata[2]))
linkid = jointdata[2]
deleteat!(jointlist,i)
break
end
end
if linkid == origin.id
break
end
end
jointlist = [(joints[i].id, joints[i].parent_id, joints[i].child_id) for i in eachindex(joints)]
linkid = cbody.id
joint1id = 0
joint2id = 0
foundflag = false
while true # check which predecessor link of cbody is also a predecessor link of pbody
for (i,jointdata) in enumerate(jointlist)
if linkid ∈ jointdata[3]
joint2id = jointdata[1]
linkid = jointdata[2]
deleteat!(jointlist,i)
break
end
end
for el in predlist
if linkid == el[2]
joint1id = el[1]
foundflag = true
break
end
end
foundflag && break
end
loopjoint = parse_loop_joint(xloopjoint, pbody, cbody, T, parse_dampers)
push!(loopjoints, loopjoint)
end
return joints, loopjoints
end
function parse_urdf(filename, floating, ::Type{T}, parse_dampers) where T
xdoc = LightXML.parse_file(filename)
xroot = LightXML.root(xdoc)
@assert LightXML.name(xroot) == "robot"
xlinks = get_elements_by_tagname(xroot, "link")
xjoints = get_elements_by_tagname(xroot, "joint")
xloopjoints = get_elements_by_tagname(xroot, "loop_joint")
materialdict = parse_robotmaterials(xroot, T)
ldict = parse_links(xlinks, materialdict, T; path_prefix=dirname(filename))
origin, links, joints = parse_joints(xjoints, ldict, floating, T, parse_dampers)
joints, loopjoints = parse_loop_joints(xloopjoints, origin, joints, ldict, T, parse_dampers)
free(xdoc)
return origin, links, joints, loopjoints
end
### After parsing
function set_parsed_values!(mechanism::Mechanism{T}, loopjoints) where T
system = mechanism.system
timestep= mechanism.timestep
xjointlist = Dict{Int64,SVector{3,T}}() # stores id, x in world frame
qjointlist = Dict{Int64,Quaternion{T}}() # stores id, q in world frame
for id in root_to_leaves_ordering(mechanism, exclude_origin=true, exclude_loop_joints=true)
node = get_node(mechanism, id)
!(node isa JointConstraint) && continue # only for joints
# Parent joint --> Parent body --> Child joint --> Child body
# Child joint (joint of interest here)
cjoint = node
x_cjoint = cjoint.translational.vertices[1] # stored in parent_vertex
q_cjoint = cjoint.rotational.orientation_offset # stored in orientation_offset
# axis_pjoint = #
# Child body (body of interest here)
cnode = get_node(mechanism, cjoint.child_id) # x and q are stored in x2[1] and q2[1]
shape = cnode.shape
# x_cnode = cnode.state.x2
# q_cnode = cnode.state.q2
xbodylocal = cnode.state.x2
qbodylocal = cnode.state.q2
# Parent body
pnode = get_node(mechanism, cjoint.parent_id, origin=true) # x and q are stored in x2[1] and q2[1]
# x_pnode = pnode.state.x2
# q_pnode = pnode.state.q2
xparentbody = pnode.state.x2
qparentbody = pnode.state.q2
# Parent joint
if pnode.id == 0 # parent body is origin
# x_pjoint = SA{T}[0; 0; 0]
# q_pjoint = one(Quaternion{T})
# # axis_pjoint = SA{T}[1; 0; 0]
xparentjoint = SA{T}[0; 0; 0]
qparentjoint = one(Quaternion{T})
else
pjoint = get_node(mechanism, get_parent_id(mechanism, pnode.id, loopjoints))
# x_pjoint = pjoint.translational.vertices[1] # stored in parent_vertex
# q_pjoint = pjoint.rotational.orientation_offset # stored in orientation_offset
# # axis_pjoint = #
xparentjoint = xjointlist[pjoint.id] # in world frame
qparentjoint = qjointlist[pjoint.id] # in world frame
end
# urdf joint's x and q in parent's (parentbody) frame
# xjointlocal = vector_rotate(x_pjoint + vector_rotate(x_cjoint, q_pjoint) - x_pnode, inv(q_pnode))
xjointlocal = vector_rotate(xparentjoint + vector_rotate(x_cjoint, qparentjoint) - xparentbody, inv(qparentbody))
qjointlocal = qparentbody \ qparentjoint * q_cjoint
# store joint's x and q in world frame
xjoint = xparentbody + vector_rotate(xjointlocal, qparentbody)
qjoint = qparentbody * qjointlocal
xjointlist[cjoint.id] = xjoint
qjointlist[cjoint.id] = qjoint
# difference to parent body (parentbody)
orientation_offset = qjointlocal * qbodylocal
# actual joint properties
parent_vertex = xjointlocal # in parent's (parentbody) frame
child_vertex = vector_rotate(-xbodylocal, inv(qbodylocal)) # in body frame (xbodylocal and qbodylocal are both relative to the same (joint) frame -> rotationg by inv(body.q) gives body frame)
cjoint.translational.vertices = (parent_vertex, child_vertex)
# V3 = vector_rotate(cjoint.rotational.axis_mask3', qjointlocal) # in parent's (parentbody) frame
# V1 = (svd(skew(V3)).Vt)[1:1,:]
# V2 = (svd(skew(V3)).Vt)[2:2,:]
# cjoint.rotational.axis_mask3 = SVector{3}(V3)'
# cjoint.rotational.axis_mask1 = SVector{3}(V1)'
# cjoint.rotational.axis_mask2 = SVector{3}(V2)'
cjoint.rotational.orientation_offset = orientation_offset # in parent's (parentbody) frame
# actual body properties
set_maximal_configurations!(cnode) # set everything to zero
set_maximal_configurations!(pnode, cnode; parent_vertex, child_vertex, Δq = orientation_offset)
xbody = cnode.state.x2
qbody = cnode.state.q2
# shape relative
if !(typeof(shape) <: EmptyShape)
shape.position_offset = vector_rotate(xjoint + vector_rotate(shape.position_offset, qjoint) - xbody, inv(qbody))
shape.orientation_offset = orientation_offset \ qjointlocal * shape.orientation_offset
end
end
for (i,constraint) in enumerate(loopjoints)
parent_id1 = constraint.parent_id
parent_id2 = constraint.child_id
if parent_id1 == 0 # predecessor is origin
parentpbody = mechanism.origin
xparentpbody = SA{T}[0; 0; 0]
qparentpbody = one(Quaternion{T})
xparentjoint1 = SA{T}[0; 0; 0]
qparentjoint1 = one(Quaternion{T})
else
parentpbody = get_body(mechanism, parent_id1)
grandparent_id1 = get_parent_id(mechanism, parent_id1, loopjoints)
parentconstraint1 = get_joint(mechanism, grandparent_id1)
xparentpbody = parentpbody.state.x2 # in world frame
qparentpbody = parentpbody.state.q2 # in world frame
xparentjoint1 = xjointlist[parentconstraint1.id] # in world frame
qparentjoint1 = qjointlist[parentconstraint1.id] # in world frame
end
parentcbody = get_body(mechanism, parent_id2)
grandparent_id2 = get_parent_id(mechanism, parent_id2, loopjoints)
parentconstraint2 = get_joint(mechanism, grandparent_id2)
xparentcbody = parentcbody.state.x2 # in world frame
qparentcbody = parentcbody.state.q2 # in world frame
xparentjoint2 = xjointlist[parentconstraint2.id] # in world frame
qparentjoint2 = qjointlist[parentconstraint2.id] # in world frame
ind1 = 1
ind2 = ind1+1
# urdf joint's x and q in parent's (parentbody) frame
xjointlocal1 = vector_rotate(xparentjoint1 + vector_rotate(constraint.translational.vertices[1], qparentjoint1) - xparentpbody, inv(qparentpbody))
xjointlocal2 = vector_rotate(xparentjoint2 + vector_rotate(constraint.translational.vertices[2], qparentjoint2) - xparentcbody, inv(qparentcbody))
qjointlocal1 = qparentpbody \ qparentjoint1 * constraint.rotational.orientation_offset
# difference to parent body (parentbody)
orientation_offset1 = qjointlocal1 * qparentcbody # qparentcbody = body in for loop above
# actual joint properties
parent_vertex = xjointlocal1 # in parent's (parentpbody) frame
child_vertex = xjointlocal2 # in parent's (parentcbody) frame
constraint.translational.vertices = (parent_vertex, child_vertex)
V3 = vector_rotate(constraint.rotational.axis_mask3', qjointlocal1) # in parent's (parentpbody) frame
V1 = (svd(skew(V3)).Vt)[1:1,:]
V2 = (svd(skew(V3)).Vt)[2:2,:]
constraint.rotational.axis_mask3 = SVector{3}(V3)'
constraint.rotational.axis_mask1 = SVector{3}(V1)'
constraint.rotational.axis_mask2 = SVector{3}(V2)'
constraint.rotational.orientation_offset = orientation_offset1 # in parent's (parentpbody) frame
end
end
function get_parent_id(mechanism, id, loopjoints)
system = mechanism.system
conns = connections(system, id)
for connsid in conns
constraint = get_joint(mechanism, connsid)
if constraint ∉ loopjoints && id == constraint.child_id
return connsid
end
end
return nothing
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1586 | function axis_angle_to_quaternion(x)
@assert length(x) == 3
θ = norm(x)
if θ > 0.0
r = x ./ θ
q = Quaternion(cos(0.5 * θ), (sin(0.5 * θ) * r)...)
else
q = Quaternion(1.0, 0.0, 0.0, 0.0)
end
return q
end
function daxis_angle_to_quaterniondx(x)
θ = norm(x)
if θ > 0.0
r = x ./ θ
∂qw∂x = -0.5 * sin(0.5 * θ) * transpose(x) ./ θ
∂qx∂x = 0.5 * cos(0.5 * θ) * transpose(x) ./ θ * r[1] + [sin(0.5 * θ) / θ 0.0 0.0] - sin(0.5 * θ) * x[1] / θ^2 * transpose(x) ./ θ
∂qy∂x = 0.5 * cos(0.5 * θ) * transpose(x) ./ θ * r[2] + [0.0 sin(0.5 * θ) / θ 0.0] - sin(0.5 * θ) * x[2] / θ^2 * transpose(x) ./ θ
∂qz∂x = 0.5 * cos(0.5 * θ) * transpose(x) ./ θ * r[3] + [0.0 0.0 sin(0.5 * θ) / θ] - sin(0.5 * θ) * x[3] / θ^2 * transpose(x) ./ θ
return [
∂qw∂x;
∂qx∂x;
∂qy∂x;
∂qz∂x;
]
else
return [
0.0 0.0 0.0;
0.5 0.0 0.0;
0.0 0.5 0.0;
0.0 0.0 0.5;
]
end
end
function axes_pair_to_quaternion(n1, n2)
if norm(n1 + n2, Inf) < 1e-5
n2 = n2 + 1e-5ones(3)
end
reg(x) = 1e-20 * (x == 0) + x
# provides the quaternion that rotates n1 into n2, assuming n1 and n2 are normalized
n1 ./= reg(norm(n1))
n2 ./= reg(norm(n2))
n3 = skew(n1)*n2
cθ = n1' * n2 # cosine
sθ = norm(n3) # sine
axis = n3 ./ reg(sθ)
tanθhalf = sθ / reg(1 + cθ)
q = [1; tanθhalf * axis]
q /= norm(q)
return Quaternion(q...)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 713 | function quaternion_map(ω, timestep)
return Quaternion(sqrt(4 / timestep^2 - dot(ω, ω)), ω...)
end
function quaternion_map_jacobian(ω::SVector{3}, timestep)
msq = -sqrt(4 / timestep^2 - dot(ω, ω))
return [ω' / msq; I]
end
function cayley(ω)
Quaternion(1.0 / sqrt(1.0 + ω' * ω) * [1.0; ω])
end
function cayley_jacobian(ω)
ω₁, ω₂, ω₃ = ω
a = (sqrt(1.0 + ω₁^2 + ω₂^2 + ω₃^2)^-3)
b = sqrt(1.0 + ω₁^2 + ω₂^2 + ω₃^2)^-1
SMatrix{4,3}([
-ω₁*a -ω₂*a -ω₃*a;
(b - (ω₁^2)*a) (-ω₁ * ω₂ * a) (-ω₁ * ω₃ * a);
(-ω₁ * ω₂ * a) (b - (ω₂^2)*a) (-ω₂ * ω₃ * a);
(-ω₁ * ω₃ * a) (-ω₂ * ω₃ * a) (b - (ω₃^2)*a);
])
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1495 | function mrp(q::Quaternion)
q̄ = vector(q)
return q̄[SUnitRange(2,4)] ./ (q̄[1] + 1.0)
end
function mrp(q::AbstractVector)
return q[SUnitRange(2,4)] ./ (q[1] + 1.0)
end
function dmrpdq(q::AbstractVector)
s = q[1]
v = q[SA[2;3;4]]
d1 = 1 / (s + 1)^2
di = 1 / (s + 1)
[-v[1] * d1 di 0.0 0.0;
-v[2] * d1 0.0 di 0.0;
-v[3] * d1 0.0 0.0 di]
end
function axis(q)
m = mrp(q)
mag = norm(m)
if mag > 0
# θ = 4.0 * atan(mag)
n = m ./ mag
else
# θ = 0.0
n = SVector{3}(1.0, 0.0, 0.0)
end
return n
end
function daxisdq(q::AbstractVector)
m = mrp(q)
dmrpdq(q) ./ norm(m) - m ./ norm(m)^2 * transpose(m ./ norm(m)) * dmrpdq(q)
end
function angle(q)
m = mrp(q)
mag = norm(m)
if mag > 0
θ = 4.0 * atan(mag)
else
θ = 0.0
end
return θ
end
function dangledq(q::AbstractVector)
m = mrp(q)
4.0 * 1.0 / (1.0 + norm(m)^2.0) * transpose(m ./ norm(m)) * dmrpdq(q)
end
function axis_angle(q)
return axis(q), angle(q)
end
function rotation_vector(q)
n, θ = axis_angle(q)
return θ .* n
end
function drotation_vectordq(q::AbstractVector)
θ = angle(q)
if θ != 0.0
a = axis(q)
return a * dangledq(q) + θ * daxisdq(q)
else
[
0.0 2.0 0.0 0.0;
0.0 0.0 2.0 0.0;
0.0 0.0 0.0 2.0;
]
end
end
drotation_vectordq(q::Quaternion) = drotation_vectordq(vector(q))
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4459 | Quaternions.Quaternion(v::AbstractVector) = Quaternion(0,v[1],v[2],v[3])
MeshCat.LinearMap(q::Quaternion) = MeshCat.LinearMap(rotation_matrix(q))
MeshCat.js_quaternion(q::Quaternion) = [q.v1, q.v2, q.v3, q.s]
RotX(θ) = Quaternion(cos(θ/2), sin(θ/2), 0, 0)
RotY(θ) = Quaternion(cos(θ/2), 0, sin(θ/2), 0)
RotZ(θ) = Quaternion(cos(θ/2), 0, 0, sin(θ/2))
quateltype(x) = eltype(x) # TODO not super elegant
quateltype(::Quaternion{T}) where T = T
vector(q::Quaternion) = SA[q.s, q.v1, q.v2, q.v3]
vector(q::AbstractVector) = q
function Lmat(q::Quaternion)
SA[
q.s -q.v1 -q.v2 -q.v3;
q.v1 q.s -q.v3 q.v2;
q.v2 q.v3 q.s -q.v1;
q.v3 -q.v2 q.v1 q.s;
]
end
function Rmat(q::Quaternion)
SA[
q.s -q.v1 -q.v2 -q.v3;
q.v1 q.s q.v3 -q.v2;
q.v2 -q.v3 q.s q.v1;
q.v3 q.v2 -q.v1 q.s;
]
end
Lᵀmat(q) = Lmat(q)'
Rᵀmat(q) = Rmat(q)'
function Tmat(::Type{T}=Float64) where T
SA{T}[
1 0 0 0;
0 -1 0 0;
0 0 -1 0;
0 0 0 -1;
]
end
function Vmat(::Type{T}=Float64) where T
SA{T}[
0 1 0 0;
0 0 1 0;
0 0 0 1;
]
end
function Vᵀmat(::Type{T}=Float64) where T
SA{T}[
0 0 0;
1 0 0;
0 1 0;
0 0 1;
]
end
Vmat(q::Quaternion) = SA[q.v1, q.v2, q.v3]
function VLmat(q::Quaternion)
SA[
q.v1 q.s -q.v3 q.v2;
q.v2 q.v3 q.s -q.v1;
q.v3 -q.v2 q.v1 q.s;
]
end
function VLᵀmat(q::Quaternion)
SA[
-q.v1 q.s q.v3 -q.v2;
-q.v2 -q.v3 q.s q.v1;
-q.v3 q.v2 -q.v1 q.s;
]
end
function VRmat(q::Quaternion)
SA[
q.v1 q.s q.v3 -q.v2;
q.v2 -q.v3 q.s q.v1;
q.v3 q.v2 -q.v1 q.s;
]
end
function VRᵀmat(q::Quaternion)
SA[
-q.v1 q.s -q.v3 q.v2;
-q.v2 q.v3 q.s -q.v1;
-q.v3 -q.v2 q.v1 q.s;
]
end
function LVᵀmat(q::Quaternion)
SA[
-q.v1 -q.v2 -q.v3;
q.s -q.v3 q.v2;
q.v3 q.s -q.v1;
-q.v2 q.v1 q.s;
]
end
function LᵀVᵀmat(q::Quaternion)
SA[
q.v1 q.v2 q.v3;
q.s q.v3 -q.v2;
-q.v3 q.s q.v1;
q.v2 -q.v1 q.s;
]
end
function RVᵀmat(q::Quaternion)
SA[
-q.v1 -q.v2 -q.v3;
q.s q.v3 -q.v2;
-q.v3 q.s q.v1;
q.v2 -q.v1 q.s;
]
end
function RᵀVᵀmat(q::Quaternion)
SA[
q.v1 q.v2 q.v3;
q.s -q.v3 q.v2;
q.v3 q.s -q.v1;
-q.v2 q.v1 q.s;
]
end
################################################################################
# Matrix-Vector Product Jacobian
################################################################################
function ∂VLmat∂q(p::AbstractVector) # 𝞉(VLmat(q)*p)/∂q
SA[
0 p[1] p[2] p[3];
p[1] 0 p[3] -p[2];
p[2] -p[3] 0 p[1];
p[3] p[2] -p[1] 0;
]
end
function ∂LVᵀmat∂q(p::AbstractVector) # 𝞉(∂LVᵀmat∂q(q)*p)/∂q
SA[
0 -p[1] -p[2] -p[3];
p[1] 0 p[3] -p[2];
p[2] -p[3] 0 p[1];
p[3] p[2] -p[1] 0;
]
end
function ∂VLᵀmat∂q(p::AbstractVector) # 𝞉(VLᵀmat(q)*p)/∂q
SA[
p[2] -p[1] -p[4] p[3];
p[3] p[4] -p[1] -p[2];
p[4] -p[3] p[2] -p[1];
]
end
function ∂LᵀVᵀmat∂q(p::AbstractVector) # 𝞉(LᵀVᵀmat(q)*p)/∂q
SA[
0 p[1] p[2] p[3];
p[1] 0 -p[3] p[2];
p[2] p[3] 0 -p[1];
p[3] -p[2] p[1] 0;
]
end
function ∂VRmat∂q(p::AbstractVector) # 𝞉(VRmat(q)*p)/∂q
SA[
p[2] p[1] -p[4] p[3];
p[3] p[4] p[1] -p[2];
p[4] -p[3] p[2] p[1];
]
end
function ∂RᵀVᵀmat∂q(p::AbstractVector) # 𝞉(RᵀVᵀmat(q)*p)/∂q
SA[
p[2] p[1] p[4] -p[3];
p[3] -p[4] p[1] p[2];
p[4] p[3] -p[2] p[1];
]
end
function ∂VRᵀmat∂q(p::AbstractVector) # 𝞉(RᵀVᵀmat(q)*p)/∂q
SA[
p[2] -p[1] p[4] -p[3];
p[3] -p[4] -p[1] p[2];
p[4] p[3] -p[2] -p[1];
]
end
function ∂Rᵀmat∂q(p::AbstractVector) # 𝞉(Rᵀmat(q)*p)/∂q
SA[
p[1] p[2] p[3] p[4];
p[2] -p[1] p[4] -p[3];
p[3] -p[4] -p[1] p[2];
p[4] p[3] -p[2] -p[1];
]
end
function ∂Lmat∂q(p::AbstractVector) # 𝞉(Lmat(q)*p)/∂q
SA[
p[1] -p[2] -p[3] -p[4];
p[2] p[1] p[4] -p[3];
p[3] -p[4] p[1] p[2];
p[4] p[3] -p[2] p[1];
]
end
function skew(p)
SA[
0 -p[3] p[2];
p[3] 0 -p[1];
-p[2] p[1] 0;
]
end
function ∂skew∂p(λ) # 𝞉(skew(p)*λ)/∂p
skew(-λ)
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1356 | # rotate quaternion
quaternion_rotate(q1::Quaternion,q2::Quaternion) = q2 * q1 / q2
# rotate vector
vector_rotate(v::AbstractVector,q::Quaternion) = Vmat(quaternion_rotate(Quaternion(0,v...), q))
∂vector_rotate∂q(p::AbstractVector, q::Quaternion) = VLmat(q) * Lmat(Quaternion(p)) * Tmat() + VRᵀmat(q) * Rmat(Quaternion(p))
# rotate matrix
function matrix_rotate(A::AbstractMatrix,q::Quaternion)
c1 = vector_rotate(A[SA[1;2;3]], q)
c2 = vector_rotate(A[SA[4;5;6]], q)
c3 = vector_rotate(A[SA[7;8;9]], q)
return [c1 c2 c3]
end
# transform matrix in different frame "q*A*inv(q)"
function matrix_transform(A::AbstractMatrix,q::Quaternion)
matrix_rotate(matrix_rotate(A', q)', q)
end
# rotation matrix
rotation_matrix(q::Quaternion) = VRᵀmat(q) * LVᵀmat(q)
function ∂rotation_matrix∂q(q::Quaternion, p::AbstractVector{T}) where T #; attjac::Bool=false) where T
M = ∂VRᵀmat∂q(LVᵀmat(q) * p) + VRᵀmat(q) * ∂LVᵀmat∂q(p)
# if attjac
# return (M * LVᵀmat(q))::SMatrix{3,3,T,9}
# else
# return M::SMatrix{3,4,T,12}
# end
end
function ∂rotation_matrix_inv∂q(q::Quaternion, p::AbstractVector{T}) where T #; attjac::Bool=false) where T
M = ∂rotation_matrix∂q(inv(q), p) * Tmat()
# if attjac
# return (M * LVᵀmat(q))::SMatrix{3,3,T,9}
# else
# return M::SMatrix{3,4,T,12}
# end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2050 | """
simulate!(mechanism, steps, storage, control!;
record, verbose, abort_upon_failure, opts)
simulate a mechanism
mechanism: Mechanism
steps: range of steps to simulate
storage: Storage
control!: Function setting inputs for mechanism
record: flag for recording simulation to storage
verbose: flag for printing during simulation
abort_upon_failure: flag for terminating simulation is solver fails to meet tolerances
opts: SolverOptions
"""
function simulate!(mechanism::Mechanism, steps::AbstractUnitRange, storage::Storage,
control!::Function=(m, k) -> nothing;
record::Bool=true,
verbose::Bool=false,
abort_upon_failure::Bool=false,
opts=SolverOptions(verbose=verbose))
initialize_simulation!(mechanism)
for k = steps
control!(mechanism, k)
for joint in mechanism.joints input_impulse!(joint, mechanism) end
status = mehrotra!(mechanism, opts=opts)
for body in mechanism.bodies clear_external_force!(body) end
abort_upon_failure && (status == :failed) && break
record && save_to_storage!(mechanism, storage, k)
(k != steps[end]) && (for body in mechanism.bodies update_state!(body, mechanism.timestep) end)
end
record ? (return storage) : (return)
end
function simulate!(mechanism::Mechanism{T}, tend::Real, args...;
record::Bool=true,
verbose::Bool=false,
abort_upon_failure::Bool=false,
opts=SolverOptions(verbose=verbose)) where T
steps = Base.OneTo(Int64(ceil(tend / mechanism.timestep)))
record ? (storage = Storage{T}(steps, length(mechanism.bodies))) : (storage = Storage{T}())
storage = simulate!(mechanism, steps, storage, args...; verbose=verbose,
record=record, abort_upon_failure=abort_upon_failure, opts=opts)
return storage
end
function initialize_simulation!(mechanism::Mechanism)
initialize_state!(mechanism)
for body in mechanism.bodies
set_velocity_solution!(body)
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1526 | """
step!(mechanism::Mechanism{T}, z::Vector{T}, u::Vector{T}; opts)
simulate mechanism for one time step provided maximal coordinates
mechanism: Mechanism
z: maximal state
u: inputs
opts: SolverOptions
"""
function step!(mechanism::Mechanism{T}, z::Vector{T}, u::Vector{T};
opts=SolverOptions{T}()) where T
# set state
set_maximal_state!(mechanism, z)
# set control
set_input!(mechanism, u)
# solve the 1-step simulation problem
mehrotra!(mechanism, opts=opts)
for body in mechanism.bodies
update_state!(body, mechanism.timestep)
end
# extract the next state
z_next = get_next_state(mechanism)
return z_next
end
"""
step_minimal_coordinates!(mechanism::Mechanism{T}, x::Vector{T}, u::Vector{T}; opts)
simulate mechanism for one time step provided minimal coordinates
mechanism: Mechanism
x: minimal state
u: inputs
opts: SolverOptions
"""
function step_minimal_coordinates!(mechanism::Mechanism{T}, x::Vector{T}, u::Vector{T};
opts=SolverOptions{T}()) where T
# set state
set_maximal_state!(mechanism, minimal_to_maximal(mechanism, x))
# set control
set_input!(mechanism, u)
# solve the 1-step simulation problem
mehrotra!(mechanism, opts=opts)
for body in mechanism.bodies
update_state!(body, mechanism.timestep)
end
# extract the next state
x_next = maximal_to_minimal(mechanism, get_next_state(mechanism))
return x_next
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3458 | """
Storage{T,N}
contains maximal-representation trajectories
x: position
q: orientation (Quaternion)
v: linear velocity (midpoint)
ω: angular velocity (midpoint)
px: linear momentum
pq: angular momentum
vl: linear velocity
ωl: angular velocity
"""
struct Storage{T,N}
x::Vector{Vector{SVector{3,T}}}
q::Vector{Vector{Quaternion{T}}}
v::Vector{Vector{SVector{3,T}}}
ω::Vector{Vector{SVector{3,T}}}
px::Vector{Vector{SVector{3,T}}}
pq::Vector{Vector{SVector{3,T}}}
vl::Vector{Vector{SVector{3,T}}}
ωl::Vector{Vector{SVector{3,T}}}
function Storage{T}(steps, nbodies) where T
x = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
q = [[one(Quaternion{T}) for i = steps] for j = 1:nbodies]
v = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
ω = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
px = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
pq = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
vl = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
ωl = [[szeros(T, 3) for i = steps] for j = 1:nbodies]
new{T,length(steps)}(x, q, v, ω, px, pq, vl, ωl)
end
Storage(steps, nbodies) = Storage{Float64}(steps, nbodies)
Storage{T}(nsteps::Integer, nbodies) where T = Storage{T}(Base.OneTo(nsteps), nbodies)
Storage(nsteps::Integer, nbodies) = Storage{Float64}(nsteps, nbodies)
Storage{T}() where T = Storage{T}(Base.OneTo(0),0)
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, storage::Storage{T,N}) where {T,N}
println(io, "Storage for "*string(N)*" steps of "*string(length(storage.x))*" bodies.")
end
Base.length(storage::Storage{T,N}) where {T,N} = N
function save_to_storage!(mechanism::Mechanism, storage::Storage, i::Int)
for (ind, body) in enumerate(mechanism.bodies)
state = body.state
storage.x[ind][i] = state.x2 # x2
storage.q[ind][i] = state.q2 # q2
storage.v[ind][i] = state.v15 # v1.5
storage.ω[ind][i] = state.ω15 # ω1.5
q2 = state.q2
px2, pq2 = momentum(mechanism, body) # p in world frame
v2 = px2 / body.mass # in world frame
ω2 = body.inertia \ (vector_rotate(pq2, inv(q2))) # in body frame, we rotate using the current quaternion q2 = state.q2
storage.px[ind][i] = px2 # px2
storage.pq[ind][i] = pq2 # pq2
storage.vl[ind][i] = v2 # v2
storage.ωl[ind][i] = ω2 # ω2
end
return
end
function generate_storage(mechanism::Mechanism, z)
N = length(z)
M = length(mechanism.bodies)
storage = Storage{Float64}(N, M)
for t = 1:N
off = 0
for i = 1:M
storage.x[i][t] = z[t][SUnitRange(off+1,off+3)]
storage.v[i][t] = z[t][SUnitRange(off+4,off+6)]
storage.q[i][t] = Quaternion(z[t][SUnitRange(off+7,off+10)]...)
storage.ω[i][t] = z[t][SUnitRange(off+11,off+13)]
off += 13
end
end
return storage
end
function get_maximal_state(storage::Storage{T,N}) where {T,N}
z = [get_maximal_state(storage, i) for i=1:N]
return z
end
function get_maximal_state(storage::Storage{T,N}, i::Int) where {T,N}
Nb = length(storage.x)
z = zeros(13 * Nb)
for j = 1:Nb
x2 = storage.x[j][i]
q2 = storage.q[j][i]
v15 = storage.v[j][i]
ω15 = storage.ω[j][i]
z[SUnitRange((j-1)*13+1,j*13)] = [x2; v15; vector(q2); ω15]
end
return z
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1722 | function centering!(mechanism::Mechanism, αaff::T) where T
system = mechanism.system
parameters = [SA{T}[0;0;0]] # ν, νaff, n
for contact in mechanism.contacts
centering!(parameters, contact, get_entry(system, contact.id), αaff)
end
for joint in mechanism.joints
centering!(parameters, joint, get_entry(system, joint.id), αaff)
end
ν = parameters[1][1]/parameters[1][3]
νaff = parameters[1][2]/parameters[1][3]
return ν, νaff
end
function centering!(parameters, contact::ContactConstraint{T,N,Nc,Cs,N½}, vector_entry::Entry, αaff) where {T,N,Nc,Cs,N½}
s = contact.impulses_dual[2]
γ = contact.impulses[2]
Δs = vector_entry.value[SUnitRange(1,N½)]
Δγ = vector_entry.value[SUnitRange(N½+1,N)]
ν = dot(s, γ)
νaff = dot(s + αaff * Δs, γ + αaff * Δγ) # plus or minus
n = cone_degree(contact)
parameters[1] += SA{T}[ν;νaff;n]
return
end
function centering!(parameters, joint::JointConstraint{T,N,Nc}, vector_entry::Entry, αaff) where {T,N,Nc}
joint_t = joint.translational
s, γ = split_impulses(joint_t, joint.impulses[2][joint_impulse_index(joint,1)])
Δs, Δγ = split_impulses(joint_t, vector_entry.value[joint_impulse_index(joint,1)])
ν = dot(s, γ)
νaff = dot(s + αaff * Δs, γ + αaff * Δγ) # plus or minus
n = length(s)
parameters[1] += SA{T}[ν;νaff;n]
joint_r = joint.rotational
s, γ = split_impulses(joint_r, joint.impulses[2][joint_impulse_index(joint,2)])
Δs, Δγ = split_impulses(joint_r, vector_entry.value[joint_impulse_index(joint,2)])
ν = dot(s, γ)
νaff = dot(s + αaff * Δs, γ + αaff * Δγ) # plus or minus
n = length(s)
parameters[1] += SA{T}[ν;νaff;n]
return
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 873 | # joints
function complementarity(mechanism, joint::JointConstraint{T,N,Nc}) where {T,N,Nc}
λ = joint.impulses[2][joint_impulse_index(joint, 1)]
s, γ = split_impulses(joint.translational, λ)
ct = s .* γ
λ = joint.impulses[2][joint_impulse_index(joint, 2)]
s, γ = split_impulses(joint.rotational, λ)
cr = s .* γ
return [ct; cr]
end
# contacts
complementarity(mechanism, contact::ContactConstraint) = contact.impulses[2] .* contact.impulses_dual[2]
function complementarity(mechanism, contact::ContactConstraint{T,N,Nc,Cs}) where {T,N,Nc,Cs<:NonlinearContact{T,N}}
γ = contact.impulses[2]
s = contact.impulses_dual[2]
return vcat(γ[1] * s[1], cone_product(γ[SA[2,3,4]], s[SA[2,3,4]]))
end
complementarityμ(mechanism, contact::ContactConstraint) = complementarity(mechanism, contact) - mechanism.μ * neutral_vector(contact.model)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1909 | function correction!(mechanism)
system = mechanism.system
residual_entries = mechanism.residual_entries
for id in reverse(system.dfs_list)
node = get_node(mechanism, id)
correction!(mechanism, residual_entries[id], get_entry(system, id), node)
end
return
end
correction!(mechanism::Mechanism, residual_entry::Entry, step_entry::Entry, node::Node) = nothing
function correction!(mechanism::Mechanism, residual_entry::Entry, step_entry::Entry, ::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs,N½}
Δs = step_entry.value[SUnitRange(1,N½)]
Δγ = step_entry.value[SUnitRange(N½+1,N)]
μ = mechanism.μ
residual_entry.value += [- Δs .* Δγ .+ μ; szeros(N½)]
return
end
function correction!(mechanism::Mechanism, residual_entry::Entry, step_entry::Entry, contact::ContactConstraint{T,N,Nc,Cs,N½}) where {T,N,Nc,Cs<:NonlinearContact{T,N},N½}
cont = contact.model
μ = mechanism.μ
Δs = step_entry.value[SUnitRange(1,N½)]
Δγ = step_entry.value[SUnitRange(N½+1,N)]
residual_entry.value += [[-Δs[1] * Δγ[1]; -cone_product(Δs[SA[2;3;4]], Δγ[SA[2;3;4]])] + μ * neutral_vector(cont); szeros(N½)]
return
end
function correction!(mechanism::Mechanism{T}, residual_entry::Entry, step_entry::Entry, joint::JointConstraint{T,N,Nc}) where {T,N,Nc}
cor = correction(mechanism, step_entry, joint)
residual_entry.value += cor
return
end
@generated function correction(mechanism::Mechanism{T}, step_entry::Entry, joint::JointConstraint{T,N,Nc}) where {T,N,Nc}
cor_tra = :(correction(joint.translational, step_entry.value[joint_impulse_index(joint, 1)], mechanism.μ))
cor_rot = :(correction(joint.rotational, step_entry.value[joint_impulse_index(joint, 2)], mechanism.μ))
return :(vcat($cor_tra, $cor_rot))
end
function correction(joint::Joint{T,Nλ,Nb,N}, Δ, μ) where {T,Nλ,Nb,N}
Δs, Δγ = split_impulses(joint, Δ)
return [- Δs .* Δγ .+ μ; szeros(Nb + Nλ)]
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1907 | function initialize!(contact::ContactConstraint{T,N,Nc,Cs}) where {T,N,Nc,Cs}
initialize_positive_orthant!(contact.impulses[1], contact.impulses_dual[1])
initialize_positive_orthant!(contact.impulses[2], contact.impulses_dual[2])
return nothing
end
function initialize!(contact::ContactConstraint{T,N,Nc,Cs}) where {T,N,Nc,Cs<:NonlinearContact{T,N}}
γort, sort = initialize_positive_orthant!(contact.impulses[1][SA[1]], contact.impulses_dual[1][SA[1]])
γsoc, ssoc = initialize_second_order_cone!(contact.impulses[1][SA[2;3;4]], contact.impulses_dual[1][SA[2;3;4]])
contact.impulses[1] = [γort; γsoc]
contact.impulses_dual[1] = [sort; ssoc]
γort, sort = initialize_positive_orthant!(contact.impulses[2][SA[1]], contact.impulses_dual[2][SA[1]])
γsoc, ssoc = initialize_second_order_cone!(contact.impulses[2][SA[2;3;4]], contact.impulses_dual[2][SA[2;3;4]])
contact.impulses[2] = [γort; γsoc]
contact.impulses_dual[2] = [sort; ssoc]
return nothing
end
function initialize_positive_orthant!(γ::AbstractVector{T}, s::AbstractVector{T};
ϵ::T = 1e-20) where T
δs = max(-1.5 * minimum(s), 0)
δγ = max(-1.5 * minimum(γ), 0)
sh = s .+ δs
γh = γ .+ δγ
δhs = 0.5 * transpose(sh) * γh / (sum(γh) + ϵ)
δhγ = 0.5 * transpose(sh) * γh / (sum(sh) + ϵ)
s0 = sh .+ δhs
γ0 = γh .+ δhγ
return γ0, s0
end
function initialize_second_order_cone!(γ::AbstractVector{T}, s::AbstractVector{T};
ϵ::T = 1e-20) where T
e = [1.0; szeros(length(γ) - 1)] # identity element
δs = max(-1.5 * (s[1] - norm(s[SUnitRange(2,end)])), 0)
δγ = max(-1.5 * (γ[1] - norm(γ[SUnitRange(2,end)])), 0)
sh = s + δs * e
γh = γ + δγ * e
δhs = 0.5 * transpose(sh) * γh / ((γh[1] + norm(γh[SUnitRange(2,end)])) + ϵ)
δhγ = 0.5 * transpose(sh) * γh / ((sh[1] + norm(sh[SUnitRange(2,end)])) + ϵ)
s0 = sh + δhs * e
γ0 = γh + δhγ * e
return γ0, s0
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 5782 | function line_search!(mechanism::Mechanism, α, rvio, bvio, opts)
scale = 0
system = mechanism.system
rvio_cand = Inf
bvio_cand = Inf
for n = Base.OneTo(opts.max_ls)
for contact in mechanism.contacts
candidate_step!(α, contact, get_entry(system, contact.id), scale)
end
for joint in mechanism.joints
candidate_step!(α, joint, get_entry(system, joint.id), scale)
end
for body in mechanism.bodies
ωmax = 3.9 / mechanism.timestep^2
candidate_step!(α, mechanism, body, get_entry(system, body.id), scale,
ωmax=ωmax, verbose=opts.verbose)
if dot(body.state.ωsol[2], body.state.ωsol[2]) > 3.91 / mechanism.timestep^2
error("Excessive angular velocity. Body-ID: $(string(body.name)) " * string(body.id) * ", ω: " * string(body.state.ωsol[2]) * ".")
end
end
rvio_cand = residual_violation(mechanism)
bvio_cand = bilinear_violation(mechanism)
if (rvio_cand > rvio) && (bvio_cand > bvio)
scale += 1
else
return rvio_cand, bvio_cand
end
end
return rvio_cand, bvio_cand
end
function cone_line_search!(mechanism::Mechanism;
τort::T=0.95,
τsoc::T=0.95) where T
system = mechanism.system
α = 1.0
for contact in mechanism.contacts
α = cone_line_search!(α, mechanism, contact, get_entry(system, contact.id), τort, τsoc)
end
for joint in mechanism.joints
α = cone_line_search!(α, mechanism, joint, get_entry(system, joint.id), τort, τsoc)
end
return α
end
function cone_line_search!(α, mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½},
vector_entry::Entry, τort, τsoc) where {T,N,Nc,Cs<:NonlinearContact{T,N},N½}
s = contact.impulses_dual[2]
γ = contact.impulses[2]
Δs = vector_entry.value[SUnitRange(1,N½)]
Δγ = vector_entry.value[SUnitRange(N½+1,2*N½)]
αs_ort = positive_orthant_step_length(s[SA[1]], Δs[SA[1]], τ = τort)
αγ_ort = positive_orthant_step_length(γ[SA[1]], Δγ[SA[1]], τ = τort)
αs_soc = second_order_cone_step_length(s[SA[2;3;4]], Δs[SA[2;3;4]]; τ = τsoc)
αγ_soc = second_order_cone_step_length(γ[SA[2;3;4]], Δγ[SA[2;3;4]]; τ = τsoc)
return min(α, αs_soc, αγ_soc, αs_ort, αγ_ort)
end
function cone_line_search!(α, mechanism, contact::ContactConstraint{T,N,Nc,Cs,N½},
vector_entry::Entry, τort, τsoc) where {T,N,Nc,Cs<:Union{ImpactContact{T,N},LinearContact{T,N}},N½}
s = contact.impulses_dual[2]
γ = contact.impulses[2]
Δs = vector_entry.value[SUnitRange(1,N½)]
Δγ = vector_entry.value[SUnitRange(N½+1,2*N½)]
αs_ort = positive_orthant_step_length(s, Δs, τ = τort)
αγ_ort = positive_orthant_step_length(γ, Δγ, τ = τort)
return min(α, αs_ort, αγ_ort)
end
function cone_line_search!(α, mechanism, joint::JointConstraint{T,N,Nc},
vector_entry::Entry, τort, τsoc) where {T,N,Nc}
s, γ = split_impulses(joint.translational, joint.impulses[2][joint_impulse_index(joint,1)])
Δs, Δγ = split_impulses(joint.translational, vector_entry.value[joint_impulse_index(joint,1)])
αs_ort = positive_orthant_step_length(s, Δs, τ = τort)
αγ_ort = positive_orthant_step_length(γ, Δγ, τ = τort)
α = min(α, αs_ort, αγ_ort)
s, γ = split_impulses(joint.rotational, joint.impulses[2][joint_impulse_index(joint,2)])
Δs, Δγ = split_impulses(joint.rotational, vector_entry.value[joint_impulse_index(joint,2)])
αs_ort = positive_orthant_step_length(s, Δs, τ = τort)
αγ_ort = positive_orthant_step_length(γ, Δγ, τ = τort)
α = min(α, αs_ort, αγ_ort)
return α
end
function positive_orthant_step_length(λ::AbstractVector{T}, Δ::AbstractVector{T};
τ::T = 0.99) where T
α = 1.0
for i in eachindex(λ)
if Δ[i] < 0 # safer
α = min(α, - τ * λ[i] / Δ[i])
end
end
return α
end
function second_order_cone_step_length(λ::AbstractVector{T}, Δ::AbstractVector{T};
τ::T=0.99,
ϵ::T=1e-14) where T
# check Section 8.2 CVXOPT
λ0 = λ[1]
λ_2_end = λ[SUnitRange(2,end)]
λ_λ = max(λ0^2 - λ_2_end' * λ_2_end, 1e-25)
if λ_λ < 0.0
# @show λ_λ
@warn "should always be positive"
end
λ_λ += ϵ
λ_Δ = λ0 * Δ[1] - λ_2_end' * Δ[SUnitRange(2,end)] + ϵ
ρs = λ_Δ / λ_λ
ρv = Δ[SUnitRange(2,end)] / sqrt(λ_λ)
ρv -= (λ_Δ / sqrt(λ_λ) + Δ[1]) / (λ0 / sqrt(λ_λ) + 1) * λ_2_end / λ_λ
α = 1.0
if norm(ρv) - ρs > 0.0
α = min(α, τ / (norm(ρv) - ρs))
end
return α
end
function candidate_step!(α, mechanism::Mechanism, body::Body, vector_entry::Entry, scale;
ωmax = Inf, verbose=true)
body.state.vsol[2] = body.state.vsol[1] + 1 / (2^scale) * α * vector_entry.value[SA[1; 2; 3]]
body.state.ωsol[2] = body.state.ωsol[1] + 1 / (2^scale) * α * vector_entry.value[SA[4; 5; 6]]
ω = body.state.ωsol[2]
ωdot = dot(ω, ω)
if ωdot > ωmax
verbose && println("clipping ", scale, scn((ωdot - ωmax) / ωmax), " ", scn(ωdot), " ", scn(ωmax), " ", body.name)
body.state.ωsol[2] *= ωmax / ωdot # this is overkill, but works better than sqrt(ωmax/ωdot)
end
return
end
function candidate_step!(α, joint::JointConstraint, vector_entry::Entry, scale)
joint.impulses[2] = joint.impulses[1] + 1.0 / (2^scale) * α * vector_entry.value
return
end
function candidate_step!(α::T, contact::ContactConstraint{T,N,Nc,Cs,N½}, vector_entry::Entry, scale) where {T,N,Nc,Cs,N½}
contact.impulses_dual[2] = contact.impulses_dual[1] + 1 / (2^scale) * α * vector_entry.value[SVector{N½,Int64}(1:N½)]
contact.impulses[2] = contact.impulses[1] + 1 / (2^scale) * α * vector_entry.value[SVector{N½,Int64}(N½+1:N)]
return
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 2015 | function set_entries!(mechanism::Mechanism)
system = mechanism.system
for id in reverse(system.dfs_list)
for child_id in system.cyclic_children[id]
zero_LU!(get_entry(system, id, child_id), get_entry(system, child_id, id))
end
node = get_node(mechanism, id)
set_matrix_vector_entries!(mechanism, get_entry(system, id, id), get_entry(system, id), node)
for child_id in children(system,id)
set_LU!(mechanism, get_entry(system, id, child_id), get_entry(system, child_id, id), node, get_node(mechanism, child_id))
end
end
return
end
function set_LU!(mechanism::Mechanism, matrix_entry_L::Entry, matrix_entry_U::Entry, nodea::Node, nodeb::Node)
L, U = off_diagonal_jacobians(mechanism, nodea, nodeb)
matrix_entry_L.value = L
matrix_entry_U.value = U
return
end
function zero_LU!(matrix_entry_L::Entry, matrix_entry_U::Entry)
matrix_entry_L.value *= 0
matrix_entry_U.value *= 0
return
end
function pull_residual!(mechanism::Mechanism)
for i in eachindex(mechanism.residual_entries)
pull_residual!(mechanism.residual_entries[i], mechanism.system.vector_entries[i])
end
return
end
function pull_residual!(residual_entry, vector_entry)
residual_entry.value = vector_entry.value
end
function push_residual!(mechanism::Mechanism)
for i in eachindex(mechanism.residual_entries)
push_residual!(mechanism.system.vector_entries[i], mechanism.residual_entries[i])
end
return
end
function push_residual!(vector_entry, residual_entry)
vector_entry.value = residual_entry.value
end
function update!(body::Body)
body.state.vsol[1] = body.state.vsol[2]
body.state.ωsol[1] = body.state.ωsol[2]
return
end
function update!(joint::JointConstraint)
joint.impulses[1] = joint.impulses[2]
return
end
function update!(contact::ContactConstraint)
contact.impulses_dual[1] = contact.impulses_dual[2]
contact.impulses[1] = contact.impulses[2]
return
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3682 | """
mehrotra!(mechanism; opts)
interior-point solver for simulation-step feasibility problem
mechanism: Mechanism
opts: SolverOptions
"""
function mehrotra!(mechanism::Mechanism{T}; opts=SolverOptions{T}()) where T
reset!.(mechanism.contacts, scale=1.0) # resets the values of s and γ to the scaled neutral vector; TODO: solver option
reset!.(mechanism.joints, scale=1.0) # resets the values of s and γ to the scaled neutral vector; TODO: solver option
status = :failed
mechanism.μ = 0.0
μtarget = 0.0
no_progress = 0
undercut = opts.undercut
α = 1.0
initialize!.(mechanism.contacts)
set_entries!(mechanism) # compute the residual
bvio = bilinear_violation(mechanism) # does not require to apply set_entries!
rvio = residual_violation(mechanism) # does not require to apply set_entries!
opts.verbose && solver_header()
for n = Base.OneTo(opts.max_iter)
opts.verbose && solver_status(mechanism, α, rvio, bvio, n, μtarget, undercut)
(rvio < opts.rtol) && (bvio < opts.btol) && (status=:success; break)
(n == opts.max_iter) && (opts.verbose && (@warn "failed mehrotra"))
# affine search direction
μ = 0.0
pull_residual!(mechanism) # store the residual inside mechanism.residual_entries
ldu_factorization!(mechanism.system) # factorize system, modifies the matrix in place
ldu_backsubstitution!(mechanism.system) # solve system, modifies the vector in place
αaff = cone_line_search!(mechanism; τort=0.95, τsoc=0.95) # uses system.vector_entries which holds the search drection
ν, νaff = centering!(mechanism, αaff)
σcentering = clamp(νaff / (ν + 1e-20), 0.0, 1.0)^3
# corrected search direction
μtarget = max(σcentering * ν, opts.btol / undercut)
mechanism.μ = μtarget
correction!(mechanism) # update the residual in mechanism.residual_entries
push_residual!(mechanism) # cache residual + correction
ldu_backsubstitution!(mechanism.system) # solve system
τ = max(0.95, 1 - max(rvio, bvio)^2) # τ = 0.95
α = cone_line_search!(mechanism; τort=τ, τsoc=min(τ, 0.95)) # uses system.vector_entries which holds the corrected search drection
# steps taken without making progress
rvio_, bvio_ = line_search!(mechanism, α, rvio, bvio, opts)
# evaluate progress
made_progress = (!(rvio_ < opts.rtol) && (rvio_ < 0.8rvio)) || (!(bvio_ < opts.btol) && (bvio_ < 0.8bvio)) # we only care when progress is made while the tolerance is not met
made_progress ? no_progress = max(no_progress - 1, 0) : no_progress += 1
rvio, bvio = rvio_, bvio_
(no_progress >= opts.no_progress_max) && (undercut *= opts.no_progress_undercut)
# update solution
update!.(mechanism.bodies)
update!.(mechanism.joints)
update!.(mechanism.contacts)
# recompute Jacobian and residual
set_entries!(mechanism)
end
return status
end
function solver_status(mechanism::Mechanism, α, rvio, bvio, n, μtarget, undercut)
fv = full_vector(mechanism.system)
Δvar = norm(fv, Inf)
fM = full_matrix(mechanism.system)
fΔ = fM \ fv
Δalt = norm(fΔ, Inf)
res = norm(fv, Inf)
println(
n,
" ", scn(bvio, digits=0),
" ", scn(rvio, digits=0),
" ", scn(α, digits=0),
" ", scn(μtarget, digits=0),
" ", scn(res, digits=0),
" ", scn(Δvar, digits=0),
# " ucut", scn(undercut),
)
end
function solver_header()
println(" ")
println("n bvio rvio α μ |res|∞ |Δ|∞")
println("–––––––––––––––––––––––––––––––––––––––––––––––––")
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1986 | """
SolverOptions{T}
Options and tolerances of primal-dual interior point solver.
rtol: tolerance on residual violations (equality constraints); defaults to 1e-6
btol: tolerance on bilinear violations (complementarity constraints); defaults to 1e-4
ls_scale: line search scaling factor (α_new ← ls_scale * α_current); defaults to 0.5
max_iter: maximum number of Newton iterations; defaults to 50
max_ls: maximum number of line search steps; defaults to 10
undercut: complementarity slackness target; solver will aim at reaching complementarity violation = btol / undercut; defaults to Inf
no_progress_max: number of Newton's iterations without progress trigerring the rescaling of the target complementarity violation; defaults to 3
no_progress_undercut: undercut scaling factor (target_new ← target_current / no_progress_undercut); defaults to 10
verbose: flag for printing the status of the solver during the solve; defaults to false
"""
Base.@kwdef mutable struct SolverOptions{T}
rtol::T=1.0e-6
btol::T=1.0e-4
ls_scale::T=0.5
max_iter::Int=50
max_ls=10
undercut::T=Inf
no_progress_max::Int=3
no_progress_undercut::T=10.0
verbose::Bool=false
end
function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, options::SolverOptions)
summary(io, options)
println(io, "")
println(io, " rtol: "*string(options.rtol))
println(io, " btol: "*string(options.btol))
println(io, " ls_scale: "*string(options.ls_scale))
println(io, " max_iter: "*string(options.max_iter))
println(io, " max_ls: "*string(options.max_ls))
println(io, " undercut: "*string(options.undercut))
println(io, " no_progress_max: "*string(options.no_progress_max))
println(io, " no_progress_undercut: "*string(options.no_progress_undercut))
println(io, " verbose: "*string(options.verbose))
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1833 | function residual_violation(mechanism::Mechanism)
violation = 0.0
for joint in mechanism.joints
violation = max(violation, joint_residual_violation(mechanism, joint))
end
for body in mechanism.bodies
res = constraint(mechanism, body)
violation = max(violation, norm(res, Inf))
end
for contact in mechanism.contacts
violation = max(violation, contact_residual_violation(mechanism, contact))
end
return violation
end
function joint_residual_violation(mechanism, joint)
res = constraint(mechanism, joint)
joint_t = joint.translational
Nλ = joint_length(joint_t)
Nb = limits_length(joint_t)
subres = res[SUnitRange(2*Nb+1,2*Nb+Nλ)]
violation = norm(subres, Inf)
shift = impulses_length(joint_t)
joint_r = joint.rotational
Nλ = joint_length(joint_r)
Nb = limits_length(joint_r)
subres = res[SUnitRange(shift+2Nb+1,shift+2Nb+Nλ)]
violation = max(violation, norm(subres, Inf))
return violation
end
function contact_residual_violation(mechanism, contact)
res = constraint(mechanism, contact)
violation = norm(res, Inf)
return violation
end
function bilinear_violation(mechanism::Mechanism)
violation = 0.0
for joint in mechanism.joints
violation = max(violation, joint_bilinear_violation(mechanism, joint))
end
for contact in mechanism.contacts
violation = max(violation, contact_bilinear_violation(mechanism, contact))
end
return violation
end
function joint_bilinear_violation(mechanism, joint)
comp = complementarity(mechanism, joint)
violation = norm(comp, Inf)
return violation
end
function contact_bilinear_violation(mechanism, contact)
comp = complementarity(mechanism, contact)
violation = norm(comp, Inf)
return violation
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1416 | Base.:*(u::AbstractVector, v::SVector{1,T}) where T = u * v[1]
Base.vcat(v::Adjoint{T,SVector{N,T}}, E::UniformScaling) where {T, N} = vcat(v, SMatrix{N,N,T,N*N}(E))
Base.vcat(A::SMatrix{N1,N2,T,N1N2}, E::UniformScaling) where {T, N1, N2, N1N2} = vcat(A, SMatrix{N2,N2,T,N2*N2}(E))
svcat(a::T, b::T) where T = SA[a; b]
svcat(a::StaticArray, b::StaticArray) = vcat(a, b)
svcat(a::StaticArray{Tuple{N},T,1}, b::T) where {T,N} = vcat(a, SA[b])
svcat(a::T, b::StaticArray{Tuple{N},T,1}) where {T,N} = vcat(SA[a], b)
szeros(::Type{T}, N) where T = @SVector zeros(T, N)
szeros(N)= @SVector zeros(N)
szeros(::Type{T}, N1, N2) where T = @SMatrix zeros(T, N1, N2)
szeros(N1, N2)= @SMatrix zeros(N1, N2)
sones(::Type{T}, N) where T = @SVector ones(T, N)
sones(N)= @SVector ones(N)
srand(N)= @SVector rand(N)
sI(::Type{T}, N) where T = SMatrix{N,N,T}(I)
sI(N) = SMatrix{N,N,Float64}(I)
# TODO: check StaticArray bug fix, then remove
zerodimstaticadjoint(A) = A'
zerodimstaticadjoint(::SMatrix{0,N,T,0}) where {T,N} = SMatrix{N,0,T,0}()
function diagonal_cat(a::AbstractMatrix{T}, b::AbstractMatrix{T}) where T
diagonal_cat(dense(a), dense(b))
end
function diagonal_cat(a::SMatrix{Na,Na,T,Ma}, b::SMatrix{Nb,Nb,T,Mb}) where {T,Na,Nb,Ma,Mb}
[[a szeros(Na,Nb)]; [szeros(Nb,Na) b]]
end
dense(a::AbstractMatrix{T}) where T = a
function dense(a::Diagonal{T,SVector{N, T}}) where {T,N}
SMatrix{N,N,T,N^2}(a)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 997 | function module_dir()
return joinpath(@__DIR__, "..", "..")
end
function string_to_symbol(x)
typeof(x) <: String ? (return Symbol(x)) : (return x)
end
function scn(a::Float64; digits=1, exp_digits=1)
isnan(a) && return " NaN" * " "^(digits + exp_digits)
@assert digits >= 0
# a = m x 10^e
if a == 0
e = 0
m = 0.0
elseif a == Inf
return " Inf"
elseif a == -Inf
return "-Inf"
else
e = Int(floor(log(abs(a))/log(10)))
m = a*exp(-e*log(10))
end
m = round(m, digits=digits)
if m == 10.0
m = 1.0
e += 1
end
if digits == 0
m = Int(floor(m))
strm = string(m)
else
strm = string(m)
is_neg = m < 0.
strm = strm*"0"^max(0, 2+digits+is_neg-length(strm))
end
sgn = a >= 0 ? " " : ""
sgne = e >= 0 ? "+" : "-"
stre = string(abs(e))
stre = "0"^max(0, exp_digits - length(stre)) * stre
return "$sgn$(strm)e$sgne$(stre)"
end
# useful for python visualizer
wait_for_server = MeshCat.wait_for_server
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 534 | function normalize(x)
mag = norm(x)
if mag > 0.0
return x ./ mag
else
return ones(length(x)) ./ length(x)
end
end
function ∂normalize∂x(x)
mag = norm(x)
n = length(x)
if mag > 0.0
n = length(x)
return 1.0 * I(n) ./ mag - x * transpose(x) ./ mag^3
else
return 1.0 * I(n) # TODO: confirm this is good choice
end
end
function ∂norm∂x(x)
mag = norm(x)
if mag > 0.0
return x' ./ mag
else
return ones(1, length(x))
end
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 438 | # default colors
orange = RGBA(1.0, 153.0 / 255.0, 51.0 / 255.0, 1.0)
cyan = RGBA(51.0 / 255.0, 1.0, 1.0, 1.0)
magenta = RGBA(255.0 / 255.0, 0.0, 255.0 / 255.0, 1.0)
gray = RGBA(0.7, 0.7, 0.7, 1.0)
# light colors
orange_light = RGBA(1.0, 153.0 / 255.0 + 0.2, 51.0 / 255.0 + 0.2, 1.0)
cyan_light = RGBA(51.0 / 255.0 + 0.6, 1.0, 1.0, 1.0)
magenta_light = RGBA(255.0 / 255.0, 0.75, 255.0 / 255.0, 1.0)
gray_light = RGBA(0.9, 0.9, 0.9, 1.0)
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1888 | function convert_video_to_gif(video_file_path::String, output_path::String="output.gif";
framerate::Int=30, start_time=0., duration=1e3, overwrite=false, width::Int=1080, height::Int=-2, hq_colors::Bool=false)
output_path = abspath(output_path)
if !isfile(video_file_path)
error("Could not find the input file $video_file_path")
end
if isfile(output_path) && !overwrite
error("The output path $output_path already exists. To overwrite that file, you can pass `overwrite=true` to this function")
end
mktempdir() do tmpdir
# run(MeshCat.unpack_cmd(video_file_path, tmpdir, ".mp4", nothing)) # unpack the .tar file
# cmd = ["-r", string(framerate), "-i", "%07d.png", "-vcodec", "libx264", "-preset", "slow", "-crf", "18"]
color_map = hq_colors ?
"[0:v] fps=$framerate, scale=$width:$height,split [a][b];[a] palettegen=stats_mode=single [p];[b][p] paletteuse=new=1" :
"[0:v] fps=$framerate, scale=$width:$height,split [a][b];[a] palettegen [p];[b][p] paletteuse"
cmd = ["-ss", string(start_time), "-t", string(duration), "-i", video_file_path, "-filter_complex", color_map]
if overwrite
push!(cmd, "-y")
end
push!(cmd, output_path)
cd(tmpdir) do
FFMPEG.exe(cmd...)
end
end
@info("Saved output as $output_path")
return output_path
end
function convert_frames_to_video_and_gif(filename, overwrite::Bool=true; load_path=homedir()*"/Downloads", save_path=homedir() * "/Documents/video")
MeshCat.convert_frames_to_video(
joinpath(load_path, "$filename.tar"),
joinpath(save_path, "$filename.mp4"),
overwrite=overwrite)
convert_video_to_gif(
joinpath(save_path, "$filename.mp4"),
joinpath(save_path, "$filename.gif"),
overwrite=overwrite)
return nothing
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4920 |
function newton_solver(res, x0; iterations=500, tolerance=1e-6)
x = x0
for i = 1:iterations
r = res(x)
(norm(r, Inf) < tolerance) && break
∇r = FiniteDiff.finite_difference_derivative(x -> res(x), x)
Δx = - r / ∇r
α = 1.0
r_cand = Inf
while norm(r_cand, Inf) >= norm(r, Inf)
r_cand = res(x + α * Δx)
α /= 2
end
x += α * Δx
(i == iterations) && (@show "solver failure")
end
return x
end
function catenary_parameters(x_start, x_goal, rope_length; iterations=500, tolerance=1e-6,
a_guess=0.0, dx_guess=0.0)
rope_length = max(rope_length, (1+1e-5)*norm(x_goal - x_start))
h = x_goal[1] - x_start[1]
v = x_goal[2] - x_start[2]
# find a i.e. the shape of the catenary
res(b) = 1/sqrt(sqrt(rope_length^2 - v^2)/h - 1) - 1/sqrt(2b * sinh(1/(2b)) - 1)
b = newton_solver(res, a_guess/h, iterations=iterations, tolerance=tolerance)
a = b * h
# find x offset
function caten(x; a=a)
return a * cosh(x/a)
end
res = dx -> caten(x_goal[1] + dx) - caten(x_start[1] + dx) - (x_goal[2] - x_start[2])
dx = newton_solver(res, dx_guess, iterations=iterations, tolerance=tolerance)
# find y offset
dy = x_goal[2] - caten(x_goal[1] + dx)
# final function
return a, dx, dy
end
function catenary(x; a=0.0, dx=0.0, dy=0.0)
return a * cosh((x+dx)/a) + dy
end
function link_transform(start, goal)
# transforms a vertical line of length 1 into a line between start and goal
v1 = [0.0, 0.0, 1.0]
v2 = goal[SA[1;2;3]] - start[SA[1;2;3]]
normalize!(v2)
ax = cross(v1, v2)
ang = acos(v1' * v2)
q = axis_angle_to_quaternion(ang * normalize!(ax))
rope_length = norm(goal - start)
scaling = LinearMap(I * Diagonal([1.0, 1.0, rope_length]))
transform = compose(Translation(start), LinearMap(q))
return transform, scaling
end
function build_rope(vis::Visualizer; N::Int=10, color=Colors.RGBA(0,0,0,1),
rope_type::Symbol=:cylinder, rope_radius=0.02, name=:rope)
if rope_type == :line
line = MeshCat.Line([xa, xb])
material = LineBasicMaterial(color=color, wireframeLinewidth=10, linewidth=10)
elseif rope_type == :cylinder
line = MeshCat.Cylinder(Point(0,0,0.0), Point(0,0,1.0), rope_radius)
material = MeshPhongMaterial(color=color)
end
for i = 1:N
setobject!(vis[name][Symbol(i)][:scaled], line, material)
end
return vis
end
function set_straight_rope(vis::Visualizer, x_start, x_goal; N::Int=10, name::Symbol=:rope)
Λ = range(0,1,length=N+1)
x = [(1-λ)*x_start + λ * x_goal for λ in Λ]
for i = 1:N
transform, scaling = link_transform(x[i], x[i+1])
settransform!(vis[name][Symbol(i)][:scaled], scaling)
settransform!(vis[name][Symbol(i)], transform)
end
return nothing
end
function set_loose_rope(vis::Visualizer, x_start, x_goal; N::Int=10,
rope_length=2norm(x_goal - x_start), min_altitude=-Inf, a_guess=1.0, dx_guess=0.0, name::Symbol=:rope)
v = x_goal - x_start
shadow_rope_length = norm(v[SA[1;2]])
θ = atan(v[2], v[1])
R = rotationmatrix(RotZ(-θ))
v̄ = R * v # rotated into the xz plane
a, dx, dy = catenary_parameters(zeros(2), v̄[SA[1;3]], rope_length, a_guess=a_guess, dx_guess=dx_guess)
Λ = shadow_rope_length * range(0,1,length=N+1)
x = []
for i = 1:N+1
xi = x_start + R' * [Λ[i], 0, catenary(Λ[i], a=a, dx=dx, dy=dy)]
xi[3] = max(xi[3], min_altitude)
push!(x, xi)
end
for i = 1:N
transform, scaling = link_transform(x[i], x[i+1])
settransform!(vis[name][Symbol(i)][:scaled], scaling)
settransform!(vis[name][Symbol(i)], transform)
end
return a, dx
end
function animate_straight_rope(vis::Visualizer, start_traj::Vector, goal_traj::Vector;
anim::Animation=MeshCat.Animation(100), N::Int=50, name=:rope)
M = length(start_traj)
for i = 1:M
atframe(anim, i) do
xa = start_traj[i]
xb = goal_traj[i]
set_straight_rope(vis, xa, xb, N=N, name=name)
end
end
setanimation!(vis, anim)
return vis, anim
end
function animate_loose_rope(vis::Visualizer, start_traj::Vector, goal_traj::Vector;
anim::Animation=MeshCat.Animation(100), rope_length=30.0, N::Int=50, min_altitude=-Inf, name=:rope)
M = length(start_traj)
a_guess = 1.0
dx_guess = 0.0
for i = 1:M
atframe(anim, i) do
xa = start_traj[i]
xb = goal_traj[i]
a_guess, dx_guess = set_loose_rope(vis, xa, xb, rope_length=rope_length,
N=N, min_altitude=min_altitude, a_guess=a_guess, dx_guess=dx_guess, name=name)
# set_straight_rope(vis, xa, xb, N=N, name=name)
end
end
setanimation!(vis, anim)
return vis, anim
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4543 | """
set_floor!(vis; x, y, z, origin, normal, color, tilepermeter, imagename, axis, grid)
adds floor to visualization
vis::Visualizer
x: lateral position
y: longitudinal position
z: vertical position
origin:: position of the center of the floor
normal:: unit vector indicating the normal to the floor
color: RGBA
tilepermeter: scaling
imagename: path to image
axis: flag to turn on visualizer axis
grid: flag to turn on visualizer grid
"""
function set_floor!(vis::Visualizer;
x=20.0,
y=20.0,
z=0.1,
origin=[0,0,0.0],
normal=[0,0,1.0],
color=RGBA(0.5,0.5,0.5,1.0),
tilepermeter=1.0,
imagename="tile.png",
axis::Bool=false,
grid::Bool=false)
image = PngImage(joinpath(module_dir(), "assets", imagename))
repeat = Int.(ceil.(tilepermeter * [x, y]))
texture = Texture(image=image, wrap=(1,1), repeat=(repeat[1],repeat[2]))
mat = MeshPhongMaterial(map=texture)
(color !== nothing) && (mat = MeshPhongMaterial(color=color))
obj = HyperRectangle(Vec(-x/2, -y/2, -z), Vec(x, y, z))
setobject!(vis[:floor], obj, mat)
p = origin
q = axes_pair_to_quaternion([0,0,1.], normal)
settransform!(vis[:floor], MeshCat.compose(
MeshCat.Translation(p...),
MeshCat.LinearMap(q),
))
setvisible!(vis["/Axes"], axis)
setvisible!(vis["/Grid"], grid)
return nothing
end
"""
set_surface!(vis; f, xlims, ylims, color, n)
adds surface to visualization
vis::Visualizer
f: implicit function representing surface
xlims: lateral domain for surface
ylims: longitudinal domain for surface
color: RGBA
n: number of discretization points along each domain
"""
function set_surface!(vis::Visualizer, f::Any;
xlims=[-20.0, 20.0],
ylims=[-20.0, 20.0],
color=RGBA(1.0, 1.0, 1.0, 0.0),
n::Int=200)
mesh = GeometryBasics.Mesh(f,
HyperRectangle(Vec(xlims[1], ylims[1], -2.0), Vec(xlims[2] - xlims[1], ylims[2] - ylims[1], 4.0)),
Meshing.MarchingCubes(), samples=(n, n, Int(floor(n / 8))))
setobject!(vis["surface"], mesh, MeshPhongMaterial(color=color))
return nothing
end
"""
set_light!(vis; ambient, fill, pointX, pointXshadow, direction)
lighting conditions for visualization
vis: Visualizer
ambient: value for ambient lighting
direction: positive or negative direction for light
"""
function set_light!(vis::Visualizer;
ambient=0.35,
direction::String="Positive")
setprop!(vis["/Lights/AmbientLight/<object>"], "intensity", ambient)
setprop!(vis["/Lights/FillLight/<object>"], "intensity", 0.25)
setprop!(vis["/Lights/PointLight$(direction)X/<object>"], "intensity", 0.85)
setprop!(vis["/Lights/PointLight$(direction)X/<object>"], "castShadow", true)
return nothing
end
"""
set_camera!(vis; zoom, cam_pos)
position and zoom for camera in visualization
vis: Visualizer
zoom: value for zoom
cam_pos: position of camera
"""
function set_camera!(vis::Visualizer;
zoom=1.0,
cam_pos=nothing)
camvis=vis["/Cameras/default/rotated/<object>"]
setprop!(camvis, "zoom", zoom)
(cam_pos !== nothing) && MeshCat.settransform!(camvis,
MeshCat.compose(
MeshCat.LinearMap(Dojo.RotX(-1/2 * pi)),
MeshCat.Translation(cam_pos...),
))
return nothing
end
"""
set_arrow!(vis, origin, direction; color, shaft_radius, max_head_radius, scaling, name)
adds an arrow object to scene
vis: Visualizer
origin: point defining arrow base
direction: vector defining arrow
color: RGBA
shaft_radius: dimension of arrow shaft
max_head_radius: dimension of arrow head base
scaling: parameter that scales the entire arrow
name: Symbol
"""
function set_arrow!(vis, origin, direction;
color=Colors.RGBA(1.0, 0.0, 0.0, 1.0),
shaft_radius=0.0125,
max_head_radius=0.025,
scaling=0.2,
name=:name)
# create arrow
force_vis = ArrowVisualizer(vis[name])
setobject!(force_vis, MeshPhongMaterial(color=color))
# direction
scaled_direction = scaling * direction
# set
settransform!(force_vis,
Point(origin...),
Vec(scaled_direction...),
shaft_radius=shaft_radius,
max_head_radius=max_head_radius)
end
function set_background!(vis::Visualizer; top_color=RGBA(1,1,1.0), bottom_color=RGBA(1,1,1.0))
setprop!(vis["/Background"], "top_color", top_color)
setprop!(vis["/Background"], "bottom_color", bottom_color)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 10572 | """
visualize(mechanism, storage; vis, build, show_contact, animation, color, name)
visualize mechanism using trajectory from storage
mechanism: Mechanism
storage: Storage
vis: Visualizer
build: flag to construct mechanism visuals (only needs to be built once)
show_contact: flag to show contact locations on system
color: RGBA
name: unique identifier for mechanism
"""
function visualize(mechanism::Mechanism, storage::Storage{T,N};
vis::Visualizer=Visualizer(),
framerate=60, # Inf for 1/timestep
build::Bool=true,
show_joint=false,
joint_radius=0.1,
show_contact=false,
show_frame=false,
animation=nothing,
color=nothing,
name::Symbol=:robot,
return_animation=false,
visualize_floor=true) where {T,N}
storage = deepcopy(storage)
bodies = mechanism.bodies
origin = mechanism.origin
# Build robot in the visualizer
build && build_robot(mechanism;
vis, show_joint, show_contact, show_frame, color, name, visualize_floor)
# Create animations
timestep_max = 1/framerate
time_factor = Int64(maximum([1;floor(timestep_max/mechanism.timestep)]))
framerate = Int64(round(1/(mechanism.timestep*time_factor)))
(animation === nothing) && (animation =
MeshCat.Animation(Dict{MeshCat.SceneTrees.Path,MeshCat.AnimationClip}(), framerate))
# Bodies and Contacts
for (id, body) in enumerate(bodies)
shape = body.shape
visshape = convert_shape(shape)
subvisshape = nothing
showshape = false
if visshape !== nothing
subvisshape = vis[name][:bodies][Symbol(body.name, "__id_$id")]
showshape = true
end
animate_node!(storage, id, shape, animation, subvisshape, showshape, time_factor)
if show_joint
for (jd, joint) in enumerate(mechanism.joints)
if joint.child_id == body.id
radius = 0.1
joint_shape = Sphere(radius,
position_offset=joint.translational.vertices[2],
color=RGBA(0.0, 0.0, 1.0, 0.5))
visshape = convert_shape(joint_shape)
subvisshape = nothing
showshape = false
if visshape !== nothing
subvisshape = vis[name][:joints][Symbol(joint.name, "__id_$(jd)")]
showshape = true
end
animate_node!(storage, id, joint_shape, animation, subvisshape, showshape, time_factor)
end
end
end
if show_contact
for (jd, contact) in enumerate(mechanism.contacts)
if contact.parent_id == body.id
radius = abs(contact.model.collision.contact_radius)
(radius == 0.0) && (radius = 0.01)
contact_shape = Sphere(radius,
position_offset=contact.model.collision.contact_origin, #TODO: generalize for collision checking
orientation_offset=one(Quaternion),
color=RGBA(1.0, 0.0, 0.0, 0.5))
visshape = convert_shape(contact_shape)
subvisshape = nothing
showshape = false
if visshape !== nothing
subvisshape = vis[name][:contacts][Symbol(contact.name, "__id_$(jd)")]
showshape = true
end
animate_node!(storage, id, contact_shape, animation, subvisshape, showshape, time_factor)
end
end
end
if show_frame
frame_shape = FrameShape(scale=0.33*ones(3))
visshape = convert_shape(frame_shape)
subvisshape = vis[name][:frames][Symbol(body.name, "__id_$id")]
showshape = true
animate_node!(storage, id, frame_shape, animation, subvisshape, showshape, time_factor)
end
end
# Origin
id = origin.id
shape = origin.shape
visshape = convert_shape(shape)
if visshape !== nothing
subvisshape = vis[name][:bodies][Symbol(:origin, "_id")]
shapetransform = transform(szeros(T,3), one(Quaternion{T}), shape)
settransform!(subvisshape, shapetransform)
end
setanimation!(vis, animation)
return_animation ? (return vis, animation) : (return vis)
end
"""
build_robot(mechanism; vis, show_contact, name, color)
construct visuals for mechanism
mechanism: Mechanism
vis: Visualizer
show_contact: flag to show contact locations on mechanism
name: unique identifier
color: RGBA
"""
function build_robot(mechanism::Mechanism;
vis::Visualizer=Visualizer(),
show_joint=false,
joint_radius=0.1,
show_contact=false,
show_frame=false,
name::Symbol=:robot,
color=nothing,
visualize_floor=true)
bodies = mechanism.bodies
origin = mechanism.origin
set_background!(vis)
set_light!(vis)
visualize_floor && set_floor!(vis)
# Bodies and Contacts
for (id, body) in enumerate(bodies)
if color !== nothing
shape = deepcopy(body.shape)
set_color!(shape, color)
else
shape = body.shape
end
visshape = convert_shape(shape)
subvisshape = nothing
if visshape !== nothing
subvisshape = vis[name][:bodies][Symbol(body.name, "__id_$id")]
setobject!(subvisshape, visshape, shape,
transparent=(show_joint || show_contact))
end
if show_joint
for (jd, joint) in enumerate(mechanism.joints)
if joint.child_id == body.id
radius = joint_radius
joint_shape = Sphere(radius,
position_offset=joint.translational.vertices[2],
color=RGBA(0.0, 0.0, 1.0, 0.5))
visshape = convert_shape(joint_shape)
subvisshape = nothing
if visshape !== nothing
subvisshape = vis[name][:joints][Symbol(joint.name, "__id_$(jd)")]
setobject!(subvisshape, visshape, joint_shape,
transparent=false)
end
end
end
end
if show_contact
for (jd, contact) in enumerate(mechanism.contacts)
if contact.parent_id == body.id
radius = abs(contact.model.collision.contact_radius)
(radius == 0.0) && (radius = 0.01)
contact_shape = Sphere(radius,
position_offset=(contact.model.collision.contact_origin),
orientation_offset=one(Quaternion), color=RGBA(1.0, 0.0, 0.0, 0.5))
visshape = convert_shape(contact_shape)
subvisshape = nothing
if visshape !== nothing
subvisshape = vis[name][:contacts][Symbol(contact.name, "__id_$(jd)")]
setobject!(subvisshape,visshape,contact_shape,transparent=false)
end
end
end
end
if show_frame
frame_shape = FrameShape(scale=0.33*ones(3))
visshape = convert_shape(frame_shape)
subvisshape = vis[name][:frames][Symbol(body.name, "__id_$id")]
setobject!(subvisshape, visshape, frame_shape,
transparent=false)
end
end
# Origin
id = origin.id
shape = origin.shape
visshape = convert_shape(shape)
if visshape !== nothing
subvisshape = vis[name][:bodies][Symbol(:origin, "_id")]
setobject!(subvisshape,visshape,shape,transparent=(show_joint || show_contact))
end
return vis
end
function transform(x, q, shape)
scale_transform = MeshCat.LinearMap(diagm(shape.scale))
x_transform = MeshCat.Translation(x + vector_rotate(shape.position_offset, q))
q_transform = MeshCat.LinearMap(q * shape.orientation_offset)
return MeshCat.compose(x_transform, q_transform, scale_transform)
end
MeshCat.js_scaling(s::AbstractVector) = s
MeshCat.js_position(p::AbstractVector) = p
function set_node!(x, q, shape, shapevisualizer, showshape)
if showshape
# TODO currently setting props directly because MeshCat/Rotations doesn't convert scaled rotation properly.
# If this changes, do similarily to origin
setprop!(shapevisualizer, "scale", MeshCat.js_scaling(shape.scale))
setprop!(shapevisualizer, "position", MeshCat.js_position(x + vector_rotate(shape.position_offset, q)))
setprop!(shapevisualizer, "quaternion", MeshCat.js_quaternion(q * shape.orientation_offset))
end
return
end
function animate_node!(storage::Storage{T,N}, id, shape, animation, shapevisualizer, showshape, time_factor) where {T,N}
frame_id = 1
for i=1:time_factor:N
x = storage.x[id][i]
q = storage.q[id][i]
atframe(animation, frame_id) do
set_node!(x, q, shape, shapevisualizer, showshape)
end
frame_id += 1
end
return
end
function MeshCat.setobject!(subvisshape, visshapes::Vector, shape::CombinedShapes; transparent=false)
for (i,visshape) in enumerate(visshapes)
v = subvisshape["shape"*string(i)]
s = shape.shapes[i]
setobject!(v, visshape, s; transparent)
scale_transform = MeshCat.LinearMap(diagm(s.scale))
x_transform = MeshCat.Translation(s.position_offset)
q_transform = MeshCat.LinearMap(s.orientation_offset)
t = MeshCat.compose(x_transform, q_transform, scale_transform)
settransform!(v, t)
end
end
function MeshCat.setobject!(subvisshape, visshape, shape::Shape; transparent=false)
setobject!(subvisshape, visshape, MeshPhongMaterial(color=(transparent ? RGBA(0.75, 0.75, 0.75, 0.5) : shape.color)))
end
function MeshCat.setobject!(subvisshape, visshape, shape::FrameShape; transparent=false)
setobject!(subvisshape, visshape)
end
function MeshCat.setobject!(subvisshape, visshape, shape::Mesh; transparent=false)
if visshape.mtl_library == ""
visshape = MeshFileGeometry(visshape.contents, visshape.format)
setobject!(subvisshape, visshape, MeshPhongMaterial(color=(transparent ? RGBA(0.75, 0.75, 0.75, 0.5) : shape.color)))
else
setobject!(subvisshape, visshape)
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 3589 | @testset "Quadruped" begin
mech = get_mechanism(:quadruped;
timestep=0.05,
gravity=-9.81,
friction_coefficient=0.8,
parse_springs=false,
parse_dampers=false,
dampers=1000.0,
springs=30.0)
initialize!(mech, :quadruped)
storage = simulate!(mech, 5.0,
record=true,
verbose=false)
res = get_sdf(mech, storage) # distance from floor to each contact
@test minimum(minimum([min.(0.0, r) for r in res])) >= 0.0
end
@testset "Box toss" begin
for timestep in [0.10, 0.05, 0.01, 0.005]
mech = get_mechanism(:block;
timestep,
gravity=-9.81,
friction_coefficient = 0.1)
initialize!(mech, :block,
position=[0.0, 0.0, 0.5],
velocity=[1.0, 1.5, 1.0],
angular_velocity=[5.0, 4.0, 2.0] .* timestep)
storage = simulate!(mech, 5.0,
record=true,
opts=SolverOptions(btol=1e-6, rtol=1e-6,
verbose=false))
@test norm(storage.v[1][end], Inf) < 1.0e-8
@test norm(storage.x[1][end][3] - 0.25, Inf) < 1.0e-3
end
end
@testset "Box external force" begin
mech = get_mechanism(:block;gravity=0, contact=false, mass=1)
mech.bodies[1].inertia = diagm(ones(3))
controller!(mechanism, k) = (k<=50 ? set_external_force!(mechanism.bodies[1];force=[1;0;0],vertex=[0.5;0;0]) : nothing)
initialize!(mech, :block; position=zeros(3), orientation=Dojo.RotZ(pi/2), velocity=zeros(3), angular_velocity=zeros(3))
storage = simulate!(mech, 1.0, controller!, record=true)
@test norm(mech.bodies[1].state.vsol[1][2] - 0.5) < 1.0e-3
controller!(mechanism, k) = (k<=50 ? set_external_force!(mechanism.bodies[1];torque=[1;0;0],vertex=[0.5;0;0]) : nothing)
initialize!(mech, :block; position=zeros(3), orientation=Dojo.RotZ(pi/2), velocity=zeros(3), angular_velocity=zeros(3))
storage = simulate!(mech, 1.0, controller!, record=true)
@test norm(mech.bodies[1].state.ωsol[1][1] - 0.5) < 1.0e-3
end
@testset "Four-bar linkage" begin
for timestep in [0.10, 0.05, 0.01, 0.005]
mech = get_mechanism(:fourbar;
timestep,
parse_springs=false,
parse_dampers=false,
dampers=0.0)
Dojo.initialize!(mech, :fourbar,
inner_angle=0.25)
loopjoints = mech.joints[end:end]
Dojo.root_to_leaves_ordering(mech) == [2, 7, 3, 6, 1, 8, 4, 9]
# Simulation
function ctrl!(m, t)
Dojo.set_input!(m, 1.0 * SVector(rand(), -rand(), 0.0, 0.0, 0.0))
return nothing
end
storage = Dojo.simulate!(mech, 5.0, ctrl!, verbose=false, record=true)
min_coords = Dojo.get_minimal_coordinates(mech)
@test norm(min_coords[5] - +min_coords[4], Inf) < 1.0e-5
@test norm(min_coords[5] - -min_coords[3], Inf) < 1.0e-5
@test norm(min_coords[5] - (min_coords[2] - min_coords[1]), Inf) < 1.0e-5
end
end
@testset "Dzhanibekov" begin
# Simulation
timestep=0.01
gravity=0.0
mech = get_mechanism(:dzhanibekov;
timestep,
gravity);
# Simulate
Dojo.initialize!(mech, :dzhanibekov,
angular_velocity=[15.0; 0.01; 0.0])
storage = Dojo.simulate!(mech, 4.0,
record=true,
verbose=false)
# The x position of the side body oscillate between a positive and negative
# value when we observe the Dhanibekov effect. Otherwise, it always remains in the positive position.
@test Dojo.minimum([x[1] for x in storage.x[2]]) < -0.05
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 816 | @testset "Shape convertion" begin
# shapes
box = Dojo.Box(1.0, 1.0, 1.0)
cylinder = Dojo.Cylinder(1.0, 1.0)
capsule = Dojo.Capsule(1.0, 1.0)
shapes = Dojo.CombinedShapes([box, cylinder, capsule])
sphere = Dojo.Sphere(1.0)
pyramid = Dojo.Pyramid(1.0, 1.0)
frame = Dojo.FrameShape()
mesh = Dojo.Mesh(joinpath(dirname(pathof(DojoEnvironments)), "mechanisms/atlas/dependencies/mesh/head.obj"))
# convert
box_geom = Dojo.convert_shape(box)
cylinder_geom = Dojo.convert_shape(cylinder)
capsule_geom = Dojo.convert_shape(capsule)
shapes_geom = Dojo.convert_shape(shapes)
sphere_geom = Dojo.convert_shape(sphere)
pyramid_geom = Dojo.convert_shape(pyramid)
frame_geom = Dojo.convert_shape(frame)
mesh_geom = Dojo.convert_shape(mesh)
@test true
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 28247 | @testset "Collision: Sphere-sphere" begin
function get_two_body(;
radius_body1=0.5,
radius_body2=0.5,
mass_body1=1.0,
mass_body2=1.0,
friction_type=:nonlinear,
friction_coefficient=0.5,
joint_world_body1=:Fixed,
gravity=-9.81,
timestep=0.1)
origin = Dojo.Origin{Float64}()
pbody = Dojo.Sphere(radius_body1, mass_body1)
cbody = Dojo.Sphere(radius_body2, mass_body2)
joint = Dojo.JointConstraint(eval(joint_world_body1)(origin, pbody))
bodies = [pbody, cbody]
joints = [joint]
# contact model
collision = Dojo.SphereSphereCollision{Float64,2,3,6}(
szeros(3),
szeros(3),
pbody.shape.r,
cbody.shape.r)
if friction_type == :nonlinear
friction_parameterization = SA{Float64}[
1.0 0.0
0.0 1.0
]
body_body = Dojo.NonlinearContact{Float64,8}(friction_coefficient, friction_parameterization, collision)
elseif friction_type == :linear
friction_parameterization = SA{Float64}[
0.0 1.0
0.0 -1.0
1.0 0.0
-1.0 0.0
]
body_body = Dojo.LinearContact{Float64,12}(friction_coefficient, friction_parameterization, collision)
elseif friction_type == :impact
friction_parameterization = szeros(Float64, 0, 2)
collision = Dojo.SphereSphereCollision{Float64,0,3,0}(
szeros(3),
szeros(3),
pbody.shape.r,
cbody.shape.r)
body_body = Dojo.ImpactContact{Float64,2}(friction_parameterization, collision)
end
contacts = [Dojo.ContactConstraint((body_body, pbody.id, cbody.id), name=:body_body)]
# z-drop (w/ gravity)
mechanism = Dojo.Mechanism(origin, bodies, joints, contacts;
gravity,
timestep)
return mechanism
end
function test_jacobians(mechanism)
# unpack
collision = mechanism.contacts[1].model.collision
xp = mechanism.bodies[1].state.x2
qp = mechanism.bodies[1].state.q2
xc = mechanism.bodies[2].state.x2
qc = mechanism.bodies[2].state.q2
for jacobian in [:parent, :child]
# distance
dis = Dojo.distance(collision, xp, qp, xc, qc)
X = Dojo.∂contact_normal_transpose∂x(jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(x -> Dojo.contact_normal(collision, x, qp, xc, qc)', xp)
elseif jacobian == :child
FD = ForwardDiff.jacobian(x -> Dojo.contact_normal(collision, xp, qp, x, qc)', xc)
end
@test norm((dis >= 0.0 ? 1.0 : -1.0) * X - FD, Inf) < 1.0e-6
Q = Dojo.∂contact_normal_transpose∂q(jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(q -> Dojo.contact_normal(collision, xp, Quaternion(q...), xc, qc)', Dojo.vector(qp))
elseif jacobian == :child
FD = ForwardDiff.jacobian(q -> Dojo.contact_normal(collision, xp, qp, xc, Quaternion(q...))', Dojo.vector(qc))
end
@test norm((dis >= 0.0 ? 1.0 : -1.0) * Q - FD, Inf) < 1.0e-6
X = Dojo.∂contact_tangent_one_transpose∂x(jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(x -> Dojo.contact_tangent(collision, x, qp, xc, qc)[1, :]', xp)
elseif jacobian == :child
FD = ForwardDiff.jacobian(x -> Dojo.contact_tangent(collision, xp, qp, x, qc)[1, :]', xc)
end
@test norm(FD - X, Inf) < 1.0e-6
X = Dojo.∂contact_tangent_two_transpose∂x(jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(x -> Dojo.contact_tangent(collision, x, qp, xc, qc)[2, :]', xp)
elseif jacobian == :child
FD = ForwardDiff.jacobian(x -> Dojo.contact_tangent(collision, xp, qp, x, qc)[2, :]', xc)
end
@test norm(FD - X, Inf) < 1.0e-6
Q = Dojo.∂contact_tangent_one_transpose∂q(jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(q -> Dojo.contact_tangent(collision, xp, Quaternion(q...), xc, qc)[1, :]', Dojo.vector(qp))
elseif jacobian == :child
FD = ForwardDiff.jacobian(q -> Dojo.contact_tangent(collision, xp, qp, xc, Quaternion(q...))[1, :]', Dojo.vector(qc))
end
@test norm(FD - Q, Inf) < 1.0e-6
Q = Dojo.∂contact_tangent_two_transpose∂q(jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(q -> Dojo.contact_tangent(collision, xp, Quaternion(q...), xc, qc)[2, :]', Dojo.vector(qp))
elseif jacobian == :child
FD = ForwardDiff.jacobian(q -> Dojo.contact_tangent(collision, xp, qp, xc, Quaternion(q...))[2, :]', Dojo.vector(qc))
end
@test norm(FD - Q, Inf) < 1.0e-6
# gradients
gradient = jacobian
D = Dojo.∂distance∂x(gradient, collision, xp, qp, xc, qc)
if gradient == :parent
FD = FiniteDiff.finite_difference_jacobian(x -> Dojo.distance(collision, x, qp, xc, qc), xp)
elseif gradient == :child
FD = FiniteDiff.finite_difference_jacobian(x -> Dojo.distance(collision, xp, qp, x, qc), xc)
end
@test norm(D - FD, Inf) < 1.0e-5
Q = Dojo.∂distance∂q(gradient, collision, xp, qp, xc, qc)
if gradient == :parent
FD = FiniteDiff.finite_difference_jacobian(q -> Dojo.distance(collision, xp, Quaternion(q...), xc, qc), Dojo.vector(qp))
elseif gradient == :child
FD = FiniteDiff.finite_difference_jacobian(q -> Dojo.distance(collision, xp, qp, xc, Quaternion(q...)), Dojo.vector(qc))
end
@test norm(Q - FD, Inf) < 1.0e-5
for relative in [:parent, :child]
X = Dojo.∂contact_point∂x(relative, jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(x -> Dojo.contact_point(relative, collision, x, qp, xc, qc), xp)
elseif jacobian == :child
FD = ForwardDiff.jacobian(x -> Dojo.contact_point(relative, collision, xp, qp, x, qc), xc)
end
@test norm(X - FD, Inf) < 1.0e-6
Q = Dojo.∂contact_point∂q(relative, jacobian, collision, xp, qp, xc, qc)
if jacobian == :parent
FD = ForwardDiff.jacobian(q -> Dojo.contact_point(relative, collision, xp, Quaternion(q...), xc, qc), Dojo.vector(qp))
elseif jacobian == :child
FD = ForwardDiff.jacobian(q -> Dojo.contact_point(relative, collision, xp, qp, xc, Quaternion(q...)), Dojo.vector(qc))
end
@test norm(Q - FD, Inf) < 1.0e-6
end
end
end
for friction_type in [:nonlinear, :linear, :impact]
## z drop
mech = get_two_body(;
friction_type=friction_type,
gravity=-9.81)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 0.0, 2.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [0.0, 0.0, 0.0]
# initial Jacobians
test_jacobians(mech)
# initial distance
d = Dojo.distance(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test abs(d - 1.0) < 1.0e-6
# body 1 contact point
cp = Dojo.contact_point(:parent, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cp - [0.0; 0.0; 0.5], Inf) < 1.0e-6
# body 2 contact point
cc = Dojo.contact_point(:child, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cc - [0.0; 0.0; 1.5], Inf) < 1.0e-6
# contact normal
cn = Dojo.contact_normal(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cn - [0.0 0.0 -1.0], Inf) < 1.0e-6
# contact tangent
ct = Dojo.contact_tangent(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(ct - [0.0 1.0 0.0; -1.0 0.0 0.0], Inf) < 1.0e-6
# graph
am = Dojo.adjacency_matrix(mech.joints, mech.bodies, mech.contacts)
@test norm(am - [0 1 0 0; 1 0 0 1; 0 0 0 1; 0 1 1 0], Inf) < 1.0e-6
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test norm(storage.x[2][end] - [0.0; 0.0; 1.0], Inf) < 1.0e-4
## z velocity (no gravity)
mech = get_two_body(;
friction_type=friction_type,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 0.0, 2.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [0.0, 0.0, -5.0]
# initial Jacobians
test_jacobians(mech)
# simulate
storage = simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][end] > 1.0
# z velocity (no gravity)
mech = get_two_body(;
friction_type=friction_type,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 0.0, 2.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [0.0, 0.0, -5.0]
# initial Jacobians
test_jacobians(mech)
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][end] > 1.0
## z velocity (no gravity, floating parent)
mech = get_two_body(;
friction_type=friction_type,
joint_world_body1=:Floating,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 0.0, 2.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [0.0, 0.0, -5.0]
# initial Jacobians
test_jacobians(mech)
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][end] - storage.x[1][end][end] > 1.0
@test storage.x[2][end][end] < 0.0
## x velocity (fixed parent)
mech = get_two_body(;
friction_type=friction_type,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [2.0, 0.0, 0.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [-5.0, 0.0, 0.0]
# initial Jacobians
test_jacobians(mech)
# initial distance
d = Dojo.distance(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test abs(d - 1.0) < 1.0e-6
# body 1 contact point
cp = Dojo.contact_point(:parent, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cp - [0.5; 0.0; 0.0], Inf) < 1.0e-6
# body 2 contact point
cc = Dojo.contact_point(:child, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cc - [1.5; 0.0; 0.0], Inf) < 1.0e-6
# contact normal
cn = Dojo.contact_normal(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cn - [-1.0 0.0 0.0], Inf) < 1.0e-6
# contact tangent
ct = Dojo.contact_tangent(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(ct - [0.0 0.0 1.0; 0.0 -1.0 0.0], Inf) < 1.0e-6
# graph
am = Dojo.adjacency_matrix(mech.joints, mech.bodies, mech.contacts)
@test norm(am - [0 1 0 0; 1 0 0 1; 0 0 0 1; 0 1 1 0], Inf) < 1.0e-6
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][1] > 1.0
## x velocity (floating parent)
mech = get_two_body(;
friction_type=friction_type,
joint_world_body1=:Floating,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [2.0, 0.0, 0.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [-5.0, 0.0, 0.0]
# initial Jacobians
test_jacobians(mech)
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][1] - storage.x[1][end][1] > 1.0
@test storage.x[1][end][1] < 0.0
## y velocity (fixed parent)
mech = get_two_body(;
friction_type=friction_type,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 2.0, 0.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [0.0, -5.0, 0.0]
# initial Jacobians
test_jacobians(mech)
# initial distance
d = Dojo.distance(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test abs(d - 1.0) < 1.0e-6
# body 1 contact point
cp = Dojo.contact_point(:parent, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cp - [0.0; 0.5; 0.0], Inf) < 1.0e-6
# body 2 contact point
cc = Dojo.contact_point(:child, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cc - [0.0; 1.5; 0.0], Inf) < 1.0e-6
# contact normal
cn = Dojo.contact_normal(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cn - [0.0 -1.0 0.0], Inf) < 1.0e-6
# contact tangent
ct = Dojo.contact_tangent(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(ct - [0.0 0.0 -1.0; -1.0 0.0 0.0], Inf) < 1.0e-6
# graph
am = Dojo.adjacency_matrix(mech.joints, mech.bodies, mech.contacts)
@test norm(am - [0 1 0 0; 1 0 0 1; 0 0 0 1; 0 1 1 0], Inf) < 1.0e-6
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][2] > 1.0
## y velocity (floating parent)
mech = get_two_body(;
friction_type=friction_type,
joint_world_body1=:Floating,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 2.0, 0.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [0.0, -5.0, 0.0]
# initial Jacobians
test_jacobians(mech)
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][2] - storage.x[1][end][2] > 1.0
@test storage.x[1][end][2] < 0.0
## xyz velocity (fixed parent)
mech = get_two_body(;
friction_type=friction_type,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [2.0, 2.0, 2.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [-2.0, -2.0, -2.0]
# initial Jacobians
test_jacobians(mech)
# initial distance
d = Dojo.distance(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test abs(d - 2.4641016) < 1.0e-4
# body 1 contact point
cp = Dojo.contact_point(:parent, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cp - [0.288675; 0.288675; 0.288675], Inf) < 1.0e-4
# body 2 contact point
cc = Dojo.contact_point(:child, mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cc - [1.711324; 1.711324; 1.711324], Inf) < 1.0e-4
# contact normal
cn = Dojo.contact_normal(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(cn - [-0.57735 -0.57735 -0.57735], Inf) < 1.0e-4
# contact tangent
ct = Dojo.contact_tangent(mech.contacts[1].model.collision,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,)
@test norm(ct - [0.0 0.57735 -0.57735; -0.66666 0.33333 0.33333], Inf) < 1.0e-4
# graph
am = Dojo.adjacency_matrix(mech.joints, mech.bodies, mech.contacts)
@test norm(am - [0 1 0 0; 1 0 0 1; 0 0 0 1; 0 1 1 0], Inf) < 1.0e-6
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
# test no interpentration
@test storage.x[2][end][1] > 0.5
@test storage.x[2][end][2] > 0.5
@test storage.x[2][end][3] > 0.5
# test reverse velocity direction
@test norm(Dojo.normalize(storage.v[2][end]) + Dojo.normalize([-2.0, -2.0, -2.0]), Inf) < 1.0e-5
## xyz velocity (floating parent)
mech = get_two_body(;
friction_type=friction_type,
joint_world_body1=:Floating,
gravity=0.0)
# initialize
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [2.0, 2.0, 2.0]
mech.bodies[1].state.v15 = [0.0, 0.0, 0.0]
mech.bodies[2].state.v15 = [-2.0, -2.0, -2.0]
# initial Jacobians
test_jacobians(mech)
# simulate
storage = Dojo.simulate!(mech, 2.0,
verbose=false,
record=true)
# Jacobians
test_jacobians(mech)
@test norm(storage.x[2][end] - storage.x[1][end]) > 1.0
@test norm(Dojo.normalize(storage.v[2][end]) - Dojo.normalize([-2.0, -2.0, -2.0]), Inf) < 1.0e-5
@test norm(Dojo.normalize(storage.v[1][end]) - Dojo.normalize([-2.0, -2.0, -2.0]), Inf) < 1.0e-5
end
end
# Sphere-Capsule
@testset "Collision: Sphere-capsule" begin
function simulate_sphere_capsule(x1, x2)
origin = Dojo.Origin{Float64}()
pbody = Dojo.Capsule(0.5, 2.0, 1.0, orientation_offset=Dojo.Quaternion(sqrt(2.0) / 2.0, sqrt(2.0) / 2.0, 0.0, 0.0))
cbody = Dojo.Sphere(0.5, 1.0)
joint = Dojo.JointConstraint(Dojo.Fixed(origin, pbody))
bodies = [pbody, cbody]
joints = [joint]
collision = Dojo.SphereCapsuleCollision{Float64,2,3,6}(
szeros(3),
SA[0.0; 1.0; 0.0],
SA[0.0; -1.0; 0.0],
0.5,
0.5,
)
friction_parameterization = SA{Float64}[
1.0 0.0
0.0 1.0
]
body_body_contact = Dojo.NonlinearContact{Float64,8}(0.5, friction_parameterization, collision)
contacts = [Dojo.ContactConstraint((body_body_contact, cbody.id, pbody.id), name=:body_body)]
mech = Dojo.Mechanism(origin, bodies, joints, contacts,
gravity=1.0 * -9.81,
timestep=0.05)
mech.bodies[1].state.x2 = x1
mech.bodies[2].state.x2 = x2
storage = Dojo.simulate!(mech, 1.0,
verbose=false,
record=true)
return mech, storage
end
x2 = [[0.0, 0.0, 2.0], [0.2, 0.5, 2.0]]
mech, storage = simulate_sphere_capsule([0.0, 0.0, 0.0], x2[1])
d = Dojo.distance(mech.contacts[1].model.collision,
storage.x[2][end], storage.q[2][end],
storage.x[1][end], storage.q[1][end],)
@test d > 0.0
cp = Dojo.contact_point(:parent, mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,)
@test norm(cp - [0.0; 0.0; 0.5], Inf) < 1.0e-2
cc = Dojo.contact_point(:child, mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
)
@test norm(cc - [0.0; 0.0; 0.5], Inf) < 1.0e-2
cn = Dojo.contact_normal(mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
)
@test norm(cn - [0.0 0.0 1.0], Inf) < 1.0e-3
ct = Dojo.contact_tangent(mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
)
@test norm(ct - [0.0 -1.0 0.0; -1.0 0.0 0.0], Inf) < 1.0e-2
mech, storage = simulate_sphere_capsule([0.0, 0.0, 0.0], x2[2])
d = Dojo.distance(mech.contacts[1].model.collision,
storage.x[2][end], storage.q[2][end],
storage.x[1][end], storage.q[1][end],)
@test d > 0.0
end
# Sphere-Box
@testset "Collision: Sphere-box" begin
function simulate_sphere_box(x1, x2, v2)
origin = Dojo.Origin{Float64}()
pbody = Dojo.Box(1.0, 1.0, 1.0, 1.0)
cbody = Dojo.Sphere(0.5, 1.0)
joint = Dojo.JointConstraint(Dojo.Fixed(origin, pbody))
bodies = [pbody, cbody]
joints = [joint]
collision = Dojo.SphereBoxCollision{Float64,2,3,6}(
szeros(3),
1.0,
1.0,
1.0,
0.5,
)
friction_parameterization = SA{Float64}[
1.0 0.0
0.0 1.0
]
body_body_contact = Dojo.NonlinearContact{Float64,8}(0.5, friction_parameterization, collision)
contacts = [Dojo.ContactConstraint((body_body_contact, cbody.id, pbody.id), name=:body_body)]
mech = Dojo.Mechanism(origin, bodies, joints, contacts,
gravity=1.0 * -9.81,
timestep=0.05)
mech.bodies[1].state.x2 = x1
mech.bodies[2].state.x2 = x2
mech.bodies[2].state.v15 = v2
storage = Dojo.simulate!(mech, 1.0,
verbose=false,
record=true)
return mech, storage
end
x1 = [0.0, 0.0, 0.0]
x2 = [
[0.0, 0.0, 2.0],
[0.0, 1.0, 2.0],
[1.0, 1.0, 2.0],
[-1.0, 1.0, 2.0],
[-0.5; 0.5; 2.0],
[0.0, -1.0, 2.0],
[0.0, -1.0, 2.0],
[-1.0, -1.0, -2.0],
[0.0, 0.0, -2.0],
]
v2 = [
[0.0, 0.0, 0.0],
[0.0; -1.0; -2.0],
[-1.0; -1.0; -2.0],
[1.0; -1.0; -2.0],
[0.0; 0.0; 0.0],
[0.0; 1.0; -2.0],
[0.0; 1.0; -2.0],
[5.0; 5.0; 10.0],
[0.0; 0.0; 10.0],
]
N = length(x2)
for i = 1:N
mech, storage = simulate_sphere_box(x1, x2[i], v2[i])
d = Dojo.distance(mech.contacts[1].model.collision,
storage.x[2][end], storage.q[2][end],
storage.x[1][end], storage.q[1][end],)
@test d > 0.0
if i == 1
cp = Dojo.contact_point(:parent, mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,)
@test norm(cp - [0.0; 0.0; 0.5], Inf) < 1.0e-2
cc = Dojo.contact_point(:child, mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
)
@test norm(cc - [0.0; 0.0; 0.5], Inf) < 1.0e-2
cn = Dojo.contact_normal(mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
)
@test norm(cn - [0.0 0.0 1.0], Inf) < 1.0e-3
ct = Dojo.contact_tangent(mech.contacts[1].model.collision,
mech.bodies[2].state.x2, mech.bodies[2].state.q2,
mech.bodies[1].state.x2, mech.bodies[1].state.q2,
)
@test norm(ct - [0.0 -1.0 0.0; -1.0 0.0 0.0], Inf) < 1.0e-2
end
end
end
@testset "Collision: String" begin
origin = Origin{Float64}()
pbody = Sphere(0.5, 1.0)
cbody = Sphere(0.5, 1.0)
joint = JointConstraint(Fixed(origin, pbody))
bodies = [pbody, cbody]
joints = [joint]
collision = StringCollision{Float64,2,3,6}(
szeros(3),
szeros(3),
2.0)
friction_parameterization = SA{Float64}[
1.0 0.0
0.0 1.0
]
body_body_contact = NonlinearContact{Float64,8}(0.5, friction_parameterization, collision)
contacts = [ContactConstraint((body_body_contact, pbody.id, cbody.id), name=:body_body)]
mech = Mechanism(origin, bodies, joints, contacts;
gravity=1.0 * -9.81,
timestep=0.1)
mech.bodies[1].state.x2 = [0.0, 0.0, 0.0]
mech.bodies[2].state.x2 = [0.0, 0.0, 1.0]
storage = simulate!(mech, 2.0,
verbose=false,
record=true)
# vis = Visualizer()
# render(vis)
# visualize(mech, storage,
# vis=vis)
@test norm(mech.bodies[2].state.x2 - mech.bodies[1].state.x2) < 2.0
end | Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 4479 | @testset "rotational damper jacobian" begin
joint_types = [
:Fixed,
:Prismatic,
:Planar,
:FixedOrientation,
:Revolute,
:Cylindrical,
:PlanarAxis,
:FreeRevolute,
:Orbital,
:PrismaticOrbital,
:PlanarOrbital,
:FreeOrbital,
:Spherical,
:CylindricalFree,
:PlanarFree
]
for joint_type in joint_types
mech = DojoEnvironments.get_snake(;
gravity=0.0, num_bodies=2,
dampers=0.3, joint_type)
DojoEnvironments.initialize_snake!(mech)
function ctrl!(m,k)
Dojo.set_input!(m, 0.01*ones(Dojo.minimal_dimension(m)))
end
storage = Dojo.simulate!(mech, 1.0, ctrl!)
# Dojo.visualize(mech, storage, vis=vis)
rot0 = mech.joints[2].rotational
timestep0 = mech.timestep
pbody0 = mech.bodies[1]
cbody0 = mech.bodies[2]
xa0, va0, qa0, ωa0 = Dojo.current_configuration_velocity(pbody0.state)
xb0, vb0, qb0, ωb0 = Dojo.current_configuration_velocity(cbody0.state)
# Configuration
J0 = Dojo.damper_jacobian_configuration(:parent, :parent, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
xq -> timestep0 * Dojo.damper_force(:parent, rot0,
Dojo.Quaternion(xq[4:7]...), ωa0, qb0, ωb0, timestep0; rotate=true, unitary=false),
[xa0; Dojo.vector(qa0)]) * Dojo.cat(I(3), Dojo.LVᵀmat(qa0), dims=(1,2))
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
J0 = Dojo.damper_jacobian_configuration(:parent, :child, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
xq -> timestep0 * Dojo.damper_force(:parent, rot0, qa0, ωa0,
Dojo.Quaternion(xq[4:7]...), ωb0, timestep0; rotate=true, unitary=false),
[xb0; Dojo.vector(qb0)]) * Dojo.cat(I(3), Dojo.LVᵀmat(qb0), dims=(1,2))
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
J0 = Dojo.damper_jacobian_configuration(:child, :parent, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
xq -> timestep0 * Dojo.damper_force(:child, rot0,
Dojo.Quaternion(xq[4:7]...), ωa0, qb0, ωb0, timestep0; rotate=true, unitary=false),
[xa0; Dojo.vector(qa0)]) * Dojo.cat(I(3), Dojo.LVᵀmat(qa0), dims=(1,2))
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
J0 = Dojo.damper_jacobian_configuration(:child, :child, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
xq -> timestep0 * Dojo.damper_force(:child, rot0, qa0, ωa0,
Dojo.Quaternion(xq[4:7]...), ωb0, timestep0; rotate=true, unitary=false),
[xb0; Dojo.vector(qb0)]) * Dojo.cat(I(3), Dojo.LVᵀmat(qb0), dims=(1,2))
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
# Velocity
J0 = Dojo.damper_jacobian_velocity(:parent, :parent, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
vω -> timestep0 * Dojo.damper_force(:parent, rot0, qa0,
vω[Dojo.SUnitRange(4,6)], qb0, ωb0, timestep0; rotate=true, unitary=false),
[va0; ωa0])
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
J0 = Dojo.damper_jacobian_velocity(:parent, :child, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
vω -> timestep0 * Dojo.damper_force(:parent, rot0, qa0, ωa0, qb0,
vω[Dojo.SUnitRange(4,6)], timestep0; rotate=true, unitary=false),
[vb0; ωb0])
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
J0 = Dojo.damper_jacobian_velocity(:child, :parent, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
vω -> timestep0 * Dojo.damper_force(:child, rot0, qa0,
vω[Dojo.SUnitRange(4,6)], qb0, ωb0, timestep0; rotate=true, unitary=false),
[va0; ωa0])
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
J0 = Dojo.damper_jacobian_velocity(:child, :child, rot0, pbody0, cbody0, timestep0)
J1 = ForwardDiff.jacobian(
vω -> timestep0 * Dojo.damper_force(:child, rot0, qa0, ωa0, qb0,
vω[Dojo.SUnitRange(4,6)], timestep0; rotate=true, unitary=false),
[vb0; ωb0])
norm(J0 - J1, Inf)
@test norm(J0 - J1, Inf) < 1.0e-8
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 6948 | joint_types = [
:Fixed,
:Prismatic,
:Planar,
:FixedOrientation,
:Revolute,
:Cylindrical,
:PlanarAxis,
:FreeRevolute,
:Orbital,
:PrismaticOrbital,
:PlanarOrbital,
:FreeOrbital,
:Spherical,
:CylindricalFree,
:PlanarFree
]
function test_get_set_data(mechanism::Mechanism)
Nd = Dojo.data_dim(mechanism,
attjac=false)
data0 = rand(Nd)
Dojo.set_data!(mechanism, data0)
data1 = Dojo.get_data(mechanism)
@test norm(data0 - data1) < 1.0e-8
end
@testset "Get and set data" begin
mech = DojoEnvironments.get_snake(;
num_bodies=3, dampers=1.0, springs=1.0, contact_type=:nonlinear);
test_get_set_data(mech)
mech = DojoEnvironments.get_snake(;
num_bodies=3, dampers=1.0, springs=1.0, contact_type=:linear);
test_get_set_data(mech)
mech = DojoEnvironments.get_snake(;
num_bodies=3, dampers=1.0, springs=1.0, contact_type=:impact);
test_get_set_data(mech)
mech = DojoEnvironments.get_pendulum(;
dampers=1.0, springs=10.0);
test_get_set_data(mech)
mech = DojoEnvironments.get_humanoid(;
parse_springs=false, parse_dampers=false,
springs=10.0, contact_feet=true);
test_get_set_data(mech)
mech = DojoEnvironments.get_humanoid(;
parse_springs=false, parse_dampers=false,
springs=10.0, contact_feet=false);
test_get_set_data(mech)
mech = DojoEnvironments.get_atlas(;
parse_springs=false, parse_dampers=false,
springs=10.0, dampers=10.0);
test_get_set_data(mech)
mech = DojoEnvironments.get_quadruped(;
parse_springs=false, parse_dampers=false,
dampers=1.0, springs=10.0);
test_get_set_data(mech)
end
################################################################################
# Analytical Jacobian
################################################################################
# Controller
function ctrl!(mechanism, k)
nu = Dojo.input_dimension(mechanism)
if Dojo.input_dimension(mechanism.joints[1]) == 6
u = 0.2 * [szeros(6); sones(nu-6)]
else
u = 0.2 * sones(nu)
end
Dojo.set_input!(mechanism, u)
return
end
function test_data_system(model::Symbol;
ϵ=1.0e-6,
tsim=0.1,
ctrl=(m, k)->nothing,
timestep=0.01,
gravity=[0.0; 0.0; -9.81],
verbose=false,
T=Float64,
kwargs...)
# mechanism
mechanism = DojoEnvironments.get_mechanism(model;
timestep,
gravity,
kwargs...)
Dojo.initialize!(mechanism, model)
# simulate
Dojo.simulate!(mechanism, tsim, ctrl!,
record=false,
verbose=false,
opts=Dojo.SolverOptions(rtol=ϵ, btol=ϵ))
# Finite Difference
Nd = Dojo.data_dim(mechanism,
attjac=false)
data0 = Dojo.get_data(mechanism)
sol0 = Dojo.get_solution(mechanism)
datajac0 = Dojo.finite_difference_data_jacobian(mechanism, data0, sol0)
attjac0 = Dojo.data_attitude_jacobian(mechanism)
datajac0 *= attjac0
# Analytical
D = Dojo.create_data_matrix(mechanism.joints, mechanism.bodies, mechanism.contacts)
Dojo.jacobian_data!(D, mechanism)
nodes = [mechanism.joints; mechanism.bodies; mechanism.contacts]
dimrow = length.(nodes)
dimcol = Dojo.data_dim.(nodes)
datajac1 = Dojo.full_matrix(D, false, dimrow, dimcol)
# Test
@testset "$(String(model))" begin
@test norm(datajac0 - datajac1, Inf) < 1.0e-6
end
return nothing
end
################################################################################
# Without contact and joint limits
################################################################################
@testset "Data Jacobian without contact and limits" begin
for (springs, dampers) in [(0.0, 0.0), (2.0, 0.3)]
test_data_system(:sphere;
contact=false)
test_data_system(:block;
contact=false)
test_data_system(:block2d;
contact=false)
test_data_system(:slider;
springs, dampers)
test_data_system(:nslider;
springs, dampers)
test_data_system(:pendulum;
springs, dampers)
test_data_system(:cartpole;
springs, dampers)
test_data_system(:pendulum;
springs, dampers)
test_data_system(:hopper;
parse_springs=false,
parse_dampers=false,
springs, dampers,
contact_foot=false,
contact_body=false)
test_data_system(:humanoid;
parse_springs=false,
parse_dampers=false,
springs, dampers,
contact_feet=false)
test_data_system(:atlas;
parse_springs=false,
parse_dampers=false,
springs, dampers,
contact_feet=false,
contact_body=false)
test_data_system(:halfcheetah;
parse_springs=false,
parse_dampers=false,
contact_feet=false,
contact_body=false,
joint_limits=Dict())
test_data_system(:walker;
parse_springs=false,
parse_dampers=false,
springs, dampers,
contact_feet=false,
contact_body=false,
joint_limits=Dict())
test_data_system(:quadruped;
parse_springs=false,
parse_dampers=false,
springs, dampers,
contact_feet=false,
contact_body=false,
joint_limits=Dict())
for joint_type in joint_types
test_data_system(:snake;
num_bodies=5,
springs, dampers,
contact=false,
joint_type)
test_data_system(:twister;
num_bodies=5,
springs, dampers,
contact=false,
joint_type)
end
end
end
################################################################################
# With contact and joint limits
################################################################################
@testset "Data Jacobian with contact and limtis" begin
for (springs, dampers) in [(0.0, 0.0), (2.0, 0.3)]
test_data_system(:sphere;
contact=true)
test_data_system(:block;
contact=true)
test_data_system(:block2d;
contact=true)
test_data_system(:slider;
springs,
dampers)
test_data_system(:nslider;
springs,
dampers)
test_data_system(:pendulum;
springs,
dampers)
test_data_system(:cartpole;
springs,
dampers)
test_data_system(:pendulum;
springs,
dampers)
test_data_system(:hopper;
parse_springs=false,
parse_dampers=false,
springs,
dampers,
contact_foot=true,
contact_body=true)
test_data_system(:humanoid;
parse_springs=false,
parse_dampers=false,
springs,
dampers,
contact_feet=true)
test_data_system(:atlas;
parse_springs=false,
parse_dampers=false,
springs,
dampers,
contact_feet=true,
contact_body=true)
test_data_system(:halfcheetah;
parse_springs=false,
parse_dampers=false,
contact_feet=true,
contact_body=true)
test_data_system(:walker;
parse_springs=false,
parse_dampers=false,
springs,
dampers,
contact_feet=true,
contact_body=true)
test_data_system(:quadruped;
parse_springs=false,
parse_dampers=false,
springs,
dampers,
contact_feet=true,
contact_body=true)
for joint_type in joint_types
test_data_system(:snake;
num_bodies=5,
springs,
dampers,
contact=true,
joint_type=joint_type)
test_data_system(:twister;
num_bodies=5,
springs,
dampers,
contact=true,
joint_type=joint_type)
end
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 19626 | # Parameters
ϵ0 = 1.0e-12
timestep0 = 1.0e-2
start0 = Int(floor(1 / timestep0)) + 1
joint_types = [
:Fixed,
:Prismatic,
:Planar,
:FixedOrientation,
:Revolute,
:Cylindrical,
:PlanarAxis,
:FreeRevolute,
:Orbital,
:PrismaticOrbital,
:PlanarOrbital,
:FreeOrbital,
:Spherical,
:CylindricalFree,
:PlanarFree
]
# Controllers
function controller!(mechanism, k;
U=0.5,
timestep=timestep0)
N = Int(floor(1 / timestep))
for joint in mechanism.joints
nu = input_dimension(joint)
u = (nu <= 5 && k ∈ (1:N)) * U * sones(nu)
set_input!(joint, u)
end
return
end
nocontrol!(mechanism, k) = controller!(mechanism, k, U=0.0)
function humanoid_controller!(mechanism, k;
U=0.05,
timestep=timestep0)
N = Int(floor(1 / timestep))
for joint in mechanism.joints
nu = input_dimension(joint)
u = (nu <= 5 && k ∈ (1:N)) * U * sones(nu)
set_input!(joint, u)
end
return
end
function quadruped_controller!(mechanism, k;
U=0.05,
timestep=timestep0)
N = Int(floor(1.0 / timestep))
for joint in mechanism.joints
nu = input_dimension(joint)
u = (nu <= 5 && k ∈ (1:N)) * U * sones(nu)
set_input!(joint, u)
end
return
end
function snake_controller!(mechanism, k;
U=0.05,
timestep=timestep0)
N = Int(floor(1.0 / timestep))
for joint in mechanism.joints
nu = input_dimension(joint)
u = (nu <= 5 && k ∈ (1:N)) * U * sones(nu)
set_input!(joint, u)
end
return
end
function twister_controller!(mechanism, k;
U=0.01,
timestep=timestep0)
N = Int(floor(1.0 / timestep))
for joint in mechanism.joints
nu = input_dimension(joint)
u = (nu <= 5 && k ∈ (1:N)) * U * sones(nu)
set_input!(joint, u)
end
return
end
################################################################################
# DICE
################################################################################
# single body
# initial linear and angular velocity
# no gravity
# no spring and damper
# no control
################################################################################
@testset "Dice" begin
gravity0 = -10.0
mech = get_mechanism(:block;
timestep=timestep0,
gravity=gravity0,
contact=false)
v0 = [1,2,3.0]
ω0 = [1,1,1.0]
initialize!(mech, :block;
velocity=v0,
angular_velocity=ω0)
storage = simulate!(mech, 5.0, nocontrol!;
record=true,
verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
# With spring the error is or the order of timestep, but there is no drift
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-8
end
################################################################################
# SINGLE PENDULUM
################################################################################
# single body
# initial angular velocity
# gravity
# no damper
# no control
################################################################################
@testset "Pendulum" begin
gravity0 = 0.0
springs0 = 1.0
dampers0 = 0.0
mech = get_mechanism(:pendulum;
timestep=timestep0,
gravity=gravity0,
springs=springs0,
dampers=dampers0)
ϕ0 = 0.5π
ω0 = 0.0
initialize!(mech, :pendulum,
angle=ϕ0,
angular_velocity=ω0)
storage = simulate!(mech, 25.0, controller!,
record=true,
verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
# With spring the error is or the order of timestep, but there is no drift
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-2
end
################################################################################
# SLIDER 1
################################################################################
# single body
# no initial linear velocity
# no gravity
# no damper
# no control
################################################################################
@testset "Slider 1" begin
gravity0 = 0.0
springs0 = 10.0
dampers0 = 0.0
mech = get_mechanism(:slider;
timestep=timestep0,
gravity=gravity0,
springs=springs0,
dampers=dampers0)
z0 = 0.5
initialize!(mech, :slider;
position=z0)
# Analytical
pbody = mech.bodies[1]
zmax = z0
vmax = z0 * sqrt(springs0 / pbody.mass)
pe_max = 0.5 * springs0 * zmax^2
ke_max = 0.5 * pbody.mass * vmax^2
storage = simulate!(mech, 5.0, nocontrol!;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test maximum amplitude and velocity
@test norm(maximum([x[3] for x in storage.x[1]]) - zmax + 0.5) < 1.0e-4
@test norm(maximum([vl[3] for vl in storage.vl[1]]) - vmax) < 1.0e-4
# Test mechanical energy conservation
# With spring the error is of the order of timestep, but there is no drift
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-3
# @show norm((me0 .- me0[1]) ./ mean(me0), Inf)
end
################################################################################
# SLIDER 2
################################################################################
# single body
# no initial linear velocity
# gravity
# no damper
# no control
################################################################################
@testset "Slider 2" begin
gravity0 = -9.81
springs0 = 0.0
dampers0 = 0.0
mech = get_mechanism(:slider;
timestep=timestep0,
gravity=gravity0,
springs=springs0,
dampers=dampers0)
z0 = 0.5
initialize!(mech, :slider,
position=z0)
storage = simulate!(mech, 1.5, nocontrol!,
record=true,
verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
# For gravity the conservation is perfect
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-6
end
################################################################################
# SLIDER 3
################################################################################
# single body
# no initial linear velocity
# gravity
# no damper
# no control
################################################################################
@testset "Slider 3" begin
gravity0 = -9.81
springs0 = 1.0
dampers0 = 0.0
mech = get_mechanism(:slider;
timestep=timestep0,
gravity=gravity0,
springs=springs0,
dampers=dampers0)
z0 = 0.1
initialize!(mech, :slider;
position=z0)
storage = simulate!(mech, 10.0, nocontrol!;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[start0])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[start0])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[start0])
# Test mechanical energy conservation
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-3
end
################################################################################
# HUMANOID
################################################################################
# multiple bodies
# initial linear and angular velocity
# no gravity
# with spring and damper
# with control
################################################################################
@testset "Humanoid" begin
gravity0 = 0.0
springs0 = 1.0
dampers0 = 0.0
mech = get_mechanism(:humanoid;
timestep=timestep0,
gravity=gravity0,
parse_springs=false,
parse_dampers=false,
springs=springs0,
dampers=dampers0,
contact_feet=false)
initialize!(mech, :humanoid)
bodies = mech.bodies
for body in mech.bodies
set_maximal_velocities!(body,
ω=0.5 * rand(3))
# set_maximal_velocities!(body, v=1.0 * rand(3))
end
for joint in mech.joints
joint.rotational.spring_type = :linear
end
storage = simulate!(mech, 3.0, humanoid_controller!;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 2.0e-3
end
################################################################################
# ATLAS
################################################################################
# multiple bodies
# initial linear and angular velocity
# no gravity
# with spring and damper
# with control
################################################################################
@testset "Atlas" begin
gravity0 = 0.0
springs0 = 1.0
dampers0 = 0.0
mech = get_mechanism(:atlas;
timestep=timestep0,
gravity=gravity0,
parse_springs=false,
parse_dampers=false,
springs=springs0,
contact_feet=false,
contact_body=false)
initialize!(mech, :atlas)
bodies = mech.bodies
set_maximal_velocities!.(bodies,
ω=1.0 * rand(3))
storage = simulate!(mech, 5.0, humanoid_controller!;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 3.0e-3
end
################################################################################
# QUADRUPED
################################################################################
# multiple bodies
# initial linear and angular velocity
# no gravity
# with spring and damper
# with control
################################################################################
@testset "Quadruped" begin
gravity0 = 0.0
springs0 = 1.0
dampers0 = 0.0
mech = get_mechanism(:quadruped;
timestep=timestep0,
gravity=gravity0,
parse_springs=false,
parse_dampers=false,
springs=springs0,
contact_feet=false,
contact_body=false,
joint_limits=Dict())
initialize!(mech, :quadruped)
storage = simulate!(mech, 5.0;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-2
end
# TODO Removed due to change in mechanism in DojoEnvironments. Test could be adjusted
# ################################################################################
# # 5-LINK SNAKE
# ################################################################################
# # multiple bodies
# # initial linear and angular velocity
# # no gravity
# # with spring and damper
# # with control
# ################################################################################
# @testset "Snake" begin
# Nb0 = 5
# gravity0 = 0.0
# springs0 = 0.01
# dampers0 = 0.0
# mech = get_mechanism(:snake;
# timestep=timestep0,
# gravity=gravity0,
# num_bodies=Nb0,
# springs=springs0,
# dampers=dampers0,
# joint_type=:Revolute,
# contact=false,
# radius=0.05);
# v0 = 10.0 * [1, 2, 3] * timestep0
# ω0 = 10.0 * [1, 2, 3] * timestep0
# q10 = Dojo.RotX(0.5*π)
# initialize!(mech, :snake,
# base_orientation=q10,
# base_linear_velocity=v0,
# base_angular_velocity=ω0)
# storage = simulate!(mech, 3.0, snake_controller!;
# record=true, verbose=false,
# opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# # visualize(mech, storage, vis=vis)
# ke0 = kinetic_energy(mech, storage)[start0:end]
# pe0 = potential_energy(mech, storage)[start0:end]
# me0 = mechanical_energy(mech, storage)[start0:end]
# # plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# # plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# # plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# # Test mechanical energy conservation
# @test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-3
# for joint_type in joint_types
# # @show joint_type
# mech = get_mechanism(:snake;
# timestep=timestep0,
# gravity=gravity0,
# num_bodies=Nb0,
# springs=springs0,
# dampers=dampers0,
# joint_type=joint_type,
# contact=false,
# radius=0.05)
# v0 = 10.0 * [1, 2, 3] * timestep0
# ω0 = 10.0 * [1, 2, 3] * timestep0
# q10 = Dojo.RotX(0.5*π)
# initialize!(mech, :snake;
# base_orientation=q10,
# base_linear_velocity=v0,
# base_angular_velocity=ω0)
# storage = simulate!(mech, 3.0, snake_controller!;
# record=true, verbose=false,
# opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# # visualize(mech, storage, vis=vis)
# ke0 = kinetic_energy(mech, storage)[start0:end]
# pe0 = potential_energy(mech, storage)[start0:end]
# me0 = mechanical_energy(mech, storage)[start0:end]
# # plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# # plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# # plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# # Test mechanical energy conservation
# @test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-2
# norm((me0 .- me0[1]) ./ mean(me0), Inf)
# end
# end
################################################################################
# 5-lINK TWISTER
################################################################################
# multiple bodies
# initial linear and angular velocity
# no gravity
# with spring and damper
# with control
################################################################################
@testset "Twister" begin
Nb0 = 5
gravity0 = 0.0
springs0 = 0.01
dampers0 = 0.0
mech = get_mechanism(:twister;
timestep=timestep0,
gravity=gravity0,
num_bodies=Nb0,
springs=springs0,
dampers=dampers0,
joint_type=:Revolute,
contact=false,
radius=0.05);
v0 = 10.0 * [1, 2, 3] * timestep0
ω0 = 10.0 * [1, 2, 3] * timestep0
q10 = Dojo.RotX(0.5*π)
initialize!(mech, :twister,
base_orientation=q10,
base_linear_velocity=v0,
base_angular_velocity=ω0)
storage = simulate!(mech, 3.0, twister_controller!;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-3
for joint_type in joint_types
mech = get_mechanism(:twister;
timestep=timestep0,
gravity=gravity0,
num_bodies=Nb0,
springs=springs0,
dampers=dampers0,
joint_type=joint_type,
contact=false,
radius=0.05)
v0 = 10.0 * [1, 2, 3] * timestep0
ω0 = 10.0 * [1, 2, 3] * timestep0
q10 = Dojo.RotX(0.5*π)
initialize!(mech, :twister;
base_orientation=q10,
base_linear_velocity=v0,
base_angular_velocity=ω0)
storage = simulate!(mech, 3.0, snake_controller!;
record=true, verbose=false,
opts=SolverOptions(rtol=ϵ0, btol=ϵ0))
# visualize(mech, storage, vis=vis)
ke0 = kinetic_energy(mech, storage)[start0:end]
pe0 = potential_energy(mech, storage)[start0:end]
me0 = mechanical_energy(mech, storage)[start0:end]
# plot([(i-1) * timestep0 for i in 1:length(ke0)], ke0 .- ke0[1])
# plot([(i-1) * timestep0 for i in 1:length(pe0)], pe0 .- pe0[1])
# plot([(i-1) * timestep0 for i in 1:length(me0)], me0 .- me0[1])
# Test mechanical energy conservation
@test norm((me0 .- me0[1]) ./ mean(me0), Inf) < 1.0e-2
norm((me0 .- me0[1]) ./ mean(me0), Inf)
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 11647 | ################################################################################
# Displacement Jacobian
################################################################################
@testset "Displacement Jacobian" begin
@testset "Rotational" begin
mech = DojoEnvironments.get_mechanism(:pendulum)
joint0 = mech.joints[1]
rot0 = joint0.rotational
rot0.orientation_offset = rand(QuatRotation).q
xa = rand(3)
qa = rand(QuatRotation).q
xb = rand(3)
qb = rand(QuatRotation).q
# displacement_jacobian_configuration
X0, Q0 = Dojo.displacement_jacobian_configuration(:parent, rot0, xa, qa, xb, qb,
attjac=true)
J0 = [X0 Q0]
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = ForwardDiff.jacobian(
z -> Dojo.displacement(rot0, z[1:3], Quaternion(z[4:7]...), xb, qb),
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-8
# displacement_jacobian_configuration
X0, Q0 = Dojo.displacement_jacobian_configuration(:child, rot0, xa, qa, xb, qb,
attjac=true)
J0 = [X0 Q0]
attjac = cat(I(3),Dojo.LVᵀmat(qb), dims=(1,2))
J1 = ForwardDiff.jacobian(
z -> Dojo.displacement(rot0, xa, qa, z[1:3], Quaternion(z[4:7]...)),
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-8
end
@testset "Translational" begin
mech = DojoEnvironments.get_mechanism(:slider)
joint0 = mech.joints[1]
tra0 = joint0.translational
xa = rand(3)
qa = rand(QuatRotation).q
xb = rand(3)
qb = rand(QuatRotation).q
# displacement_jacobian_configuration
X0, Q0 = Dojo.displacement_jacobian_configuration(:parent, tra0, xa, qa, xb, qb,
attjac=true)
J0 = [X0 Q0]
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = ForwardDiff.jacobian(
z -> Dojo.displacement(tra0, z[1:3], Quaternion(z[4:7]...), xb, qb),
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-8
# displacement_jacobian_configuration
X0, Q0 = Dojo.displacement_jacobian_configuration(:child, tra0, xa, qa, xb, qb,
attjac=true)
J0 = [X0 Q0]
attjac = cat(I(3),Dojo.LVᵀmat(qb), dims=(1,2))
J1 = ForwardDiff.jacobian(
z -> Dojo.displacement(tra0, xa, qa, z[1:3], Quaternion(z[4:7]...)),
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-8
end
end
################################################################################
# Impulse transform Jacobian
################################################################################
@testset "Impulse transform Jacobian: rotational" begin
@testset "Rotational" begin
mech = DojoEnvironments.get_mechanism(:pendulum)
joint0 = mech.joints[1]
rot0 = joint0.rotational
rot0.orientation_offset = rand(QuatRotation).q
xa = rand(3)
qa = rand(QuatRotation).q
xb = rand(3)
qb = rand(QuatRotation).q
p0 = rand(3)
J0 = Dojo.impulse_transform_jacobian(:parent, :parent, rot0, xa, qa, xb, qb, p0)
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:parent, rot0, z[1:3], Quaternion(z[4:7]...), xb, qb) * p0,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
J0 = Dojo.impulse_transform_jacobian(:parent, :child, rot0, xa, qa, xb, qb, p0)
attjac = cat(I(3),Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:parent, rot0, xa, qa, z[1:3], Quaternion(z[4:7]...)) * p0,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
J0 = Dojo.impulse_transform_jacobian(:child, :parent, rot0, xa, qa, xb, qb, p0)
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:child, rot0, z[1:3], Quaternion(z[4:7]...), xb, qb) * p0,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
J0 = Dojo.impulse_transform_jacobian(:child, :child, rot0, xa, qa, xb, qb, p0)
attjac = cat(I(3),Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:child, rot0, xa, qa, z[1:3], Quaternion(z[4:7]...)) * p0,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
end
@testset "Translational" begin
mech = DojoEnvironments.get_mechanism(:slider)
joint0 = mech.joints[1]
tra0 = joint0.translational
xa = rand(3)
qa = rand(QuatRotation).q
xb = rand(3)
qb = rand(QuatRotation).q
p0 = rand(3)
J0 = Dojo.impulse_transform_jacobian(:parent, :parent, tra0, xa, qa, xb, qb, p0)
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:parent, tra0, z[1:3], Quaternion(z[4:7]...), xb, qb) * p0,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
J0 = Dojo.impulse_transform_jacobian(:parent, :child, tra0, xa, qa, xb, qb, p0)
attjac = cat(I(3), Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:parent, tra0, xa, qa, z[1:3], Quaternion(z[4:7]...)) * p0,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
J0 = Dojo.impulse_transform_jacobian(:child, :parent, tra0, xa, qa, xb, qb, p0)
attjac = cat(I(3), Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:child, tra0, z[1:3], Quaternion(z[4:7]...), xb, qb) * p0,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
J0 = Dojo.impulse_transform_jacobian(:child, :child, tra0, xa, qa, xb, qb, p0)
attjac = cat(I(3),Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_transform(:child, tra0, xa, qa, z[1:3], Quaternion(z[4:7]...)) * p0,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
end
end
################################################################################
# Impulse map Jacobian
################################################################################
@testset "Impulse map" begin
@testset "impulse map: rotational" begin
mech = DojoEnvironments.get_mechanism(:pendulum)
joint0 = mech.joints[1]
rot0 = joint0.rotational
rot0.orientation_offset = rand(QuatRotation).q
xa = rand(3)
qa = rand(QuatRotation).q
xb = rand(3)
qb = rand(QuatRotation).q
λ = rand(2)
η = rand(0)
Dojo.impulse_map(:parent, rot0, xa, qa, xb, qb, η)
Dojo.impulse_map(:child, rot0, xa, qa, xb, qb, η)
m = 1.0
J = I(3)
pbody = Body(m, J)
cbody = Body(m, J)
pbody.state.x2 = xa
pbody.state.q2 = qa
cbody.state.x2 = xb
cbody.state.q2 = qb
# impulse_map_parent_jacobian_parent
J0 = Dojo.impulse_map_jacobian(:parent, :parent, rot0, pbody, cbody, λ)
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:parent, rot0, z[1:3], Quaternion(z[4:7]...), xb, qb, 0) * λ,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
# impulse_map_parent_jacobian_child
J0 = Dojo.impulse_map_jacobian(:parent, :child, rot0, pbody, cbody, λ)
attjac = cat(I(3), Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:parent, rot0, xa, qa, z[1:3], Quaternion(z[4:7]...), 0) * λ,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
# impulse_map_child_jacobian_parent
J0 = Dojo.impulse_map_jacobian(:child, :parent, rot0, pbody, cbody, λ)
attjac = cat(I(3), Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:child, rot0, z[1:3], Quaternion(z[4:7]...), xb, qb, 0) * λ,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
# impulse_map_child_jacobian_child
J0 = Dojo.impulse_map_jacobian(:child, :child, rot0, pbody, cbody, λ)
attjac = cat(I(3), Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:child, rot0, xa, qa, z[1:3], Quaternion(z[4:7]...), 0) * λ,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
end
@testset "Translational" begin
mech = get_mechanism(:pendulum)
joint0 = mech.joints[1]
tra0 = joint0.translational
xa = rand(3)
qa = rand(QuatRotation).q
xb = rand(3)
qb = rand(QuatRotation).q
λ = rand(3)
η = rand(0)
Dojo.impulse_map(:parent, tra0, xa, qa, xb, qb, η)
Dojo.impulse_map(:child, tra0, xa, qa, xb, qb, η)
m = 1.0
J = I(3)
pbody = Body(m, J)
cbody = Body(m, J)
pbody.state.x2 = xa
pbody.state.q2 = qa
cbody.state.x2 = xb
cbody.state.q2 = qb
# impulse_map_parent_jacobian_parent
J0 = Dojo.impulse_map_jacobian(:parent, :parent, tra0, pbody, cbody, λ)
attjac = cat(I(3),Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:parent, tra0, z[1:3], Quaternion(z[4:7]...), xb, qb, 0) * λ,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
# impulse_map_parent_jacobian_child
J0 = Dojo.impulse_map_jacobian(:parent, :child, tra0, pbody, cbody, λ)
attjac = cat(I(3), Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:parent, tra0, xa, qa, z[1:3], Quaternion(z[4:7]...), 0) * λ,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
# impulse_map_child_jacobian_parent
J0 = Dojo.impulse_map_jacobian(:child, :parent, tra0, pbody, cbody, λ)
attjac = cat(I(3), Dojo.LVᵀmat(qa), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:child, tra0, z[1:3], Quaternion(z[4:7]...), xb, qb, 0) * λ,
[xa; Dojo.vector(qa)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
# impulse_map_child_jacobian_child
J0 = Dojo.impulse_map_jacobian(:child, :child, tra0, pbody, cbody, λ)
attjac = cat(I(3), Dojo.LVᵀmat(qb), dims=(1,2))
J1 = FiniteDiff.finite_difference_jacobian(
z -> Dojo.impulse_map(:child, tra0, xa, qa, z[1:3], Quaternion(z[4:7]...), 0) * λ,
[xb; Dojo.vector(qb)]
) * attjac
@test norm(J0 - J1, Inf) < 1.0e-6
end
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 1982 | @testset "ForwardDiff comparison" begin
Random.seed!(100)
x0 = srand(3)
v0 = srand(3)
q0 = rand(QuatRotation).q
ω0 = srand(3)
timestep0 = 0.01
x1 = Dojo.next_position(x0, v0, timestep0)
q1 = Dojo.next_orientation(q0, ω0, timestep0)
# ∇v
FD∂i∂v = ForwardDiff.jacobian(v0 -> Dojo.next_position(x0, v0, timestep0), v0)
@test norm(FD∂i∂v - Dojo.linear_integrator_jacobian_velocity(x0, v0, timestep0), Inf) < 1.0e-8
# ∇ω
FD∂i∂ω = ForwardDiff.jacobian(ω0 -> Dojo.vector(Dojo.next_orientation(q0, ω0, timestep0)), ω0)
@test norm(FD∂i∂ω - Dojo.rotational_integrator_jacobian_velocity(q0, ω0, timestep0), Inf) < 1.0e-8
# ∇x
FD∂i∂x = ForwardDiff.jacobian(x0 -> Dojo.next_position(x0, v0, timestep0), x0)
@test norm(FD∂i∂x - Dojo.linear_integrator_jacobian_position(x0, v0, timestep0), Inf) < 1.0e-8
# ∇q
FD∂i∂q = ForwardDiff.jacobian(q0 ->
Dojo.vector(Dojo.next_orientation(Quaternion(q0...), ω0, timestep0)),
Dojo.vector(q0))
@test norm(FD∂i∂q - Dojo.rotational_integrator_jacobian_orientation(q0, ω0, timestep0, attjac=false), Inf) < 1.0e-8
# ∇vω
vel0 = [v0; ω0]
FDvel = ForwardDiff.jacobian(vel0 ->
[Dojo.next_position(x0, SVector{3}(vel0[1:3]), timestep0);
Dojo.vector(Dojo.next_orientation(q0, SVector{3}(vel0[4:6]), timestep0))], vel0)
@test norm(FDvel - Dojo.integrator_jacobian_velocity(x0, v0, q0, ω0, timestep0), Inf) < 1.0e-8
# ∇xq
con0 = [x0; Dojo.vector(q0)]
FDcon = ForwardDiff.jacobian(con0 ->
[Dojo.next_position(SVector{3}(con0[1:3]), v0, timestep0);
Dojo.vector(Dojo.next_orientation(Quaternion(con0[4:7]...), ω0, timestep0))], con0)
@test norm(FDcon - Dojo.integrator_jacobian_configuration(x0, v0, q0, ω0, timestep0, attjac=false), Inf) < 1.0e-8
@test norm(FDcon * cat(I(3), Dojo.LVᵀmat(q0), dims=(1,2)) - Dojo.integrator_jacobian_configuration(x0, v0, q0, ω0, timestep0, attjac=true), Inf) < 1.0e-8
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 5626 | function test_solmat(model;
ϵ=1.0e-6,
tsim=0.1,
ctrl=(m, k)->nothing,
timestep=0.01,
gravity=[0.0; 0.0; -9.81],
verbose=false,
T=Float64,
kwargs...)
@testset "$(string(model))" begin
# mechanism
mechanism = get_mechanism(model;
timestep,
gravity,
kwargs...)
initialize!(mechanism, model)
# simulate
storage = simulate!(mechanism, tsim, ctrl,
record=true,
verbose=verbose,
opts=SolverOptions(rtol=ϵ, btol=ϵ))
# Set data
Nb = length(mechanism.bodies)
data = Dojo.get_data(mechanism)
Dojo.set_data!(mechanism, data)
sol = Dojo.get_solution(mechanism)
attjac = Dojo.attitude_jacobian(data, Nb)
# IFT
solmat = Dojo.full_matrix(mechanism.system)
# finite diff
fd_solmat = finite_difference_solution_matrix(mechanism, data, sol,
δ=1.0e-5,
verbose=verbose)
@test norm(fd_solmat + solmat, Inf) < ϵ
end
return nothing
end
function finite_difference_solution_matrix(mechanism::Mechanism, data::AbstractVector, sol::AbstractVector;
δ=1.0e-8,
verbose=false)
nsol = length(sol)
jac = zeros(nsol, nsol)
Dojo.set_data!(mechanism, data)
Dojo.set_solution!(mechanism, sol)
for i = 1:nsol
verbose && println("$i / $nsol")
solp = deepcopy(sol)
solm = deepcopy(sol)
solp[i] += δ
solm[i] -= δ
rp = Dojo.evaluate_residual!(deepcopy(mechanism), data, solp)
rm = Dojo.evaluate_residual!(deepcopy(mechanism), data, solm)
jac[:, i] = (rp - rm) / (2δ)
end
return jac
end
function control!(mechanism, k;
u=0.1)
for joint in mechanism.joints
nu = Dojo.input_dimension(joint,
ignore_floating_base=false)
su = u * sones(nu)
Dojo.set_input!(joint, su)
end
end
#TODO: decrease ϵ tolerance once we replace finite-difference methods
# Flying after 0.1 sec simulation
@testset "Flying" begin
tsim = 0.1
test_solmat(:atlas, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, parse_dampers=false)
test_solmat(:atlas, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, parse_dampers=false)
test_solmat(:atlas, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, parse_springs=false, parse_dampers=false, springs=1e3, dampers=5e2)
test_solmat(:quadruped, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, parse_springs=false, parse_dampers=false, springs=1.0, dampers=0.2)
test_solmat(:block, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
test_solmat(:snake, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:slider, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:pendulum, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:npendulum, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:nslider, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:twister, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, contact_type=:nonlinear)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, contact_type=:linear)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, contact_type=:impact)
test_solmat(:ant, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
test_solmat(:halfcheetah,tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
end
# In contact with the ground after 0.4 sec simulation
@testset "In contact" begin
tsim = 0.4
test_solmat(:atlas, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
test_solmat(:atlas, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, parse_springs=false, parse_dampers=false, springs=1e3, dampers=5e2)
test_solmat(:quadruped, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, parse_springs=false, parse_dampers=false, springs=1.0, dampers=0.2)
test_solmat(:block, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
test_solmat(:snake, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:slider, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:pendulum, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:npendulum, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:nslider, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:twister, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, springs=1.0, dampers=0.2)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, contact_type=:nonlinear)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, contact_type=:linear)
test_solmat(:sphere, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7, contact_type=:impact)
test_solmat(:ant, tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
test_solmat(:halfcheetah,tsim=tsim, ctrl=(m,k)->control!(m,k,u=0.1), ϵ=1.0e-7)
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 471 | @testset "Pendulum" begin
mech = get_mechanism(:pendulum;
timestep=0.01,
gravity=-9.81,
springs=0.0,
dampers=0.0,
joint_limits=Dict([
(:joint, [0.25 * π, 1.0 * π]),])
)
initialize!(mech, :pendulum;
angle=0.4 * π)
storage = simulate!(mech, 1.0;
record=true,
opts=SolverOptions(btol=1.0e-5, rtol=1.0e-5))
@test norm(Dojo.get_minimal_state(mech)[1] - 0.25 * π) < 1.0e-3
end
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
|
[
"MIT"
] | 0.7.5 | 104b6a1a358da9b1348ab7cd66ad685ecaca13d4 | code | 5436 | @testset "Pendulum" begin
# get pendulum mechanism and simulate
timestep=0.1
mechanism = DojoEnvironments.get_mechanism(:pendulum;
timestep, gravity=-10.0);
DojoEnvironments.initialize!(mechanism, :pendulum; angle=0.25 * π)
u1 = rand(Dojo.input_dimension(mechanism))
z1 = Dojo.get_maximal_state(mechanism)
storage = Dojo.simulate!(mechanism, 1.0; record=true)
@test norm(z1 - Dojo.get_maximal_state(storage, 1)) < 1.0e-6
zTs = Dojo.get_maximal_state(mechanism)
@test norm(zTs - Dojo.get_maximal_state(storage, Dojo.length(storage))) < 1.0e-6
zT = Dojo.get_next_state(mechanism)
DojoEnvironments.initialize!(mechanism, :pendulum; angle=0.25 * π)
storage = Dojo.simulate!(mechanism, 1.0 + timestep; record=true)
@test norm(zT - Dojo.get_maximal_state(storage, Dojo.length(storage))) < 1.0e-6
# maximal gradients
Dojo.step!(mechanism, z1, u1)
Fx1, Fu1 = Dojo.get_maximal_gradients(mechanism)
Fx2, Fu2 = Dojo.get_maximal_gradients!(mechanism, z1, u1)
@test norm(Fx1 - Fx2, Inf) < 1.0e-6
@test norm(Fu1 - Fu2, Inf) < 1.0e-6
timestep=0.1
mechanism = DojoEnvironments.get_mechanism(:halfcheetah;
timestep, gravity=-10.0);
# get body
@test Dojo.get_body(mechanism, :origin).name == :base
# get contact
contact_name = mechanism.contacts[1].name
@test Dojo.get_contact(mechanism, contact_name).name == contact_name
# velocity indices
@test Dojo.velocity_index(mechanism) == [4, 5, 6, 8, 10, 12, 14, 16, 18]
# set state
z = Dojo.get_maximal_state(mechanism)
mechanism = DojoEnvironments.get_mechanism(:halfcheetah;
timestep, gravity=-10.0);
Dojo.set_maximal_state!(mechanism, zeros(Dojo.maximal_dimension(mechanism)))
z2 = Dojo.get_maximal_state(mechanism)
@test norm(z2) < 1.0e-8
Dojo.set_maximal_state!(mechanism, z)
@test norm(z - Dojo.get_maximal_state(mechanism)) < 1.0e-8
# change atlas floating base
mechanism = get_mechanism(:atlas; parse_dampers=false)
j = get_joint(mechanism, :floating_base)
base_origin = get_body(mechanism, j.child_id).name
mechanism = set_floating_base(mechanism, :head)
j = get_joint(mechanism, :floating_base)
base_new = get_body(mechanism, j.child_id).name
@test base_origin != base_new
@test base_new == :head
end
@testset "Remove fixed joints" begin
origin = Origin()
box1 = Box(0.1,0.1,0.5,0.5;color=RGBA(0.8,0.8,0.8,0.5))
box2 = Box(0.1,0.1,0.5,0.5;color=RGBA(0.8,0.8,0.8,0.5))
box3 = Box(0.1,0.1,0.5,0.5;color=RGBA(1,1,0,0.5))
box4 = Box(0.1,0.1,0.5,0.5;color=RGBA(1,0,1,0.5))
joint1 = JointConstraint(Revolute(origin, box1, [1;0;0], child_vertex = [0;0;0.25]))
joint2 = JointConstraint(Fixed(box1, box2; parent_vertex = [0;0;-0.25], child_vertex = [0;0;0.25], orientation_offset = Dojo.RotY(pi/2)))
joint3 = JointConstraint(Revolute(origin, box3, [1;0;0], child_vertex = [0;0;0.25]))
joint4 = JointConstraint(Fixed(box3, box4; parent_vertex = [0;0;-0.25], child_vertex = [0;0;0.25], orientation_offset = Dojo.RotY(pi/2)))
mechanism = Mechanism(origin, [box1;box2;box3;box4], [joint1;joint2;joint3;joint4])
origin, bodies, joints = Dojo.reduce_fixed_joints(mechanism.origin,mechanism.bodies,mechanism.joints)
box1 = Box(0.1,0.1,0.5,0.5;color=RGBA(0.8,0.8,0.8,0.5))
box2 = Box(0.1,0.1,0.5,0.5;color=RGBA(0.8,0.8,0.8,0.5))
joint1 = JointConstraint(Revolute(origin, box1, [1;0;0]; child_vertex = [0;0;0.25]))
joint2 = JointConstraint(Fixed(box1, box2; parent_vertex = [0;0;-0.25], child_vertex = [0;0;0.25], orientation_offset = Dojo.RotY(pi/2)))
mechanism = Mechanism(origin, [box1,box2,bodies[2]], [joint1,joint2,joints[2]]; gravity = -9.81, timestep = 0.01)
Dojo.zero_coordinates!(mechanism)
set_minimal_coordinates!(mechanism,joint1,[pi/2])
set_minimal_coordinates!(mechanism,joints[2],[pi/2])
storage = simulate!(mechanism, 5.0; record = true)
@test abs(storage.q[3][end].v1 - storage.q[1][end].v1) < 1.0e-5
end
@testset "Force and impulse input" begin
timestep = 0.01
# Force input, default scaling
origin0 = Origin()
box0 = Box(1.0,1,1,1)
joint0 = JointConstraint(Floating(origin0,box0))
mech0 = Mechanism(origin0, [box0], [joint0]; gravity = -9.81, timestep)
controller0!(mechanism, k) = set_input!(mechanism, [0;0;9.81;0;0;0])
storage0 = simulate!(mech0, 10.0, controller0!; record = true)
# Force input, default scaling explicitly set
origin1 = Origin()
box1 = Box(1.0,1,1,1)
joint1 = JointConstraint(Floating(origin1,box1))
mech1 = Mechanism(origin1, [box1], [joint1]; gravity = -9.81, timestep, input_scaling = timestep)
controller1!(mechanism, k) = set_input!(mechanism, [0;0;9.81;0;0;0])
storage1 = simulate!(mech1, 10.0, controller1!; record = true)
# Impulse input, input scaled by timestep
origin2 = Origin()
box2 = Box(1.0,1,1,1)
joint2 = JointConstraint(Floating(origin2,box2))
mech2 = Mechanism(origin2, [box2], [joint2]; gravity = -9.81, timestep, input_scaling = 1)
controller2!(mechanism, k) = set_input!(mechanism, [0;0;9.81*timestep;0;0;0])
storage2 = simulate!(mech2, 10.0, controller2!; record = true)
@test norm(storage0.x[1][end] - storage1.x[1][end]) < 1.0e-5
@test norm(storage1.x[1][end] - storage2.x[1][end]) < 1.0e-5
end
#TODO: get and set methods
| Dojo | https://github.com/dojo-sim/Dojo.jl.git |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.