Merge pull request #123 from fjebaker/fergus/copy

Copy

src/abstract-models.jl

@@ -322,6 +322,10 @@ function allocate_model_output(
     construct_objective_cache(T, model, domain)
 end
 
+function Base.copy(m::AbstractSpectralModel)
+    typeof(m)((copy(getproperty(m, f)) for f in fieldnames(typeof(m)))...)
+end
+
 # printing
 
 function _printinfo(io::IO, m::M) where {M<:AbstractSpectralModel}

src/composite-models.jl

@@ -105,7 +105,11 @@ struct CompositeModel{M1,M2,O,T,K} <: AbstractSpectralModel{T,K}
         m2::M2,
         op::O,
     ) where {M1<:AbstractSpectralModel{T},M2<:AbstractSpectralModel{T,K},O} where {T,K} =
-        new{M1,M2,O,T,K}(deepcopy(m1), deepcopy(m2), op)
+        new{M1,M2,O,T,K}(copy(m1), copy(m2), op)
+end
+
+function Base.copy(m::CompositeModel)
+    CompositeModel(getfield(m, :left), getfield(m, :right), getfield(m, :op))
 end
 
 function implementation(::Type{<:CompositeModel{M1,M2}}) where {M1,M2}

src/fitparam.jl

@@ -4,7 +4,7 @@ function fit_param_default_error(val)
 end
 
 # concrete types
-mutable struct FitParam{T}
+mutable struct FitParam{T<:Number}
     value::T
     error::T
 
@@ -47,6 +47,14 @@ Base.isapprox(f1::FitParam, f2::FitParam; kwargs...) =
 Base.:(==)(f1::FitParam, f2::FitParam) = f1.value == f2.value
 Base.convert(T::Type{<:Number}, f::FitParam) = convert(T, f.value)
 
+Base.copy(f::FitParam) = FitParam(
+    f.value;
+    error = f.error,
+    lower_limit = f.lower_limit,
+    upper_limit = f.upper_limit,
+    frozen = f.frozen,
+)
+
 paramtype(::Type{FitParam{T}}) where {T} = T
 paramtype(::T) where {T<:FitParam} = paramtype(T)
 

src/meta-models/caching.jl

@@ -24,6 +24,10 @@ struct AutoCache{M,T,K,C<:CacheEntry} <: AbstractModelWrapper{M,T,K}
     end
 end
 
+function Base.copy(m::AutoCache)
+    AutoCache(copy(m.model), deepcopy(m.cache), m.abstol)
+end
+
 function AutoCache(model::AbstractSpectralModel{T,K}; abstol = 1e-3) where {T,K}
     params = [get_value.(parameter_tuple(model))...]
     cache = CacheEntry(params)

src/meta-models/functions.jl

@@ -13,6 +13,15 @@ struct AsConvolution{M,T,V,P} <: AbstractModelWrapper{M,T,Convolutional}
     end
 end
 
+"""
+    Base.copy(m::AsConvolution)
+
+Creates a copy of an [`AsConvolution`](@ref) wrapped model. Will make a 
+`deepcopy` of the cache to elimiate possible thread contention, but does not
+copy the domain.
+"""
+Base.copy(m::AsConvolution) = AsConvolution(copy(m.model), m.domain, deepcopy(m.cache))
+
 function AsConvolution(
     model::AbstractSpectralModel{T};
     domain = collect(range(0, 2, 100)),

src/meta-models/surrogate-models.jl

@@ -28,6 +28,8 @@ struct SurrogateSpectralModel{T,K,N,S,Symbols} <: AbstractSpectralModel{T,K}
     params::NTuple{N,T}
 end
 
+Base.copy(s::SurrogateSpectralModel) = typeof(s)(deepcopy(s.surrogate), deepcopy(s.params))
+
 function SurrogateSpectralModel(
     ::K,
     surrogate::S,

src/meta-models/table-models.jl

@@ -10,12 +10,33 @@ First field in the struct **must be** `table`. See
 abstract type AbstractTableModel{T,K} <: AbstractSpectralModel{T,K} end
 
 # reflection tie-ins
-function Reflection.get_closure_symbols(::Type{<:AbstractTableModel})
-    (:table,)
-end
-function Reflection.get_parameter_symbols(model::Type{<:AbstractTableModel})
-    # `table` field is not a model parameter
+Reflection.get_closure_symbols(::Type{<:AbstractTableModel}) = (:table,)
+
+# `table` field is not a model parameter
+Reflection.get_parameter_symbols(model::Type{<:AbstractTableModel}) =
     fieldnames(model)[2:end]
+
+"""
+    Base.copy(m::AbstractTableModel)
+
+Create a copy of an [`AbstractTableModel`](@ref). This will copy all fields except
+the `table` field, which is assumed to be a constant set of values that can be
+shared by multiple copies.
+
+When this is not the case, the user should redefine `Base.copy` for their particular
+table model to copy the table as needed.
+"""
+function Base.copy(m::AbstractTableModel)
+    typeof(m)(m.table, (copy(getproperty(m, f)) for f in fieldnames(typeof(m))[2:end])...)
+end
+
+abstract type AbstractCachedModel{T,K} <: AbstractSpectralModel{T,K} end
+
+# reflection tie-ins
+function Reflection.get_closure_symbols(::Type{<:AbstractCachedModel})
+    (:cache,)
 end
+Reflection.get_parameter_symbols(model::Type{<:AbstractCachedModel}) =
+    fieldnames(model)[2:end]
 
 export AbstractTableModel

test/models/test-as-convolution.jl

@@ -14,9 +14,6 @@ model = conv(lines)
 
 domain = collect(range(0.0, 10.0, 150))
 
-plot(domain[1:end-1], invokemodel(domain, lines))
-plot(domain[1:end-1], invokemodel(domain, model))
-
 output = invokemodel(domain, model)
 
 @test sum(output) ≈ 3.2570820013702395 atol = 1e-4

test/models/test-copy.jl

@@ -0,0 +1,27 @@
+using SpectralFitting
+using Test
+
+include("../dummies.jl")
+
+# single model
+m = PowerLaw()
+m2 = copy(m)
+@inferred copy(m)
+m.K.value = 2.0
+@test m2.K.value == 1.0
+
+# table model
+m = DummyMultiplicativeTableModel()
+m2 = copy(m)
+@inferred copy(m)
+m.a.value = 2.0
+@test m2.a.value == 1.0
+@test m.table === m2.table
+
+# composite model
+model = PowerLaw() + PowerLaw()
+model2 = copy(model)
+model.K_1.value = 2.0
+@test model2.K_2.value == 1.0
+
+@inferred copy(model)

test/runtests.jl

@@ -56,6 +56,8 @@ end
     include("models/test-table-models.jl")
     include("models/test-surrogate-models.jl")
     include("models/test-auto-cache.jl")
+    include("models/test-as-convolution.jl")
+    include("models/test-copy.jl")
 
     # only test XSPEC models when not using CI
     # since model data access is annoying