Merge pull request #2802 from SciML/revert-2798-lowerplus

Revert "Bye bye ₊, use var symbols with ."

Author: YingboMa

docs/src/basics/Composition.md

@@ -37,10 +37,10 @@ connected = compose(
 equations(connected)
 
 #4-element Vector{Equation}:
-# Differential(t)(decay1.f(t)) ~ 0
-# decay2.f(t) ~ decay1.x(t)
-# Differential(t)(decay1.x(t)) ~ decay1.f(t) - (decay1.a*(decay1.x(t)))
-# Differential(t)(decay2.x(t)) ~ decay2.f(t) - (decay2.a*(decay2.x(t)))
+# Differential(t)(decay1₊f(t)) ~ 0
+# decay2₊f(t) ~ decay1₊x(t)
+# Differential(t)(decay1₊x(t)) ~ decay1₊f(t) - (decay1₊a*(decay1₊x(t)))
+# Differential(t)(decay2₊x(t)) ~ decay2₊f(t) - (decay2₊a*(decay2₊x(t)))
 
 simplified_sys = structural_simplify(connected)
 
@@ -149,27 +149,27 @@ p = [a, b, c, d, e, f]
 level0 = ODESystem(Equation[], t, [], p; name = :level0)
 level1 = ODESystem(Equation[], t, [], []; name = :level1) ∘ level0
 parameters(level1)
-#level0.a
+#level0₊a
 #b
 #c
-#level0.d
-#level0.e
+#level0₊d
+#level0₊e
 #f
 level2 = ODESystem(Equation[], t, [], []; name = :level2) ∘ level1
 parameters(level2)
-#level1.level0.a
-#level1.b
+#level1₊level0₊a
+#level1₊b
 #c
-#level0.d
-#level1.level0.e
+#level0₊d
+#level1₊level0₊e
 #f
 level3 = ODESystem(Equation[], t, [], []; name = :level3) ∘ level2
 parameters(level3)
-#level2.level1.level0.a
-#level2.level1.b
-#level2.c
-#level2.level0.d
-#level1.level0.e
+#level2₊level1₊level0₊a
+#level2₊level1₊b
+#level2₊c
+#level2₊level0₊d
+#level1₊level0₊e
 #f
 ```
 

docs/src/basics/Events.md

@@ -172,10 +172,10 @@ When accessing variables of a sub-system, it can be useful to rename them
 (alternatively, an affect function may be reused in different contexts):
 
 ```julia
-[x ~ 0] => (affect!, [resistor.v => :v, x], [p, q => :p2], [], ctx)
+[x ~ 0] => (affect!, [resistor₊v => :v, x], [p, q => :p2], [], ctx)
 ```
 
-Here, the symbolic variable `resistor.v` is passed as `v` while the symbolic
+Here, the symbolic variable `resistor₊v` is passed as `v` while the symbolic
 parameter `q` has been renamed `p2`.
 
 As an example, here is the bouncing ball example from above using the functional

docs/src/tutorials/domain_connections.md

@@ -115,7 +115,7 @@ end
 nothing #hide
 ```
 
-To see how the domain works, we can examine the set parameter values for each of the ports `src.port` and `vol.port`.  First we assemble the system using `structural_simplify()` and then check the default value of `vol.port.ρ`, whichs points to the setter value `fluid.ρ`.  Likewise, `src.port.ρ`, will also point to the setter value `fluid.ρ`.  Therefore, there is now only 1 defined density value `fluid.ρ` which sets the density for the connected network.
+To see how the domain works, we can examine the set parameter values for each of the ports `src.port` and `vol.port`.  First we assemble the system using `structural_simplify()` and then check the default value of `vol.port.ρ`, whichs points to the setter value `fluid₊ρ`.  Likewise, `src.port.ρ`, will also point to the setter value `fluid₊ρ`.  Therefore, there is now only 1 defined density value `fluid₊ρ` which sets the density for the connected network.
 
 ```@repl domain
 sys = structural_simplify(odesys)
@@ -181,7 +181,7 @@ end
 nothing #hide
 ```
 
-After running `structural_simplify()` on `actsys2`, the defaults will show that `act.port_a.ρ` points to `fluid_a.ρ` and `act.port_b.ρ` points to `fluid_b.ρ`.  This is a special case, in most cases a hydraulic system will have only 1 fluid, however this simple system has 2 separate domain networks.  Therefore, we can connect a single fluid to both networks.  This does not interfere with the mathematical equations of the system, since no unknown variables are connected.
+After running `structural_simplify()` on `actsys2`, the defaults will show that `act.port_a.ρ` points to `fluid_a₊ρ` and `act.port_b.ρ` points to `fluid_b₊ρ`.  This is a special case, in most cases a hydraulic system will have only 1 fluid, however this simple system has 2 separate domain networks.  Therefore, we can connect a single fluid to both networks.  This does not interfere with the mathematical equations of the system, since no unknown variables are connected.
 
 ```@example domain
 @component function ActuatorSystem1(; name)

src/inputoutput.jl

@@ -71,11 +71,11 @@ function is_bound(sys, u, stack = [])
     In the following scenario
     julia> observed(syss)
         2-element Vector{Equation}:
-        sys.y(tv) ~ sys.x(tv)
-        y(tv) ~ sys.x(tv)
-    sys.y(t) is bound to the outer y(t) through the variable sys.x(t) and should thus return is_bound(sys.y(t)) = true.
-    When asking is_bound(sys.y(t)), we know that we are looking through observed equations and can thus ask
-    if var is bound, if it is, then sys.y(t) is also bound. This can lead to an infinite recursion, so we maintain a stack of variables we have previously asked about to be able to break cycles
+        sys₊y(tv) ~ sys₊x(tv)
+        y(tv) ~ sys₊x(tv)
+    sys₊y(t) is bound to the outer y(t) through the variable sys₊x(t) and should thus return is_bound(sys₊y(t)) = true.
+    When asking is_bound(sys₊y(t)), we know that we are looking through observed equations and can thus ask
+    if var is bound, if it is, then sys₊y(t) is also bound. This can lead to an infinite recursion, so we maintain a stack of variables we have previously asked about to be able to break cycles
     =#
     u ∈ Set(stack) && return false # Cycle detected
     eqs = equations(sys)
@@ -119,17 +119,17 @@ function same_or_inner_namespace(u, var)
     nv = get_namespace(var)
     nu == nv ||           # namespaces are the same
         startswith(nv, nu) || # or nv starts with nu, i.e., nv is an inner namespace to nu
-        occursin('.', string(getname(var))) &&
-            !occursin('.', string(getname(u))) # or u is top level but var is internal
+        occursin('₊', string(getname(var))) &&
+            !occursin('₊', string(getname(u))) # or u is top level but var is internal
 end
 
 function inner_namespace(u, var)
     nu = get_namespace(u)
     nv = get_namespace(var)
     nu == nv && return false
     startswith(nv, nu) || # or nv starts with nu, i.e., nv is an inner namespace to nu
-        occursin('.', string(getname(var))) &&
-            !occursin('.', string(getname(u))) # or u is top level but var is internal
+        occursin('₊', string(getname(var))) &&
+            !occursin('₊', string(getname(u))) # or u is top level but var is internal
 end
 
 """
@@ -139,11 +139,11 @@ Return the namespace of a variable as a string. If the variable is not namespace
 """
 function get_namespace(x)
     sname = string(getname(x))
-    parts = split(sname, '.')
+    parts = split(sname, '₊')
     if length(parts) == 1
         return ""
     end
-    join(parts[1:(end - 1)], '.')
+    join(parts[1:(end - 1)], '₊')
 end
 
 """

src/systems/abstractsystem.jl

@@ -365,8 +365,8 @@ function SymbolicIndexingInterface.is_variable(sys::AbstractSystem, sym::Symbol)
         return is_variable(ic, sym)
     end
     return any(isequal(sym), getname.(variable_symbols(sys))) ||
-           count('.', string(sym)) == 1 &&
-           count(isequal(sym), Symbol.(nameof(sys), :., getname.(variable_symbols(sys)))) ==
+           count('₊', string(sym)) == 1 &&
+           count(isequal(sym), Symbol.(nameof(sys), :₊, getname.(variable_symbols(sys)))) ==
            1
 end
 
@@ -399,9 +399,9 @@ function SymbolicIndexingInterface.variable_index(sys::AbstractSystem, sym::Symb
     idx = findfirst(isequal(sym), getname.(variable_symbols(sys)))
     if idx !== nothing
         return idx
-    elseif count('.', string(sym)) == 1
+    elseif count('₊', string(sym)) == 1
         return findfirst(isequal(sym),
-            Symbol.(nameof(sys), :., getname.(variable_symbols(sys))))
+            Symbol.(nameof(sys), :₊, getname.(variable_symbols(sys))))
     end
     return nothing
 end
@@ -431,9 +431,9 @@ function SymbolicIndexingInterface.is_parameter(sys::AbstractSystem, sym::Symbol
         return is_parameter(ic, sym)
     end
     return any(isequal(sym), getname.(parameter_symbols(sys))) ||
-           count('.', string(sym)) == 1 &&
+           count('₊', string(sym)) == 1 &&
            count(isequal(sym),
-        Symbol.(nameof(sys), :., getname.(parameter_symbols(sys)))) == 1
+        Symbol.(nameof(sys), :₊, getname.(parameter_symbols(sys)))) == 1
 end
 
 function SymbolicIndexingInterface.parameter_index(sys::AbstractSystem, sym)
@@ -466,9 +466,9 @@ function SymbolicIndexingInterface.parameter_index(sys::AbstractSystem, sym::Sym
     idx = findfirst(isequal(sym), getname.(parameter_symbols(sys)))
     if idx !== nothing
         return idx
-    elseif count('.', string(sym)) == 1
+    elseif count('₊', string(sym)) == 1
         return findfirst(isequal(sym),
-            Symbol.(nameof(sys), :., getname.(parameter_symbols(sys))))
+            Symbol.(nameof(sys), :₊, getname.(parameter_symbols(sys))))
     end
     return nothing
 end
@@ -889,7 +889,7 @@ function renamespace(sys, x)
     elseif x isa AbstractSystem
         rename(x, renamespace(sys, nameof(x)))
     else
-        Symbol(getname(sys), :., x)
+        Symbol(getname(sys), :₊, x)
     end
 end
 
@@ -1248,7 +1248,7 @@ function round_trip_eq(eq::Equation, var2name)
         syss = get_systems(eq.rhs)
         call = Expr(:call, connect)
         for sys in syss
-            strs = split(string(nameof(sys)), ".")
+            strs = split(string(nameof(sys)), "₊")
             s = Symbol(strs[1])
             for st in strs[2:end]
                 s = Expr(:., s, Meta.quot(Symbol(st)))

src/systems/callbacks.jl

@@ -512,24 +512,6 @@ function generate_rootfinding_callback(cbs, sys::AbstractODESystem, dvs = unknow
     end
 end
 
-# Put a wrapper on NamedTuple so that u.resistor.v indexes like u.var"resistor.v"
-# Required for hierarchical, but a hack that should be fixed in the future
-struct NamedTupleSymbolFix{T}
-    x::T
-    sym::Symbol
-end
-NamedTupleSymbolFix(x) = NamedTupleSymbolFix(x, Symbol(""))
-function Base.getproperty(u::NamedTupleSymbolFix, s::Symbol)
-    newsym = getfield(u, :sym) == Symbol("") ? s : Symbol(getfield(u, :sym), ".", s)
-    x = getfield(u, :x)
-    if newsym in keys(x)
-        getproperty(x, newsym)
-    else
-        NamedTupleSymbolFix(x, newsym)
-    end
-end
-Base.getindex(u::NamedTupleSymbolFix, idxs::Int...) = getfield(u, :x)[idxs...]
-
 function compile_user_affect(affect::FunctionalAffect, sys, dvs, ps; kwargs...)
     dvs_ind = Dict(reverse(en) for en in enumerate(dvs))
     v_inds = map(sym -> dvs_ind[sym], unknowns(affect))
@@ -544,10 +526,9 @@ function compile_user_affect(affect::FunctionalAffect, sys, dvs, ps; kwargs...)
     # HACK: filter out eliminated symbols. Not clear this is the right thing to do
     # (MTK should keep these symbols)
     u = filter(x -> !isnothing(x[2]), collect(zip(unknowns_syms(affect), v_inds))) |>
-        NamedTuple |> NamedTupleSymbolFix
-
+        NamedTuple
     p = filter(x -> !isnothing(x[2]), collect(zip(parameters_syms(affect), p_inds))) |>
-        NamedTuple |> NamedTupleSymbolFix
+        NamedTuple
 
     let u = u, p = p, user_affect = func(affect), ctx = context(affect)
         function (integ)

src/systems/connectors.jl

@@ -129,7 +129,7 @@ function generate_isouter(sys::AbstractSystem)
         function isouter(sys)::Bool
             s = string(nameof(sys))
             isconnector(sys) || error("$s is not a connector!")
-            idx = findfirst(isequal('.'), s)
+            idx = findfirst(isequal('₊'), s)
             parent_name = Symbol(idx === nothing ? s : s[1:prevind(s, idx)])
             parent_name in outer_connectors
         end

test/funcaffect.jl

@@ -123,7 +123,7 @@ i8 = findfirst(==(8.0), sol[:t])
 ctx = [0]
 function affect4!(integ, u, p, ctx)
     ctx[1] += 1
-    @test u.resistor.v == 1
+    @test u.resistor₊v == 1
 end
 s1 = compose(
     ODESystem(Equation[], t, [], [], name = :s1,
@@ -137,7 +137,7 @@ sol = solve(prob, Tsit5())
 include("../examples/rc_model.jl")
 
 function affect5!(integ, u, p, ctx)
-    @test integ.u[u.capacitor.v] ≈ 0.3
+    @test integ.u[u.capacitor₊v] ≈ 0.3
     integ.ps[p.C] *= 200
 end
 

test/input_output_handling.jl

@@ -34,8 +34,8 @@ end
 @test get_namespace(x) == ""
 @test get_namespace(sys.x) == "sys"
 @test get_namespace(sys2.x) == "sys2"
-@test get_namespace(sys2.sys.x) == "sys2.sys"
-@test get_namespace(sys21.sys1.v) == "sys21.sys1"
+@test get_namespace(sys2.sys.x) == "sys2₊sys"
+@test get_namespace(sys21.sys1.v) == "sys21₊sys1"
 
 @test !is_bound(sys, u)
 @test !is_bound(sys, x)

test/inputoutput.jl

@@ -19,8 +19,8 @@ connected = ODESystem(Equation[], t, [], [], observed = connections,
 
 sys = connected
 
-@variables lorenz1.F lorenz2.F
-@test pins(connected) == Variable[lorenz1.F, lorenz2.F]
+@variables lorenz1₊F lorenz2₊F
+@test pins(connected) == Variable[lorenz1₊F, lorenz2₊F]
 @test isequal(observed(connected),
     [connections...,
         lorenz1.u ~ lorenz1.x + lorenz1.y - lorenz1.z,
@@ -40,7 +40,7 @@ simplifyeqs(eqs) = Equation.((x -> x.lhs).(eqs), simplify.((x -> x.rhs).(eqs)))
 
 @test isequal(simplifyeqs(equations(connected)), simplifyeqs(collapsed_eqs))
 
-# Variables indicated to be input/output
+# Variables indicated to be input/output 
 @variables x [input = true]
 @test hasmetadata(x, Symbolics.option_to_metadata_type(Val(:input)))
 @test getmetadata(x, Symbolics.option_to_metadata_type(Val(:input))) == true

test/odesystem.jl

@@ -1109,9 +1109,9 @@ function RealExpressionSystem(; name)
     vars = @variables begin
         x(t)
         z(t)[1:1]
-    end # doing a collect on z doesn't work either.
-    @named e1 = RealExpression(y = x) # This works perfectly.
-    @named e2 = RealExpression(y = z[1]) # This bugs. However, `full_equations(e2)` works as expected.
+    end # doing a collect on z doesn't work either. 
+    @named e1 = RealExpression(y = x) # This works perfectly. 
+    @named e2 = RealExpression(y = z[1]) # This bugs. However, `full_equations(e2)` works as expected. 
     systems = [e1, e2]
     ODESystem(Equation[], t, Iterators.flatten(vars), []; systems, name)
 end
@@ -1166,7 +1166,7 @@ end
 # Namespacing of array variables
 @variables x(t)[1:2]
 @named sys = ODESystem(Equation[], t)
-@test getname(unknowns(sys, x)) == Symbol("sys.x")
+@test getname(unknowns(sys, x)) == :sys₊x
 @test size(unknowns(sys, x)) == size(x)
 
 # Issue#2667

test/variable_scope.jl

@@ -31,25 +31,25 @@ eqs = [0 ~ a
 
 names = ModelingToolkit.getname.(unknowns(sys))
 @test :d in names
-@test Symbol("sub1.c") in names
-@test Symbol("sub1.sub2.b") in names
-@test Symbol("sub1.sub2.sub3.a") in names
-@test Symbol("sub1.sub2.sub4.a") in names
+@test Symbol("sub1₊c") in names
+@test Symbol("sub1₊sub2₊b") in names
+@test Symbol("sub1₊sub2₊sub3₊a") in names
+@test Symbol("sub1₊sub2₊sub4₊a") in names
 
 @named foo = NonlinearSystem(eqs, [a, b, c, d], [])
 @named bar = NonlinearSystem(eqs, [a, b, c, d], [])
 @test ModelingToolkit.getname(ModelingToolkit.namespace_expr(
     ModelingToolkit.namespace_expr(b,
         foo),
-    bar)) == Symbol("bar.b")
+    bar)) == Symbol("bar₊b")
 
 function renamed(nss, sym)
     ModelingToolkit.getname(foldr(ModelingToolkit.renamespace, nss, init = sym))
 end
 
-@test renamed([:foo :bar :baz], a) == Symbol("foo.bar.baz.a")
-@test renamed([:foo :bar :baz], b) == Symbol("foo.bar.b")
-@test renamed([:foo :bar :baz], c) == Symbol("foo.c")
+@test renamed([:foo :bar :baz], a) == Symbol("foo₊bar₊baz₊a")
+@test renamed([:foo :bar :baz], b) == Symbol("foo₊bar₊b")
+@test renamed([:foo :bar :baz], c) == Symbol("foo₊c")
 @test renamed([:foo :bar :baz], d) == :d
 
 @parameters t a b c d e f
@@ -67,12 +67,12 @@ level3 = ODESystem(Equation[], t, [], []; name = :level3) ∘ level2
 
 ps = ModelingToolkit.getname.(parameters(level3))
 
-@test isequal(ps[1], Symbol("level2.level1.level0.a"))
-@test isequal(ps[2], Symbol("level2.level1.b"))
-@test isequal(ps[3], Symbol("level2.c"))
-@test isequal(ps[4], Symbol("level2.level0.d"))
-@test isequal(ps[5], Symbol("level1.level0.e"))
-@test isequal(ps[6], Symbol("f"))
+@test isequal(ps[1], :level2₊level1₊level0₊a)
+@test isequal(ps[2], :level2₊level1₊b)
+@test isequal(ps[3], :level2₊c)
+@test isequal(ps[4], :level2₊level0₊d)
+@test isequal(ps[5], :level1₊level0₊e)
+@test isequal(ps[6], :f)
 
 # Issue@2252
 # Tests from PR#2354
@@ -82,4 +82,4 @@ arr0 = ODESystem(Equation[], t, [], arr_p; name = :arr0)
 arr1 = ODESystem(Equation[], t, [], []; name = :arr1) ∘ arr0
 arr_ps = ModelingToolkit.getname.(parameters(arr1))
 @test isequal(arr_ps[1], Symbol("xx"))
-@test isequal(arr_ps[2], Symbol("arr0.xx"))
+@test isequal(arr_ps[2], Symbol("arr0₊xx"))