Merge pull request #422 from JuliaHealth/fix-type-piracy

Fixing issues in Julia 1.11 and Julia 1.12

.github/workflows/ci.yml → .github/workflows/CI.yml

@@ -9,7 +9,7 @@ on:
     tags: '*'
 jobs:
   ci:
-    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    if: ${{ !contains(github.event.head_commit.message, '[skip ci]') }}
     name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60

.github/workflows/nightly.yml → .github/workflows/CIPreRelease.yml

@@ -1,4 +1,4 @@
-name: Nightly
+name: PreRelease
 on:
   pull_request:
     branches:
@@ -8,17 +8,17 @@ on:
       - master
     tags: '*'
 jobs:
-  nightly:
-    if: "contains(github.event.head_commit.message, '[nightly]')"
+  prerelease:
+    if: ${{ contains( github.event.pull_request.labels.*.name, 'pre-release' ) }} 
     name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60
     strategy:
       fail-fast: false
       matrix:
         version:
-          - 'nightly' # Latest version of Julia under development (you can expect many packages not to work with this version)
-        os: [ubuntu-latest, windows-latest, macos-latest]
+          - 'pre' # Latest version of Julia under development (you can expect many packages not to work with this version)
+        os: [ubuntu-latest, windows-latest, macos-12] # macos-latest] <- M1 Mac was generating problems #386, commented for now
         arch: [x64]
         include:
           - os: ubuntu-latest

.gitignore

@@ -34,4 +34,5 @@ examples/5.koma_paper/comparison_accuracy/**/*.mrd
 examples/5.koma_paper/mrf/**/*.mrd
 examples/5.koma_paper/comparison_accuracy/**/*.mat
 examples/5.koma_paper/comparison_accuracy/**/*.h5
-!examples/5.koma_paper/Manifest.toml
+!examples/5.koma_paper/Manifest.toml
+*_w.phantom

KomaMRIBase/Project.toml

@@ -1,7 +1,7 @@
 name = "KomaMRIBase"
 uuid = "d0bc0b20-b151-4d03-b2a4-6ca51751cb9c"
 authors = ["Carlos Castillo Passi <cncastillo@uc.cl>"]
-version = "0.8.4"
+version = "0.9.0"
 
 [deps]
 Interpolations = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
@@ -19,3 +19,6 @@ Parameters = "0.12"
 Pkg = "1.4"
 Reexport = "1"
 julia = "1.9"
+
+[workspace]
+projects = ["test"]

KomaMRIBase/src/datatypes/Sequence.jl

@@ -154,8 +154,7 @@ Tells if the sequence `seq` has elements with ADC active, or active during time
 is_ADC_on(x::Sequence) = any(x-> x > 0, x.ADC.N)
 is_ADC_on(x::Sequence, t::AbstractVecOrMat) = begin
 	N = length(x)
-	ΔT = durs(x)
-	ts = cumsum([0 ; ΔT[1:end-1]])
+	ts = get_block_start_times(x)[1:end-1]
 	delays = x.ADC.delay
 	Ts = 	 x.ADC.dur #delat+T
 	t0s = ts .+ delays
@@ -184,8 +183,7 @@ Tells if the sequence `seq` has elements with RF active, or active during time `
 is_RF_on(x::Sequence) = any([sum(abs.(r.A)) for r = x.RF] .> 0)
 is_RF_on(x::Sequence, t::AbstractVector) = begin
 	N = length(x)
-	ΔT = durs(x)
-	ts = cumsum([0 ; ΔT[1:end-1]])
+	ts = get_block_start_times(x)[1:end-1]
 	delays = x.RF.delay
 	Ts = 	 x.RF.dur #dur = delat+T
 	t0s = ts .+ delays
@@ -263,26 +261,6 @@ Tells if the sequence `seq` is a delay.
 """
 is_Delay(x::Sequence) = !(is_GR_on(x) || is_RF_on(x) || is_ADC_on(x))
 
-"""
-    ΔT = durs(x::Sequence)
-
-Returns the array of durations of sequence's blocks in [s].
-
-# Arguments
-- `x`: (`::Sequence`) Sequence struct
-
-# Returns
-- `ΔT`: (`::Vector{Real}`, `[s]`) array of durations of sequence's blocks
-"""
-durs(x::Sequence) = begin
-	# ΔT_GR  = x.GR.dur
-	# ΔT_RF  = x.RF.dur
-	# ΔT_ADC = x.ADC.dur
-	# ΔT_DUR = x.DUR
-	# ΔT = maximum([ΔT_GR ΔT_RF ΔT_ADC ΔT_DUR],dims=2)
-	x.DUR
-end
-
 """
     T = dur(x::Sequence)
 
@@ -294,7 +272,7 @@ The total duration of the sequence in [s].
 # Returns
 - `T`: (`::Real`, `[s]`) total duration of the sequence
 """
-dur(x::Sequence) = sum(durs(x))
+dur(x::Sequence) = sum(x.DUR)
 
 """
     T0 = get_block_start_times(seq::Sequence)

KomaMRIBase/src/datatypes/sequence/ADC.jl

@@ -62,11 +62,11 @@ directly without the need to iterate elementwise.
 """
 getproperty(x::Vector{ADC}, f::Symbol) = begin
     if f == :dur
-		T, delay = x.T, x.delay
-		ΔT = T .+ delay
-		ΔT
+		dur.(x)
+    elseif f in fieldnames(ADC)
+        getfield.(x, f)
     else
-        getproperty.(x, f)
+        getfield(x, f)
     end
 end
 

KomaMRIBase/src/datatypes/sequence/Grad.jl

@@ -182,34 +182,34 @@ Base.show(io::IO, x::Grad) = begin
 end
 
 """
-    y = getproperty(x::Vector{Grad}, f::Symbol)
-    y = getproperty(x::Matrix{Grad}, f::Symbol)
+    y = getproperty(x::Array{Grad}, f::Symbol)
 
 Overloads Base.getproperty(). It is meant to access properties of the Grad vector `x`
 directly without the need to iterate elementwise.
 
 # Arguments
-- `x`: (`::Vector{Grad}` or `::Matrix{Grad}`) vector or matrix of Grad structs
+- `x`: (`::Array{Grad}`) vector or matrix of Grad structs
 - `f`: (`::Symbol`, opts: [`:x`, `:y`, `:z`, `:T`, `:delay`, `:rise`, `:delay`, `:dur`,
     `:A`, `f`]) input symbol that represents a property of the vector or matrix of Grad
     structs
 
 # Returns
-- `y`: (`::Vector{Any}` or `::Matrix{Any}`) vector or matrix with the property defined
+- `y`: (`::Array{Any}`) vector or matrix with the property defined
     by the symbol `f` for all elements of the Grad vector or matrix `x`
 """
-getproperty(x::Vector{Grad}, f::Symbol) = getproperty.(x, f)
-getproperty(x::Matrix{Grad}, f::Symbol) = begin
+getproperty(x::Array{Grad}, f::Symbol) = begin
     if f == :x
-        x[1, :]
+        @view x[1, :]
     elseif f == :y && size(x, 1) >= 2
-        x[2, :]
+        @view x[2, :]
     elseif f == :z && size(x, 1) >= 3
-        x[3, :]
+        @view x[3, :]
     elseif f == :dur
-        maximum(dur.(x); dims=1)[:]
+        dur(x)
+    elseif f in fieldnames(Grad)
+        getfield.(x, f)
     else
-        getproperty.(x, f)
+        getfield(x, f)
     end
 end
 
@@ -221,17 +221,15 @@ function Base.isapprox(gr1::Grad, gr2::Grad)
 end
 
 # Gradient operations
-*(x::Grad, α::Real) = Grad(α * x.A, x.T, x.rise, x.fall, x.delay)
-*(α::Real, x::Grad) = Grad(α * x.A, x.T, x.rise, x.fall, x.delay)
-function *(A::Matrix{Float64}, GR::Matrix{Grad})
-    N, M = size(GR)
-    return [sum(A[i, 1:N] .* GR[:, j]) for i in 1:N, j in 1:M]
-end
+# zeros(Grad, M, N)
+Base.zero(::Type{Grad}) = Grad(0.0, 0.0)
+# Rotation
 Base.zero(::Grad) = Grad(0.0, 0.0)
-size(g::Grad, i::Int64) = 1 #To fix [g;g;;] concatenation of Julia 1.7.3
-/(x::Grad, α::Real) = Grad(x.A / α, x.T, x.rise, x.fall, x.delay)
+*(α::Real, x::Grad) = Grad(α * x.A, x.T, x.rise, x.fall, x.delay)
 +(x::Grad, y::Grad) = Grad(x.A .+ y.A, x.T, x.rise, x.fall, x.delay)
-+(x::Array{Grad,1}, y::Array{Grad,1}) = [x[i] + y[i] for i in 1:length(x)]
+# Others
+*(x::Grad, α::Real) = Grad(α * x.A, x.T, x.rise, x.fall, x.delay)
+/(x::Grad, α::Real) = Grad(x.A / α, x.T, x.rise, x.fall, x.delay)
 -(x::Grad) = -1 * x
 -(x::Grad, y::Grad) = Grad(x.A .- y.A, x.T, x.rise, x.fall, x.delay)
 
@@ -254,15 +252,16 @@ end
 """
     y = dur(x::Grad)
     y = dur(x::Vector{Grad})
+    y = dur(x::Matrix{Grad})
 
-Duration time in [s] of Grad struct or Grad array. When the input is a gradient vector, then
-the duration is the maximum duration of all the elements of the gradient vector.
+Duration time in [s] of Grad struct or Grad Array.
 
 # Arguments
-- `x`: (`::Grad` or `::Vector{Grad}`) RF struct or RF array
+- `x`: (`::Grad` or `::Vector{Grad}` or `::Matrix{Grad}`) Grad struct or Grad Array
 
 # Returns
-- `y`: (`::Float64`, `[s]`) duration of the RF struct or RF array
+- `y`: (`::Float64`, `[s]`) duration of the Grad struct or Grad Array
 """
 dur(x::Grad) = x.delay + x.rise + sum(x.T) + x.fall
-dur(x::Vector{Grad}) = maximum(dur.(x); dims=1)[:]
+dur(x::Vector{Grad}) = maximum(dur.(x); dims=1)[:]
+dur(x::Matrix{Grad}) = maximum(dur.(x); dims=1)[:]

KomaMRIBase/src/datatypes/sequence/RF.jl

@@ -71,37 +71,31 @@ Base.show(io::IO, x::RF) = begin
 end
 
 """
-    y = getproperty(x::Vector{RF}, f::Symbol)
-    y = getproperty(x::Matrix{RF}, f::Symbol)
+    y = getproperty(x::Array{RF}, f::Symbol)
 
 Overloads Base.getproperty(). It is meant to access properties of the RF vector `x`
 directly without the need to iterate elementwise.
 
 # Arguments
-- `x`: (`::Vector{RF}` or `::Matrix{RF}`) vector or matrix of RF structs
+- `x`: (`::Array{RF}`) vector or matrix of RF structs
 - `f`: (`::Symbol`, opts: [`:A`, `:Bx`, `:By`, `:T`, `:Δf`, `:delay` and `:dur`]) input
     symbol that represents a property of the vector or matrix of RF structs
 
 # Returns
-- `y`: (`::Vector{Any}` or `::Matrix{Any}`) vector with the property defined by the
+- `y`: (`::Array{Any}`) vector or matrix with the property defined by the
     symbol `f` for all elements of the RF vector or matrix `x`
 """
-getproperty(x::Vector{RF}, f::Symbol) = getproperty.(x, f)
 getproperty(x::Matrix{RF}, f::Symbol) = begin
     if f == :Bx
-        real.(getproperty.(x, :A))
+        real.(getfield.(x, :A))
     elseif f == :By
-        imag.(getproperty.(x, :A))
-    elseif f == :Δf
-        getproperty.(x, :Δf)
-    elseif f == :T || f == :delay
-        getproperty.(x[1, :], f)
+        imag.(getfield.(x, :A))
     elseif f == :dur
-        T, delay = x.T, x.delay
-        ΔT = [sum(t) for t in T] .+ delay
-        ΔT
+        dur(x)
+    elseif f in fieldnames(RF)
+        getfield.(x, f)
     else
-        getproperty.(x, f)
+        getfield(x, f)
     end
 end
 
@@ -118,22 +112,20 @@ size(r::RF, i::Int64) = 1 #To fix [r;r;;] concatenation of Julia 1.7.3
 
 """
     y = dur(x::RF)
-    y = dur(x::Array{RF,1})
-    y = dur(x::Array{RF,2})
+    y = dur(x::Vector{RF})
+    y = dur(x::Matrix{RF})
 
-Duration time in [s] of RF struct or RF array.
+Duration time in [s] of RF struct or RF Array.
 
 # Arguments
-- `x`: (`::RF` or `::Array{RF,1}` or `::Array{RF,2}`) RF struct or RF array
+- `x`: (`::RF` or `::Vector{RF}` or `::Matrix{RF}`) RF struct or RF array
 
 # Returns
 - `y`: (`::Float64`, [`s`]) duration of the RF struct or RF array
 """
-dur(x::RF) = sum(x.T)
-dur(x::Array{RF,1}) = sum(sum(x[i].T) for i in 1:size(x, 1))
-function dur(x::Array{RF,2})
-    return maximum(sum([sum(x[i, j].T) for i in 1:size(x, 1), j in 1:size(x, 2)]; dims=2))
-end
+dur(x::RF) = x.delay + sum(x.T)
+dur(x::Vector{RF}) = maximum(dur.(x); dims=1)[:]
+dur(x::Matrix{RF}) = maximum(dur.(x); dims=1)[:]
 
 """
     rf = RF_fun(f::Function, T::Real, N::Int64)

KomaMRIBase/src/sequences/PulseDesigner.jl

@@ -34,8 +34,8 @@ julia> plot_seq(seq)
 """
 function RF_hard(B1, T, sys::Scanner; G=[0, 0, 0], Δf=0)
 	ζ = sum(G) / sys.Smax
-    gr = reshape([Grad(G[1], T, ζ); Grad(G[2], T, ζ); Grad(G[3], T ,ζ)], :, 1)
-    rf = reshape([RF(B1, T, Δf, ζ)], :, 1)
+    gr = [Grad(G[1], T, ζ); Grad(G[2], T, ζ); Grad(G[3], T ,ζ) ;;]
+    rf = [RF(B1, T, Δf, ζ) ;;]
 	return Sequence(gr, rf)
 end
 
@@ -159,9 +159,10 @@ function EPI(FOV::Real, N::Integer, sys::Scanner)
 	*string(round(1/(γ*Gmax*FOV),digits=2))*" us.") : 0
 	ϵ1 = Δτ/(Δτ+ζ)
 	#EPI base
-	EPI = Sequence(vcat(
-	    [mod(i,2)==0 ? Grad(Ga*(-1)^(i/2),Ta,ζ) : Grad(0.,Δτ,ζ) for i=0:2*Ny-2],  #Gx
-	 	[mod(i,2)==1 ? ϵ1*Grad(Ga,Δτ,ζ) :         Grad(0.,Ta,ζ) for i=0:2*Ny-2])) #Gy
+	GR = zeros(Grad, 3, length(0:2*Ny-2))
+	GR.x .= [mod(i,2)==0 ? Grad(Ga*(-1)^(i/2),Ta,ζ) : Grad(0.,Δτ,ζ) for i=0:2*Ny-2]
+	GR.y .= [mod(i,2)==1 ? ϵ1*Grad(Ga,Δτ,ζ) :         Grad(0.,Ta,ζ) for i=0:2*Ny-2]
+	EPI = Sequence(GR)
 	EPI.ADC = [mod(i,2)==1 ? ADC(0,Δτ,ζ) : ADC(N,Ta,ζ) for i=0:2*Ny-2]
 	# Relevant parameters
 	Δfx_pix = 1/Ta
@@ -173,8 +174,8 @@ function EPI(FOV::Real, N::Integer, sys::Scanner)
 	# println("Pixel Δf in phase direction $(round(Δfx_pix_phase,digits=2)) Hz")
 	#Pre-wind and wind gradients
 	ϵ2 = Ta/(Ta+ζ)
-    PHASE =   Sequence(reshape(1/2*[Grad(      -Ga, Ta, ζ); ϵ2*Grad(-Ga, Ta, ζ)],:,1)) #This needs to be calculated differently
-	DEPHASE = Sequence(reshape(1/2*[Grad((-1)^N*Ga, Ta, ζ); ϵ2*Grad(-Ga, Ta, ζ)],:,1)) #for even N
+    PHASE =   Sequence(1/2*[Grad(      -Ga, Ta, ζ); ϵ2*Grad(-Ga, Ta, ζ); Grad(0.,0.);;]) #This needs to be calculated differently
+	DEPHASE = Sequence(1/2*[Grad((-1)^N*Ga, Ta, ζ); ϵ2*Grad(-Ga, Ta, ζ); Grad(0.,0.);;]) #for even N
 	seq = PHASE+EPI+DEPHASE
 	#Saving parameters
 	seq.DEF = Dict("Nx"=>Nx,"Ny"=>Ny,"Nz"=>1,"Name"=>"epi")

KomaMRIBase/test/Project.toml

@@ -1,4 +1,5 @@
 [deps]
+KomaMRIBase = "d0bc0b20-b151-4d03-b2a4-6ca51751cb9c"
 Suppressor = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 TestItemRunner = "f8b46487-2199-4994-9208-9a1283c18c0a"

KomaMRIBase/test/runtests.jl

@@ -26,9 +26,10 @@ using TestItems, TestItemRunner
 
     @testset "Rot_and_Concat" begin
         # Rotation 2D case
-        A1, A2, T, t = rand(4)
+        A1, A2, A3, T, t = rand(5)
         s = Sequence([Grad(A1,T);
-                    Grad(A2,T)])
+                      Grad(A2,T);
+                      Grad(A3,T);;])
         θ = π*t
         R = rotz(θ)
         s2 = R*s #Matrix-Matrix{Grad} multiplication
@@ -96,7 +97,6 @@ using TestItems, TestItemRunner
         # Test Grad operations
         α = 3
         gradt = α * grad
-        @test size(grad, 1) == 1
         @test gradt.A ≈ α * grad.A
         gradt = grad * α
         @test gradt.A ≈ α * grad.A
@@ -165,8 +165,8 @@ using TestItems, TestItemRunner
         @test dur(rf) ≈ rf.T
         B1x, B1y, B2x, B2y, B3x, B3y, T1, T2, T3 = rand(9)
         rf1, rf2, rf3 = RF(B1x + im*B1y, T1), RF(B1x + im*B1y, T2), RF(B3x + im*B3y, T3)
-        rv = [rf1; rf2; rf3]
-        @test dur(rv) ≈ sum(dur.(rv))
+        rv = [rf1; rf2; rf3 ;;]
+        @test dur(rv) ≈ maximum(dur.(rv); dims=1)
 
     end