ParTable: add explicit params field

Author: alyst

src/frontend/specification/EnsembleParameterTable.jl

@@ -23,25 +23,19 @@ function EnsembleParameterTable(
     spec_ensemble::AbstractDict{K, V};
     params::Union{Nothing, Vector{Symbol}} = nothing,
 ) where {K, V <: SemSpecification}
-    partables = Dict{K, ParameterTable}(
-        group => convert(ParameterTable, spec; params = params) for
-        (group, spec) in pairs(spec_ensemble)
-    )
-
-    if isnothing(params)
+    params = if isnothing(params)
         # collect all SEM parameters in ensemble if not specified
         # and apply the set to all partables
-        params =
-            unique(mapreduce(SEM.params, vcat, values(partables), init = Vector{Symbol}()))
-        for partable in values(partables)
-            if partable.params != params
-                copyto!(resize!(partable.params, length(params)), params)
-                #throw(ArgumentError("The parameter sets of the SEM specifications in the ensemble do not match."))
-            end
-        end
+        unique(mapreduce(SEM.params, vcat, values(spec_ensemble), init = Vector{Symbol}()))
     else
-        params = copy(params)
+        copy(params)
     end
+
+    # convert each model specification to ParameterTable
+    partables = Dict{K, ParameterTable}(
+        group => convert(ParameterTable, spec; params) for
+        (group, spec) in pairs(spec_ensemble)
+    )
     return EnsembleParameterTable{K}(partables, params)
 end
 

src/frontend/specification/ParameterTable.jl

@@ -7,6 +7,7 @@ struct ParameterTable{C} <: AbstractParameterTable
     observed_vars::Vector{Symbol}
     latent_vars::Vector{Symbol}
     sorted_vars::Vector{Symbol}
+    params::Vector{Symbol}
 end
 
 ############################################################################################
@@ -31,11 +32,32 @@ function ParameterTable(
     columns::Dict{Symbol, Vector} = empty_partable_columns();
     observed_vars::Union{AbstractVector{Symbol}, Nothing} = nothing,
     latent_vars::Union{AbstractVector{Symbol}, Nothing} = nothing,
+    params::Union{AbstractVector{Symbol}, Nothing} = nothing,
 )
-    return ParameterTable(columns,
+    params = isnothing(params) ? unique!(filter(!=(:const), columns[:param])) : copy(params)
+    check_params(params, columns[:param])
+    return ParameterTable(
+        columns,
         !isnothing(observed_vars) ? copy(observed_vars) : Vector{Symbol}(),
         !isnothing(latent_vars) ? copy(latent_vars) : Vector{Symbol}(),
-        Vector{Symbol}())
+        Vector{Symbol}(),
+        params,
+    )
+end
+
+# new parameter table with different parameters order
+function ParameterTable(
+    partable::ParameterTable;
+    params::Union{AbstractVector{Symbol}, Nothing} = nothing,
+)
+    isnothing(params) || check_params(params, partable.columns[:param])
+
+    return ParameterTable(
+        Dict(col => copy(values) for (col, values) in pairs(partable.columns)),
+        observed_vars = copy(partable.observed_vars),
+        latent_vars = copy(partable.latent_vars),
+        params = params,
+    )
 end
 
 ############################################################################################
@@ -46,6 +68,15 @@ function Base.convert(::Type{Dict}, partable::ParameterTable)
     return partable.columns
 end
 
+function Base.convert(
+    ::Type{ParameterTable},
+    partable::ParameterTable;
+    params::Union{AbstractVector{Symbol}, Nothing} = nothing,
+)
+    return isnothing(params) || partable.params == params ? partable :
+           ParameterTable(partable; params)
+end
+
 function DataFrames.DataFrame(
     partable::ParameterTable;
     columns::Union{AbstractVector{Symbol}, Nothing} = nothing,
@@ -111,12 +142,8 @@ Base.iterate(partable::ParameterTable) = iterate(partable, 1)
 Base.iterate(partable::ParameterTable, i::Integer) =
     i > length(partable) ? nothing : (partable[i], i + 1)
 
-
-# get the vector of all parameters in the table
-# the position of the parameter is based on its first appearance in the table (and the ensemble)
-params(partable::ParameterTable) =
-    filter!(!=(:const), unique(partable.columns[:param]))
-
+params(partable::ParameterTable) = partable.params
+n_par(partable::ParameterTable) = length(params(partable))
 
 # Sorting ----------------------------------------------------------------------------------
 

src/frontend/specification/RAMMatrices.jl

@@ -222,21 +222,43 @@ function RAMMatrices(
     )
 end
 
-Base.convert(::Type{RAMMatrices}, partable::ParameterTable) = RAMMatrices(partable)
+Base.convert(
+    ::Type{RAMMatrices},
+    partable::ParameterTable;
+    params::Union{AbstractVector{Symbol}, Nothing} = nothing,
+) = RAMMatrices(partable; params)
 
 ############################################################################################
 ### get parameter table from RAMMatrices
 ############################################################################################
 
-function ParameterTable(ram_matrices::RAMMatrices)
-    colnames = ram_matrices.colnames
+function ParameterTable(
+    ram_matrices::RAMMatrices;
+    params::Union{AbstractVector{Symbol}, Nothing} = nothing,
+    observed_var_prefix::Symbol = :obs,
+    latent_var_prefix::Symbol = :var,
+)
+    # defer parameter checks until we know which ones are used
+    if !isnothing(ram_matrices.colnames)
+        colnames = ram_matrices.colnames
+        observed_vars = colnames[ram_matrices.F_ind]
+        latent_vars = colnames[setdiff(eachindex(colnames), ram_matrices.F_ind)]
+    else
+        observed_vars =
+            [Symbol("$(observed_var_prefix)_$i") for i in 1:nobserved_vars(ram_matrices)]
+        latent_vars =
+            [Symbol("$(latent_var_prefix)_$i") for i in 1:nlatent_vars(ram_matrices)]
+        colnames = vcat(observed_vars, latent_vars)
+    end
 
+    # construct an empty table
     partable = ParameterTable(
-        observed_vars = colnames[ram_matrices.F_ind],
-        latent_vars = colnames[setdiff(eachindex(colnames), ram_matrices.F_ind)],
+        observed_vars = observed_vars,
+        latent_vars = latent_vars,
+        params = isnothing(params) ? SEM.params(ram_matrices) : params,
     )
 
-    position_names = Dict{Int64, Symbol}(1:length(colnames) .=> colnames)
+    position_names = Dict{Int, Symbol}(eachindex(colnames) .=> colnames)
 
     # constants
     for c in ram_matrices.constants
@@ -256,12 +278,16 @@ function ParameterTable(ram_matrices::RAMMatrices)
             ram_matrices.size_F[2],
         )
     end
+    check_params(SEM.params(partable), partable.columns[:param])
 
     return partable
 end
 
-Base.convert(::Type{<:ParameterTable}, ram_matrices::RAMMatrices) =
-    ParameterTable(ram_matrices)
+Base.convert(
+    ::Type{<:ParameterTable},
+    ram::RAMMatrices;
+    params::Union{AbstractVector{Symbol}, Nothing} = nothing,
+) = ParameterTable(ram; params)
 
 ############################################################################################
 ### Pretty Printing