Guarantee discretized controls are Vector{Float64}.

Author: goerz

src/amplitudes.jl

@@ -28,15 +28,27 @@ struct LockedAmplitude{ST}
     shape::ST
 
     function LockedAmplitude(shape::ST; check = true) where {ST}
-        if check && !(shape isa Vector{Float64})
-            try
-                shape(0.0)
-            catch
-                msg = "A LockedAmplitude shape must either be a Vector{Float64} or a callable"
-                error(msg)
+        if shape isa AbstractVector
+            if !(shape isa Vector{Float64})
+                try
+                    shape = Vector{Float64}(shape)
+                catch
+                    msg = "A LockedAmplitude shape that is a vector must be convertible to Vector{Float64}"
+                    error(msg)
+                end
+            end
+            return new{Vector{Float64}}(shape)
+        else
+            if check
+                try
+                    shape(0.0)
+                catch
+                    msg = "A LockedAmplitude shape must either be a Vector{Float64} or a callable"
+                    error(msg)
+                end
             end
+            return new{ST}(shape)
         end
-        return new{ST}(shape)
     end
 end
 
@@ -123,6 +135,22 @@ end
 
 
 function ShapedAmplitude(control; shape, check = true)
+    if control isa AbstractVector && !(control isa Vector{Float64})
+        try
+            control = Vector{Float64}(control)
+        catch
+            msg = "A ShapedAmplitude control that is a vector must be convertible to Vector{Float64}"
+            error(msg)
+        end
+    end
+    if shape isa AbstractVector && !(shape isa Vector{Float64})
+        try
+            shape = Vector{Float64}(shape)
+        catch
+            msg = "A ShapedAmplitude shape that is a vector must be convertible to Vector{Float64}"
+            error(msg)
+        end
+    end
     if check
         if !(control isa Vector{Float64})
             try
@@ -159,7 +187,7 @@ end
 function ShapedAmplitude(control, tlist::Vector{Float64}; shape)
     control = discretize_on_midpoints(control, tlist)
     shape = discretize_on_midpoints(shape, tlist)
-    return ShapedAmplitude{typeof(control),typeof(shape)}(control, shape)
+    return ShapedAmplitude{Vector{Float64},Vector{Float64}}(control, shape)
 end
 
 

src/controls.jl

@@ -45,17 +45,17 @@ function discretize(control::Function, tlist; via_midpoints = true)
         vals_on_midpoints = discretize_on_midpoints(control, tlist)
         return discretize(vals_on_midpoints, tlist)
     else
-        return [control(t) for t in tlist]
+        return Float64[control(t) for t in tlist]
     end
 end
 
 function discretize(control::Vector, tlist)
     if length(control) == length(tlist)
-        return copy(control)
+        return Vector{Float64}(control)
     elseif length(control) == length(tlist) - 1
         # convert `control` on intervals to values on `tlist`
         # cf. pulse_onto_tlist in Python krotov package
-        vals = zeros(eltype(control), length(control) + 1)
+        vals = zeros(Float64, length(control) + 1)
         vals[1] = control[1]
         vals[end] = control[end]
         for i = 2:(length(vals)-1)
@@ -193,9 +193,9 @@ end
 
 function discretize_on_midpoints(control::Vector, tlist)
     if length(control) == length(tlist) - 1
-        return copy(control)
+        return Vector{Float64}(control)
     elseif length(control) == length(tlist)
-        vals = Vector{eltype(control)}(undef, length(tlist) - 1)
+        vals = Vector{Float64}(undef, length(tlist) - 1)
         vals[1] = control[1]
         vals[end] = control[end]
         for i = 2:(length(vals)-1)

test/test_amplitudes.jl

@@ -63,6 +63,44 @@ end
 end
 
 
+@testset "Vector{Float64} conversion" begin
+    tlist = collect(range(0, 10, length = 101))
+    S(t) = flattop(t, T = 10, t_rise = 2, func = :blackman)
+    ϵ(t) = 1.0
+
+    # LockedAmplitude: callable returning Int is discretized to Vector{Float64}
+    ampl = LockedAmplitude(t -> 1, tlist)
+    @test ampl.shape isa Vector{Float64}
+    @test check_amplitude(ampl; tlist)
+
+    # LockedAmplitude: Vector{Int} is converted to Vector{Float64}
+    S_int = ones(Int, length(tlist) - 1)
+    ampl = LockedAmplitude(S_int)
+    @test ampl.shape isa Vector{Float64}
+    @test check_amplitude(ampl; tlist)
+
+    # ShapedAmplitude: callable shape returning Int
+    ampl = ShapedAmplitude(ϵ; shape = t -> 1)
+    @test check_amplitude(ampl; tlist)
+    t = t_mid(tlist, 20)
+    @test evaluate(ampl, tlist, 20) ≈ ϵ(t) * 1
+
+    # ShapedAmplitude: Vector{Int} control and shape are converted
+    ϵ_int = ones(Int, length(tlist) - 1)
+    S_int = ones(Int, length(tlist) - 1)
+    ampl = ShapedAmplitude(ϵ_int; shape = S_int)
+    @test ampl.control isa Vector{Float64}
+    @test ampl.shape isa Vector{Float64}
+    @test check_amplitude(ampl; tlist)
+
+    # ShapedAmplitude tlist constructor: callable returning Int is discretized to Vector{Float64}
+    ampl = ShapedAmplitude(t -> 1, tlist; shape = t -> 1)
+    @test ampl.control isa Vector{Float64}
+    @test ampl.shape isa Vector{Float64}
+
+end
+
+
 @testset "ShapedAmplitude mixed" begin
     tlist = collect(range(0, 10, length = 101))
     S(t) = flattop(t, T = 10, t_rise = 2, func = :blackman)