feat: add dump_variable_metadata, dump_parameters, dump_variables

Also make `istunable` default to `true` for parameters without tunable
metadata. `tunable_parameters` is also updated accordingly

Author: AayushSabharwal

src/systems/abstractsystem.jl

@@ -2146,3 +2146,23 @@ function process_parameter_dependencies(pdeps, ps)
     end
     return pdeps, ps
 end
+
+function dump_parameters(sys::AbstractSystem)
+    defs = defaults(sys)
+    map(dump_variable_metadata.(parameters(sys))) do meta
+        if haskey(defs, meta.var)
+            meta = merge(meta, (; default = defs[meta.var]))
+        end
+        meta
+    end
+end
+
+function dump_unknowns(sys::AbstractSystem)
+    defs = defaults(sys)
+    map(dump_variable_metadata.(unknowns(sys))) do meta
+        if haskey(defs, meta.var)
+            meta = merge(meta, (; default = defs[meta.var]))
+        end
+        meta
+    end
+end

src/variables.jl

@@ -15,6 +15,57 @@ Symbolics.option_to_metadata_type(::Val{:irreducible}) = VariableIrreducible
 Symbolics.option_to_metadata_type(::Val{:state_priority}) = VariableStatePriority
 Symbolics.option_to_metadata_type(::Val{:misc}) = VariableMisc
 
+function dump_variable_metadata(var)
+    uvar = unwrap(var)
+    vartype, name = get(uvar.metadata, VariableSource, (:unknown, :unknown))
+    shape = Symbolics.shape(var)
+    if shape == ()
+        shape = nothing
+    end
+    unit = get(uvar.metadata, VariableUnit, nothing)
+    connect = get(uvar.metadata, VariableConnectType, nothing)
+    noise = get(uvar.metadata, VariableNoiseType, nothing)
+    input = isinput(uvar) || nothing
+    output = isoutput(uvar) || nothing
+    irreducible = get(uvar.metadata, VariableIrreducible, nothing)
+    state_priority = get(uvar.metadata, VariableStatePriority, nothing)
+    misc = get(uvar.metadata, VariableMisc, nothing)
+    bounds = hasbounds(uvar) ? getbounds(uvar) : nothing
+    desc = getdescription(var)
+    if desc == ""
+        desc = nothing
+    end
+    guess = getguess(uvar)
+    disturbance = isdisturbance(uvar) || nothing
+    tunable = istunable(uvar, isparameter(uvar))
+    dist = getdist(uvar)
+    type = symtype(uvar)
+
+    meta = (
+        var = var,
+        vartype,
+        name,
+        shape,
+        unit,
+        connect,
+        noise,
+        input,
+        output,
+        irreducible,
+        state_priority,
+        misc,
+        bounds,
+        desc,
+        guess,
+        disturbance,
+        tunable,
+        dist,
+        type
+    )
+
+    return NamedTuple(k => v for (k, v) in pairs(meta) if v !== nothing)
+end
+
 abstract type AbstractConnectType end
 struct Equality <: AbstractConnectType end # Equality connection
 struct Flow <: AbstractConnectType end     # sum to 0
@@ -243,7 +294,7 @@ Symbolics.option_to_metadata_type(::Val{:tunable}) = VariableTunable
 istunable(x::Num, args...) = istunable(Symbolics.unwrap(x), args...)
 
 """
-    istunable(x, default = false)
+    istunable(x, default = true)
 
 Determine whether symbolic variable `x` is marked as a tunable for an automatic tuning algorithm.
 
@@ -257,7 +308,7 @@ Create a tunable parameter by
 
 See also [`tunable_parameters`](@ref), [`getbounds`](@ref)
 """
-function istunable(x, default = false)
+function istunable(x, default = true)
     p = Symbolics.getparent(x, nothing)
     p === nothing || (x = p)
     Symbolics.getmetadata(x, VariableTunable, default)
@@ -302,7 +353,7 @@ end
 ## System interface
 
 """
-    tunable_parameters(sys, p = parameters(sys); default=false)
+    tunable_parameters(sys, p = parameters(sys); default=true)
 
 Get all parameters of `sys` that are marked as `tunable`.
 
@@ -316,7 +367,7 @@ Create a tunable parameter by
 
 See also [`getbounds`](@ref), [`istunable`](@ref)
 """
-function tunable_parameters(sys, p = parameters(sys); default = false)
+function tunable_parameters(sys, p = parameters(sys); default = true)
     filter(x -> istunable(x, default), p)
 end
 

test/test_variable_metadata.jl

@@ -4,52 +4,72 @@ using ModelingToolkit
 @variables u [bounds = (-1, 1)]
 @test getbounds(u) == (-1, 1)
 @test hasbounds(u)
+@test ModelingToolkit.dump_variable_metadata(u).bounds == (-1, 1)
 
 @variables y
 @test !hasbounds(y)
+@test !haskey(ModelingToolkit.dump_variable_metadata(y), :bounds)
 
 # Guess
 @variables y [guess = 0]
 @test getguess(y) === 0
 @test hasguess(y) === true
+@test ModelingToolkit.dump_variable_metadata(y).guess == 0
 
 @variables y
 @test hasguess(y) === false
+@test !haskey(ModelingToolkit.dump_variable_metadata(y), :guess)
 
 # Disturbance
 @variables u [disturbance = true]
 @test isdisturbance(u)
+@test ModelingToolkit.dump_variable_metadata(u).disturbance
 
 @variables y
 @test !isdisturbance(y)
+@test !haskey(ModelingToolkit.dump_variable_metadata(y), :disturbance)
 
 # Tunable
 @parameters u [tunable = true]
 @test istunable(u)
+@test ModelingToolkit.dump_variable_metadata(u).tunable
+
+@parameters u2 [tunable = false]
+@test !istunable(u2)
+@test !ModelingToolkit.dump_variable_metadata(u2).tunable
 
 @parameters y
-@test !istunable(y)
+@test istunable(y)
+@test ModelingToolkit.dump_variable_metadata(y).tunable
 
 # Distributions
 struct FakeNormal end
 d = FakeNormal()
 @parameters u [dist = d]
 @test hasdist(u)
 @test getdist(u) == d
+@test ModelingToolkit.dump_variable_metadata(u).dist == d
 
 @parameters y
 @test !hasdist(y)
+@test !haskey(ModelingToolkit.dump_variable_metadata(y), :dist)
 
 ## System interface
 @parameters t
 Dₜ = Differential(t)
 @variables x(t)=0 [bounds = (-10, 10)] u(t)=0 [input = true] y(t)=0 [output = true]
-@parameters T [tunable = true, bounds = (0, Inf)]
+@parameters T [bounds = (0, Inf)]
 @parameters k [tunable = true, bounds = (0, Inf)]
-@parameters k2
+@parameters k2 [tunable = false]
 eqs = [Dₜ(x) ~ (-k2 * x + k * u) / T
        y ~ x]
 sys = ODESystem(eqs, t, name = :tunable_first_order)
+unk_meta = ModelingToolkit.dump_unknowns(sys)
+@test length(unk_meta) == 3
+@test all(iszero, meta.default for meta in unk_meta)
+param_meta = ModelingToolkit.dump_parameters(sys)
+@test length(param_meta) == 3
+@test all(!haskey(meta, :default) for meta in param_meta)
 
 p = tunable_parameters(sys)
 sp = Set(p)
@@ -68,21 +88,23 @@ b = getbounds(sys)
 b = getbounds(sys, unknowns(sys))
 @test b[x] == (-10, 10)
 
-p = tunable_parameters(sys, default = true)
+p = tunable_parameters(sys, default = false)
 sp = Set(p)
 @test k ∈ sp
-@test T ∈ sp
-@test k2 ∈ sp
-@test length(p) == 3
+@test T ∉ sp
+@test k2 ∉ sp
+@test length(p) == 1
 
 ## Descriptions
 @variables u [description = "This is my input"]
 @test getdescription(u) == "This is my input"
 @test hasdescription(u)
+@test ModelingToolkit.dump_variable_metadata(u).desc == "This is my input"
 
 @variables u
 @test getdescription(u) == ""
 @test !hasdescription(u)
+@test !haskey(ModelingToolkit.dump_variable_metadata(u), :desc)
 
 @parameters t
 @variables u(t) [description = "A short description of u"]