Fix #22 extra fields

Author: ChrisRackauckas

README.md

@@ -161,6 +161,7 @@ Each type above then contains three fields:
 - `values::Vector{B}`
 - `end_idxs::Vector{Int}``
 
+Note that the ordering of the fields matters.
 `B` is the `BottomType`, which has to be the same as the eltype for the array
 in the leaf types. `T` is another `AbstractMultiScaleArray`. Thus at each level,
 an` AbstractMultiScaleArray` contains some information of its own (`values`), the
@@ -201,8 +202,12 @@ struct Cell{B} <: AbstractMultiScaleArrayLeaf{B}
 end
 ```
 
-Then we'd construct cells with `cell3 = Cell([3.0; 2.0; 5.0], :BCell)`, and can
-give it a cell type. This information is part of the call, so
+Note that the ordering of the fields matters here: the extra fields must come
+after the standard fields (so for a leaf it comes after `values`, for a standard
+multiscale array it would come after `nodes,values,end_idxs`).
+Then we'd construct cells with
+`cell3 = Cell([3.0; 2.0; 5.0], :BCell)`, and can give it a cell type.
+This information is part of the call, so
 
 ```julia
 for (cell, y, z) in level_iter_idx(embryo, 2)

src/shape_construction.jl

@@ -9,17 +9,23 @@ size(m::AbstractMultiScaleArray) = (length(m),)
 parameterless_type(T::Type) = Base.typename(T).wrapper
 parameterless_type(x) = parameterless_type(typeof(x))
 
-similar(m::AbstractMultiScaleArray) =
-    construct(typeof(m), deepcopy(m.nodes), deepcopy(m.values))
-similar(m::AbstractMultiScaleArrayLeaf) =
-    construct(typeof(m), similar(m.values))
-similar(m::AbstractMultiScaleArrayLeaf, T::Type) =
-    construct(parameterless_type(m), similar(m.values, T))
-similar(m::AbstractMultiScaleArray,T::Type) =
-    construct(parameterless_type(m), [similar(v, T) for v in m.nodes], similar(m.values, T))
+@generated function similar(m::AbstractMultiScaleArrayLeaf,::Type{T}=eltype(m)) where T
+    assignments = [s == :x ? :(similar(m.x, T)) :
+                   (sq = Meta.quot(s); :(deepcopy(getfield(m, $sq))))
+                   for s in fieldnames(m)[2:end]] # 1 is values
+    :(construct(parameterless_type(m), similar(m.values,T),$(assignments...)))
+end
+
+@generated function similar(m::AbstractMultiScaleArray,::Type{T}=eltype(m)) where {T}
+    assignments = [s == :x ? :(similar(m.x, T, dims)) :
+                   (sq = Meta.quot(s); :(deepcopy(getfield(m, $sq))))
+                   for s in fieldnames(m)[4:end]] # 1:3 is nodes,values,end_idxs
+    :(construct(parameterless_type(m), recursive_similar(m.nodes,T),similar(m.values, T),$(assignments...)))
+end
+
+recursive_similar(x,T) = [similar(y, T) for y in x]
 
-construct(::Type{T}, values, args...) where {T<:AbstractMultiScaleArrayLeaf} =
-                                                              T(values, args...)
+construct(::Type{T}, args...) where {T<:AbstractMultiScaleArrayLeaf} = T(args...)
 
 function __construct(nodes::Vector{<:AbstractMultiScaleArray})
     end_idxs = Vector{Int}(length(nodes))

test/additional_fields_test.jl

@@ -0,0 +1,77 @@
+using OrdinaryDiffEq, Base.Test
+using MultiScaleArrays
+
+struct CellGenotype{B<:Float64} <: AbstractMultiScaleArrayLeaf{B}
+    values::Vector{B}
+    Iam::Symbol
+end
+
+struct Host{T<:AbstractMultiScaleArray,B<:Float64} <: AbstractMultiScaleArrayHead{B}
+    nodes::Vector{T}
+    values::Vector{B}
+    end_idxs::Vector{Int}
+end
+
+host = construct(Host,[
+        CellGenotype(# Genotype present at start for symbiont 1
+        [Float64(1)],
+        :aSymbiontGenotype, # I am
+        ),
+        CellGenotype(# Genotype present at start for symbiont 1
+        [Float64(1)],
+        :aSymbiontGenotype, # I am
+        )]
+    )
+
+evolve = function (t,u::Host,du)
+  for i in 1:length(u)
+    du[i] = 2*u[i]
+  end
+end
+
+similar(host)
+similar(host.nodes[1])
+similar(host.nodes[1],Float64)
+similar(host,Float64)
+
+## Solve
+tspan = (0.0,50)
+prob = ODEProblem(evolve, host, tspan)
+sol = solve(prob,Tsit5())
+
+
+
+struct Host2{T<:AbstractMultiScaleArray,B<:Float64} <: AbstractMultiScaleArrayHead{B}
+    nodes::Vector{T}
+    values::Vector{B}
+    end_idxs::Vector{Int}
+    Iam::Symbol
+end
+
+host2 = construct(Host2,[
+        CellGenotype(# Genotype present at start for symbiont 1
+        [Float64(1)],
+        :aSymbiontGenotype, # I am
+        ),
+        CellGenotype(# Genotype present at start for symbiont 1
+        [Float64(1)],
+        :aSymbiontGenotype, # I am
+        )],Float64[],
+        :my_cell_type
+    )
+
+evolve = function (t,u::Host2,du)
+  for i in 1:length(u)
+    du[i] = 2*u[i]
+  end
+end
+
+similar(host2)
+similar(host2.nodes[1])
+similar(host2.nodes[1],Float64)
+similar(host2,Float64)
+
+## Solve
+tspan = (0.0,50)
+prob = ODEProblem(evolve, host2, tspan)
+sol = solve(prob,Tsit5())

test/runtests.jl

@@ -5,4 +5,5 @@ using Base.Test
 @time @testset "Indexing and Creation Tests" begin include("indexing_and_creation_tests.jl") end
 @time @testset "Values Indexing" begin include("values_indexing.jl") end
 @time @testset "Get Indices Tests" begin include("get_indices.jl") end
+@time @testset "Additional Fields Test" begin include("additional_fields_test.jl") end
 @time @testset "Dynamic DiffEq Tests" begin include("dynamic_diffeq.jl") end