update import functions

Author: hexaeder

ext/NetworkDynamicsMTKExt.jl

@@ -99,8 +99,26 @@ the symbol vector in
 - `Directed(dstout)`.
 
 Additional `kwargs` are the same as for the double-sided EdgeModel MTK constructor.
+
+Instead of wrapping, you can also provide the annotation as keyword argument like `annotation=:AntiSymmetric`.
 """
-EdgeModel(sys::ODESystem, srcin, dstin, dstout; kwargs...) = EdgeModel(sys, srcin, dstin, nothing, dstout; kwargs...)
+function EdgeModel(sys::ODESystem, srcin, dstin, dstout::AnnotatedSym; kwargs...)
+    EdgeModel(sys, srcin, dstin, nothing, dstout; kwargs...)
+end
+function EdgeModel(sys::ODESystem, srcin, dstin, dstout; annotation=nothing, kwargs...)
+    _dstout = if annotation==:AntiSymmetric
+        AntiSymmetric(dstout)
+    elseif annotation==:Symmetric
+        Symmetric(dstout)
+    elseif annotation==:Directed
+        Directed(dstout)
+    else
+        throw(ArgumentError("When constructing single sided EdgeModel, you must either wrap \
+            the output syms (e.g. AntiSymmetric(dstout)) orprovide the annotation as keyword \
+            argument."))
+    end
+    EdgeModel(sys, srcin, dstin, nothing, _dstout; kwargs...)
+end
 
 """
     EdgeModel(sys::ODESystem, srcin, srcout, dstin, dstout;

src/importexport.jl

@@ -103,6 +103,34 @@ function depth_first_flatten!(container::Union{OrderedDict,Vector})
     nothing
 end
 
+widen_container_type(container::OrderedDict{K}) where {K} = convert(OrderedDict{K,Any}, container)
+widen_container_type(container::Vector) = convert(Vector{Any}, container)
+
+replace_in_template!(template, placeholder, model) = template
+function replace_in_template!(container::Union{OrderedDict,Vector}, placeholder, model)
+    container = widen_container_type(container)
+    for (key, value) in pairs(container)
+        if value == placeholder
+            container[key] = deepcopy(model)
+        else
+            container[key] = replace_in_template!(value, placeholder, model)
+        end
+    end
+    container
+end
+
+apply_wrappers!(::Nothing) = nothing
+function apply_wrappers!(container::Union{OrderedDict,Vector})
+    haskey(container, "WRAPPER") || return
+
+    wrapper = container["WRAPPER"]
+    delete!(container, "WRAPPER")
+    for (key, sub) in pairs(container)
+        container[key] = replace_in_template!(wrapper, "MODEL", sub)
+    end
+    container
+end
+
 function parse_network(file)
     data = YAML.load_file(file, dicttype=OrderedDict{Any,Any})
     dependencies = OrderedDict(keys(data["Models"]) .=> map(collect_model_dependencies, values(data["Models"])))
@@ -131,9 +159,13 @@ function parse_network(file)
         error("Could not resolve all dependencies")
     end
 
+    # apply wrappers to all models
+    apply_wrappers!(data["VertexModels"])
+    apply_wrappers!(data["EdgeModels"])
+
     # with all deps resolve, we can replace the models edge and vertex list
-    recursive_resolve!(data["Models"], data["Vertices"])
-    recursive_resolve!(data["Models"], data["Edges"])
+    recursive_resolve!(data["Models"], data["VertexModels"])
+    recursive_resolve!(data["Models"], data["EdgeModels"])
 
     # traverses the tree and flattens the model properties, i.e. merges
     # the local given properties with the parent/template model properties
@@ -144,24 +176,12 @@ end
 recursive_construct(constructors, data) = _depth_first_construct!(constructors, deepcopy(data))
 _depth_first_construct!(_, data) = data
 _depth_first_construct!(_, s::String) = startswith(s, ":") ? Symbol(s[2:end]) : s
-function _depth_first_construct!(constructors, data::Vector)
-    if data isa Vector && eltype(data) !== Any
-        data = convert(Vector{Any}, data)
-    end
-    for (key, value) in pairs(data)
-        data[key] = _depth_first_construct!(constructors, value)
-    end
-    data
-end
-function _depth_first_construct!(constructors, data::OrderedDict)
-    if data isa OrderedDict && eltype(values(data)) !== Any
-        data = convert(OrderedDict{eltype(keys(data)), Any}, data)
-    end
-
+function _depth_first_construct!(constructors, data::Union{OrderedDict,Vector})
+    data = widen_container_type(data)
     for (key, value) in pairs(data)
         data[key] = _depth_first_construct!(constructors, value)
     end
-    if haskey(data, "CONSTRUCTOR")
+    if data isa OrderedDict && haskey(data, "CONSTRUCTOR")
         if !haskey(constructors, data["CONSTRUCTOR"])
             error("No constructor found for $(data["CONSTRUCTOR"])")
         end
@@ -178,21 +198,26 @@ end
 
 function build_network(data, constructors)
     vertexm = VertexModel[]
-    for (k, v) in data["Vertices"]
+    for (k, v) in data["VertexModels"]
         vm = recursive_construct(constructors, v)
         set_graphelement!(vm, k)
         push!(vertexm, vm)
     end
+
     edgem   = EdgeModel[]
-    for (k, v) in data["Vertices"]
+    for (k, v) in data["VertexModels"]
         vm = recursive_construct(constructors, v)
 
         m = match(r"^(.*)=>(.*)$", k)
         isnothing(m) && error("Edge key must be of form 'src=>dst', got $k")
         src = tryparse(Int, m[1])
         dst = tryparse(Int, m[2])
-        isnothing(src) && src = m[1]
-        isnothing(dst) && src = m[1]
+        if isnothing(src)
+            src = m[1]
+        end
+        if isnothing(dst)
+            dst = m[1]
+        end
         set_graphelement!(vm, src, dst)
         push!(vertexm, vm)
     end

test/importexport_test.jl

@@ -1,6 +1,7 @@
 using NetworkDynamics
 using ModelingToolkit
 using ModelingToolkit: t_nounits as t, D_nounits as Dt
+using StableRNGs
 
 @mtkmodel Swing begin
     @variables begin
@@ -35,8 +36,8 @@ end
 end
 
 @mtkmodel StaticPowerLine begin
-    @structural_parameters begin
-        K = 1.63 # structural parameter to keep them out of nw parameters
+    @parameters begin
+        K = 1.63, [description = "line conductance parameter"]
     end
     @variables begin
         srcθ(t), [description = "voltage angle at src end", input=true]
@@ -55,29 +56,59 @@ function CombinedModel(subsystems...; kwargs...)
         θ(t) = 0.0, [description = "voltage angle", output=true]
         Pel(t), [description = "Electical power flowing from network into node", input=true]
     end
-    θ_eqs   = [θ ~ sub.θ for sub in subsystes]
-    Pel_eqs = [Pel ~ sub.Pel for sub in subsystems]
-    ODESystem(; kwargs...)
+    eqs = [
+        (θ ~ sub.θ for sub in subsystems)...,
+        Pel ~ +((sub.Pel for sub in subsystems)...) # kirchoff constaint
+    ]
+    ODESystem(eqs, t, [θ, Pel], []; systems=collect(subsystems), kwargs...)
+end
+
+v1 = let
+    @named swing = Swing(; Pmech=1.0, M=1.0, D=1.0)
+    VertexModel(swing, [:Pel], [:θ], vidx=1)
+end
+
+v2 = let
+    @named load = Load(; Pd=-1.0)
+    VertexModel(load, [:Pel], [:θ], vidx=2)
+end
+
+v3 = let
+    @named swing = Swing(; Pmech=1.0, M=1.0, D=1.0)
+    @named load = Load(; Pd=-2.0)
+    @named swingload = CombinedModel(swing, load)
+    VertexModel(swingload, [:Pel], [:θ], vidx=3)
+end
+
+v4 = let
+    @named swing = Swing(; Pmech=2.0, M=1.0, D=1.0)
+    @named load = Load(; Pd=-1.0)
+    @named swingload2 = CombinedModel(swing, load)
+    VertexModel(swingload2, [:Pel], [:θ], vidx=4)
 end
 
-mtk_models = [
-    Swing(Pmech=1, M=1, D=1.0; name=:G1),
-    Load(Pload; name=:L2),
-    Swing(Pmech=1, M=1, D=1.0; name=:G2),
-    Load(Pload; name=:L3),
-    Swing(Pmech=1, M=1, D=1.0; name=:G3),
-    Load(Pload; name=:L4),
-];
+e1 = let
+    @named line = StaticPowerLine(; K=0.5)
+    EdgeModel(line, [:srcθ], [:dstθ], [:P]; annotation=:AntiSymmetric, src=1, dst=2)
+end
+e2 = let
+    @named line = StaticPowerLine(; K=1.0)
+    EdgeModel(line, [:srcθ], [:dstθ], [:P]; annotation=:AntiSymmetric, src=2, dst=3)
+end
+e3 = let
+    @named line = StaticPowerLine()
+    EdgeModel(line, [:srcθ], [:dstθ], [:P]; annotation=:AntiSymmetric, src=3, dst=4)
+end
 
-vertexmodels = map(mtk_models) do mtk_model
-    VertexModel(mtk_model, [:Pel], [:θ])
-end;
-vertexmodels2 = map(mtk_models2) do mtk_model
-    VertexModel(mtk_model, [:Pel], [:θ])
-end;
+nw = Network([v1,v2,v3,v4],[e1,e2,e3])
 
+rng = StableRNG(1)
+u = randn(rng, dim(nw))
+du1 = [NaN for _ in 1:dim(nw)]
+nw(du1, u, pflat(NWState(nw)), NaN)
 
 data = NetworkDynamics.parse_network("testgrid.yaml")
+data["VertexModels"][1]
 
 constructors = Dict("Swing"=>Swing, "VertexModel"=>VertexModel, "Load"=>Load)
 NetworkDynamics.build_network(data, constructors)

test/testgrid.yaml

@@ -0,0 +1,57 @@
+title: Power Grid Example
+version: "1.0"
+description: 6 Bus Powergrid Toy Example
+
+# special words are "MODEL", "CONSTRUCTOR", "ARGS", "WRAPPER"
+Models:
+  Swing:
+    CONSTRUCTOR: Swing
+    name: :swing
+    Pmech: 1
+    M: 1
+    D: 1.0
+
+  Load:  # base models have known constructor
+    CONSTRUCTOR: Load
+    name: :load
+    Pd: -1.0
+
+  DerivedLoad:
+    MODEL: Models.Load
+    Pd: 2
+
+  Swing_And_Load:
+    CONSTRUCTOR: CombinedModel
+    ARGS:
+      - Models.Swing
+      - MODEL: Models.Load
+        Pd: 2
+    name: "combined model"
+
+  DerivedSwing_And_Load:
+    MODEL: Models.Swing_And_Load
+    ARGS[1].Pd: 3
+
+  DerivedSwing_And_Load2:
+    MODEL: Models.Swing_And_Load
+    ARGS[1]:
+      Pd: 4
+      name: :foo
+
+  StaticPowerLine:
+    CONSTRUCTOR: StaticPowerLine
+
+VertexModels:
+  WRAPPER:
+    CONSTRUCTOR: VertexModel
+    ARGS:
+      - MODEL
+      - [":Pel"]
+      - [":θ"]
+  1:
+    MODEL: Models.Swing
+  2:
+    MODEL: Models.Load
+    Pd: 1
+
+EdgeModels: