Merge pull request #57 from JuliaSpaceMissionDesign/dev

v2.1.0

Author: andreapasquale94

Project.toml

@@ -1,7 +1,7 @@
 name = "FrameTransformations"
 uuid = "5be70612-1674-42c4-a038-c376b6dc81ed"
 authors = ["JSMD Team"]
-version = "2.0.0"
+version = "2.1.0"
 
 [deps]
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
@@ -11,7 +11,6 @@ IERSConventions = "4e86e20e-879b-40dc-9e12-cee74f4cd199"
 JSMDInterfaces = "6b30ee2f-618e-4a15-bf4e-7df7b496e609"
 JSMDUtils = "67801824-9821-48b9-a814-9bfb19231086"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 ReferenceFrameRotations = "74f56ac7-18b3-5285-802d-d4bd4f104033"
 SMDGraphs = "b792745b-7241-45be-ba96-70eb67e8468f"

ext/CalcephEphemerisExt.jl

@@ -2,10 +2,13 @@ module CalcephEphemerisExt
 
 import FrameTransformations: add_point_ephemeris!
 using FrameTransformations: FrameSystem, add_point!, check_point_ephemeris, 
-                            FramePointFunctions, POINT_CLASSID_DYNAMIC
+                            FramePointFunctions, POINT_CLASSID_DYNAMIC,
+                            SVectorNT
 using JSMDInterfaces.Ephemeris: ephem_compute!    
 using CalcephEphemeris: CalcephProvider
 
+using StaticArrays
+
 function add_point_ephemeris!(
     frames::FrameSystem{O, N}, eph::CalcephProvider, name::Symbol, id::Int
 ) where {O, N}

src/Core/direction.jl src/Core/directions.jlsrc/Core/direction.jl renamed to src/Core/directions.jl

@@ -1,17 +1,18 @@
 
 """
-    add_direction!(frames, name::Symbol, funs)
+    add_direction!(frames, name::Symbol, axesid, funs)
 
 Add a new direction node to `frames`.
 
 ### Inputs 
 - `frames` -- Target frame system 
 - `name` -- Direction name, must be unique within `frames` 
+- `axesid` -- ID of the axes the direction is expressed in
 - `funs` -- `DirectionFunctions` object storing the functions to compute the direction and, 
             eventually, its time derivatives. It must match the type and order of `frames`.
 """
 function add_direction!(
-    frames::FrameSystem{O, N}, name::Symbol, funs::DirectionFunctions{O, N}
+    frames::FrameSystem{O, N}, name::Symbol, axesid::Int, funs::DirectionFunctions{O, N}
 ) where {O, N <: Number}
     if name in directions(frames)
         throw(
@@ -21,13 +22,13 @@ function add_direction!(
         )
     end
 
-    dir = Direction{O, N}(name, length(directions(frames))+1, funs)
+    dir = Direction{O, N}(name, length(directions(frames))+1, axesid, funs)
     push!(directions_map(frames), Pair(name, dir))
     nothing
 end
 
 """
-    add_direction!(frames, name::Symbol, fun, δfun=nothing, δ²fun=nothing, δ³fun=nothing)
+    add_direction!(frames, name::Symbol, axes, fun, δfun=nothing, δ²fun=nothing, δ³fun=nothing)
 
 Add a new direction node to `frames`. The orientation of these direction depends only 
 on time and is computed through the custom functions provided by the user. 
@@ -46,7 +47,7 @@ If `δfun`, `δ²fun` or `δ³fun` are not provided, they are computed via autom
     function does not perform any checks on the output types. 
 """
 function add_direction!(
-    frames::FrameSystem{O, N}, name::Symbol, fun::Function, 
+    frames::FrameSystem{O, N}, name::Symbol, ax, fun::Function, 
     δfun = nothing, δ²fun = nothing, δ³fun = nothing
 ) where {O, N}
 
@@ -98,16 +99,16 @@ function add_direction!(
             t -> SVectorNT{3O, N}(δ³fun(t))
         end,
     )
-    return add_direction!(frames, name, funs)
+    return add_direction!(frames, name, axes_id(frames, ax), funs)
 end
 
 """
-    add_direction_fixed!(frames, name, offset::AbstractVector)
+    add_direction_fixed!(frames, name, axes, offset::AbstractVector)
 
 Add a fixed direction to `frames`.
 """
 function add_direction_fixed!(
-    frames::FrameSystem{O, N}, name::Symbol, offset::AbstractVector{T}
+    frames::FrameSystem{O, N}, name::Symbol, ax, offset::AbstractVector{T}
 ) where {O, N, T}
 
     if length(offset) != 3
@@ -121,77 +122,75 @@ function add_direction_fixed!(
     voffset = SVectorNT{3O, N}(SVector(offset...))
     funs = DirectionFunctions{O, N}(t -> voffset, t -> voffset, t -> voffset, t -> voffset)
 
-    return add_direction!(frames, name, funs)
+    return add_direction!(frames, name, ax, funs)
 end
 
 """
-    add_direction_position!(frames, name::Symbol, origin, target, ax)
+    add_direction_position!(frames, name::Symbol, origin, target, axes)
 
-Add a direction based on the position vector from `origin` to `target` in the specified `ax`.
+Add a direction based on the position vector from `origin` to `target` in the specified `axes`.
 """
 function add_direction_position!(
-    frames::FrameSystem{O, N}, name::Symbol, from::Symbol, to::Symbol, ax::Symbol
+    frames::FrameSystem{O, N}, name::Symbol, from, to, ax
 ) where {O, N}
-    return add_direction_position!(
-        frames, name, points(frames)[from], points(frames)[to], axes(frames)[ax]
-    )
-end
 
-function add_direction_position!(
-    frames::FrameSystem{O, N}, name::Symbol, from::Int, to::Int, ax::Int
-) where {O, N}
+    fromid, toid = point_id(frames, from),  point_id(frames, to)
+    axid = axes_id(frames, ax)
 
-    for id in (from, to)
+    for id in (fromid, toid)
         !has_point(frames, id) && throw(
-            ErrorException(
+            ArgumentError(
                 "no points with id $id registered in the given frame system."
             )
         )
     end
 
-    !has_axes(frames, ax) && throw(
-        ErrorException(
+    !has_axes(frames, axid) && throw(
+        ArgumentError(
             "no axes with id $ax registered in the given frame system"
         )
     )
 
     funs = DirectionFunctions{O, N}(
-        t->SVectorNT{3O, N}(vector3(frames, from, to, ax, t)),
-        t->SVectorNT{3O, N}(vector6(frames, from, to, ax, t)),
-        t->SVectorNT{3O, N}(vector9(frames, from, to, ax, t)),
-        t->SVectorNT{3O, N}(vector12(frames, from, to, ax, t))
+        t->SVectorNT{3O, N}(vector3(frames, fromid, toid, axid, t)),
+        t->SVectorNT{3O, N}(vector6(frames, fromid, toid, axid, t)),
+        t->SVectorNT{3O, N}(vector9(frames, fromid, toid, axid, t)),
+        t->SVectorNT{3O, N}(vector12(frames, fromid, toid, axid, t))
     )
-    return add_direction!(frames, name, funs)
+    return add_direction!(frames, name, axid, funs)
 end
 
 """
-    add_direction_velocity!(frames, name::Symbol, origin, target, ax)
+    add_direction_velocity!(frames, name::Symbol, origin, target, axes)
 
-Add a direction based on the velocity vector from `origin` to `target` in the specified `ax`.
+Add a direction based on the velocity vector from `origin` to `target` in the specified `axes`.
 """
 function add_direction_velocity!(
-    frames::FrameSystem{O, N}, name::Symbol, from::Int, to::Int, ax::Int
+    frames::FrameSystem{O, N}, name::Symbol, from, to, ax
 ) where {O, N}
 
-    for id in (from, to)
+    fromid, toid = point_id(frames, from),  point_id(frames, to)
+    axid = axes_id(frames, ax)
+
+    for id in (fromid, toid)
         !has_point(frames, id) && throw(
-            ErrorException(
+            ArgumentError(
                 "no points with id $id registered in the given frame system."
             )
         )
     end
 
-    !has_axes(frames, ax) && throw(
-        ErrorException(
+    !has_axes(frames, axid) && throw(
+        ArgumentError(
             "no axes with id $ax registered in the given frame system"
         )
     )
 
-    fun  = t->SVectorNT{3O, N}(@views(vector6(frames, from, to, ax, t)[4:end]))
-    dfun = t->SVectorNT{3O, N}(@views(vector9(frames, from, to, ax, t)[4:end]))
-    ddfun= t->SVectorNT{3O, N}(@views(vector12(frames, from, to, ax, t)[4:end]))
+    fun  = t->SVectorNT{3O, N}(@views(vector6(frames, fromid, toid, axid, t)[4:end]))
+    dfun = t->SVectorNT{3O, N}(@views(vector9(frames, fromid, toid, axid, t)[4:end]))
+    ddfun= t->SVectorNT{3O, N}(@views(vector12(frames, fromid, toid, axid, t)[4:end]))
 
-    return add_direction!(frames, name, fun, dfun , ddfun)
+    return add_direction!(frames, name, axid, fun, dfun , ddfun)
 end
 
 """
@@ -200,33 +199,41 @@ end
 Add a direction as the cross product between two existing directions (i.e. `dir1` and `dir2`).
 """
 function add_direction_orthogonal!(
-    frames::FrameSystem{O, N}, name::Symbol, dir1::Symbol, dir2::Symbol
+    frames::FrameSystem{O, N}, name::Symbol, dir1::Symbol, dir2::Symbol, ax
 ) where {O, N}
 
     for d in (dir1, dir2)
         if !(d in directions(frames))
             throw(
-                ErrorException(
+                ArgumentError(
                     "no direction with name $d registered in the given frame system"
                 )
             )
         end
     end
 
+    axid = axes_id(frames, ax)
+
+    !has_axes(frames, axid) && throw(
+        ArgumentError(
+            "no axes with id $ax registered in the given frame system"
+        )
+    )
+
     fun    = t->SVectorNT{3O, N}(
-        cross3(direction3(frames, dir1, t), direction3(frames, dir2, t))
+        cross3(direction3(frames, dir1, axid, t), direction3(frames, dir2, axid, t))
     )
     dfun   = t->SVectorNT{3O, N}(
-        cross6(direction6(frames, dir1, t), direction6(frames, dir2, t))
+        cross6(direction6(frames, dir1, axid, t), direction6(frames, dir2, axid, t))
     ) 
     ddfun  = t->SVectorNT{3O, N}(
-        cross9(direction9(frames, dir1, t), direction9(frames, dir2, t))
+        cross9(direction9(frames, dir1, axid, t), direction9(frames, dir2, axid, t))
     ) 
     dddfun = t->SVectorNT{3O, N}(
-        cross12(direction12(frames, dir1, t), direction12(frames, dir2, t))
+        cross12(direction12(frames, dir1, axid, t), direction12(frames, dir2, axid, t))
     ) 
 
-    return add_direction!(frames, name, fun, dfun, ddfun, dddfun)
+    return add_direction!(frames, name, axid, fun, dfun, ddfun, dddfun)
 end
 
 """
@@ -244,27 +251,29 @@ function add_direction_normalize!(
             )
         )
     end
-    fun    = t->SVectorNT{3O, N}(unitvec(direction3(frames, dir, t)))
-    dfun   = t->SVectorNT{3O, N}(_normalize6(frames, dir, t)) 
-    ddfun  = t->SVectorNT{3O, N}(_normalize9(frames, dir, t))
-    dddfun = t->SVectorNT{3O, N}(_normalize12(frames, dir, t))
+    axid = directions_map(frames)[dir].axesid
+
+    fun    = t->SVectorNT{3O, N}(unitvec(direction3(frames, dir, axid, t)))
+    dfun   = t->SVectorNT{3O, N}(_normalize6(frames, dir, axid, t)) 
+    ddfun  = t->SVectorNT{3O, N}(_normalize9(frames, dir, axid, t))
+    dddfun = t->SVectorNT{3O, N}(_normalize12(frames, dir, axid, t))
     return add_direction!(frames, name, fun, dfun, ddfun, dddfun)
 end
 
-function _normalize6(frames, dir, t)
-    d = direction6(frames, dir, t)
+function _normalize6(frames, dir, axid, t)
+    d = direction6(frames, dir, axid, t)
     @views nd = vcat(unitvec(d[1:3]), δunitvec(d[4:6]))
     return nd
 end
 
-function _normalize9(frames, dir, t)
-    d = direction9(frames, dir, t)
+function _normalize9(frames, dir, axid, t)
+    d = direction9(frames, dir, axid, t)
     @views nd = vcat(unitvec(d[1:3]), δunitvec(d[4:6]), δ²unitvec(d[7:9]))
     return nd
 end
 
-function _normalize12(frames, dir, t)
-    d = direction12(frames, dir, t)
+function _normalize12(frames, dir, axid, t)
+    d = direction12(frames, dir, axid, t)
     @views nd = vcat(unitvec(d[1:3]), δunitvec(d[4:6]), δ²unitvec(d[7:9]), δ³unitvec(d[10:12]))
     return nd
 end

src/Core/nodes.jl

@@ -308,17 +308,18 @@ Define a new direction.
 struct Direction{O, N, D}
     name::Symbol 
     id::Int 
+    axesid::Int
 
     # internals
     f::DirectionFunctions{O, N, D}
 end
 
 function Direction{O, N}(
-    name::Symbol, id::Int, dfun::DirectionFunctions{O, N, D}
+    name::Symbol, id::Int, axesid::Int, dfun::DirectionFunctions{O, N, D}
 ) where {O, N, D}
-    return Direction{O, N, 3O}(name, id, dfun)
+    return Direction{O, N, 3O}(name, id, axesid, dfun)
 end
 
 function Base.show(io::IO, d::Direction{O, N, D}) where {O, N, D}
-    return println(io, "Direction{$O, $N}(name=$(d.name), id=$(d.id))")
+    return println(io, "Direction{$O, $N}(name=$(d.name), id=$(d.id), axesid=$(d.axesid))")
 end

src/Core/transform.jl

@@ -271,27 +271,28 @@ for (order, axfun, _axfun, pfun, _pfun, _pfwd, _pbwd, dfun) in zip(
     @eval begin 
 
         """
-            $($dfun)(frame::FrameSystem, name::Symbol, ep::Epoch) 
+            $($dfun)(frames::FrameSystem, name::Symbol, axes, ep::Epoch) 
 
-        Compute the direction vector `name` of order $(3*$order) at epoch `ep`.
+        Compute the direction vector `name` of order $(3*$order) at epoch `ep` expressed in 
+        the `axes` frame.
 
         Requires a frame system of order ≥ $($order).
         """
         @inline function ($dfun)(
-            frame::FrameSystem{<:Any,<:Any,S}, name::Symbol, ep::Epoch{S}
+            frames::FrameSystem{<:Any,<:Any,S}, name::Symbol, ax, ep::Epoch{S}
         ) where {S}
-            return $(dfun)(frame, name, j2000s(ep))
+            return $(dfun)(frames, name, j2000s(ep))
         end
 
         """
-            $($dfun)(frame::FrameSystem, name::Symbol, t::Number) 
+            $($dfun)(frames::FrameSystem, name::Symbol, axes, t::Number) 
 
         Compute the direction vector `name` of order $(3*$order) at epoch `t`, where `t` is 
         expressed in seconds since `J2000`.
 
         Requires a frame system of order ≥ $($order).
         """
-        function ($dfun)(frame::FrameSystem{O, N}, name::Symbol, t::Number) where {O, N}
+        function ($dfun)(frames::FrameSystem{O, N}, name::Symbol, ax, t::Number) where {O, N}
             if O < $order
                 throw(
                     ErrorException(
@@ -301,17 +302,27 @@ for (order, axfun, _axfun, pfun, _pfun, _pfwd, _pbwd, dfun) in zip(
                 )
             end
 
-            if !has_direction(frame, name)
+            if !has_direction(frames, name)
                 throw(
                     ErrorException(
                         "No direction with name $(name) registered in the frame system."
                     )
                 )
             end 
 
-            stv = directions_map(frame)[name].f[$order](t)
+            node = directions_map(frames)[name]
+            stv = node.f[$order](t)
             D = 3 * $order
-            @views return SA[(stv[1:D])...]
+            y = @views SA[(stv[1:D])...]
+
+            thisaxid = node.axesid 
+            axid = axes_id(frames, ax) 
+
+            if thisaxid == axid 
+                return y 
+            end
+            return ($axfun)(frames, thisaxid, axid, t) * y 
+            
         end
 
     end

src/Definitions/ephemeris.jl

@@ -40,7 +40,7 @@ function add_point_ephemeris!(
 ) where {O, N}
     records = ephem_position_records(eph) 
     for id in sort(ephem_available_points(eph))
-        !haskey(book, id) && throw(KeyError("Cannot find point with ID $id in the names book"))
+        !haskey(book, id) && @warn "Cannot find point with ID $id in the names book" continue
 
         if id == 0 
             if length(points_graph(frames).nodes) == 0