refactor: update the arglist of non-dsl components to match the style of dsl components

- this will allow upgradation of those without breaking again

Author: ven-k

docs/src/connectors/connections.md

@@ -18,7 +18,7 @@ The idea behind the selection of the **through** variable is that it should be a
 ```math
 \begin{aligned}
     \partial {\color{blue}{across}} / \partial t \cdot c_1 = {\color{green}{through}}  \\
-    {\color{green}{through}} \cdot c_2 = {\color{blue}{across}} 
+    {\color{green}{through}} \cdot c_2 = {\color{blue}{across}}
 \end{aligned}
 ```
 
@@ -29,7 +29,7 @@ For the Electrical domain, the across variable is *voltage* and the through vari
   - Energy Dissipation:
 
 ```math
-\partial {\color{blue}{voltage}} / \partial t \cdot capacitance = {\color{green}{current}} 
+\partial {\color{blue}{voltage}} / \partial t \cdot capacitance = {\color{green}{current}}
 ```
 
   - Flow:
@@ -45,13 +45,13 @@ For the translation domain, choosing *velocity* for the across variable and *for
   - Energy Dissipation:
 
 ```math
-\partial {\color{blue}{velocity}} / \partial t \cdot mass = {\color{green}{force}} 
+\partial {\color{blue}{velocity}} / \partial t \cdot mass = {\color{green}{force}}
 ```
 
   - Flow:
 
 ```math
-{\color{green}{force}} \cdot (1/damping) = {\color{blue}{velocity}} 
+{\color{green}{force}} \cdot (1/damping) = {\color{blue}{velocity}}
 ```
 
 The diagram here shows the similarity of problems in different physical domains.
@@ -65,13 +65,13 @@ Now, if we choose *position* for the across variable, a similar relationship can
   - Energy Dissipation:
 
 ```math
-\partial^2 {\color{blue}{position}} / \partial t^2 \cdot mass = {\color{green}{force}} 
+\partial^2 {\color{blue}{position}} / \partial t^2 \cdot mass = {\color{green}{force}}
 ```
 
   - Flow:
 
 ```math
-{\color{green}{force}} \cdot (1/damping) = \partial {\color{blue}{position}} / \partial t 
+{\color{green}{force}} \cdot (1/damping) = \partial {\color{blue}{position}} / \partial t
 ```
 
 As can be seen, we must now establish a higher order derivative to define the Energy Dissipation and Flow equations, requiring an extra equation, as will be shown in the example below.
@@ -134,7 +134,7 @@ Now using the Translational library based on velocity, we can see the same relat
 using ModelingToolkitStandardLibrary
 const TV = ModelingToolkitStandardLibrary.Mechanical.Translational
 
-@named damping = TV.Damper(d = 1, v_a_0 = 1)
+@named damping = TV.Damper(d = 1, va = 1)
 @named body = TV.Mass(m = 1, v_0 = 1)
 @named ground = TV.Fixed()
 
@@ -167,7 +167,7 @@ Now, let's consider the position-based approach.  We can build the same model wi
 ```@example connections
 const TP = ModelingToolkitStandardLibrary.Mechanical.TranslationalPosition
 
-@named damping = TP.Damper(d = 1, v_a_0 = 1)
+@named damping = TP.Damper(d = 1, va = 1)
 @named body = TP.Mass(m = 1, v_0 = 1)
 @named ground = TP.Fixed(s_0 = 0)
 
@@ -220,21 +220,21 @@ In this problem, we have a mass, spring, and damper which are connected to a fix
 
 #### Damper
 
-The damper will connect the flange/flange 1 (`flange_a`) to the mass, and flange/flange 2 (`flange_b`) to the fixed point.  For both position- and velocity-based domains, we set the damping constant `d=1` and `v_a_0=1` and leave the default for `v_b_0` at 0.  For the position domain, we also need to set the initial positions for `flange_a` and `flange_b`.
+The damper will connect the flange/flange 1 (`flange_a`) to the mass, and flange/flange 2 (`flange_b`) to the fixed point.  For both position- and velocity-based domains, we set the damping constant `d=1` and `va=1` and leave the default for `v_b_0` at 0.  For the position domain, we also need to set the initial positions for `flange_a` and `flange_b`.
 
 ```@example connections
-@named dv = TV.Damper(d = 1, v_a_0 = 1)
-@named dp = TP.Damper(d = 1, v_a_0 = 1, s_a_0 = 3, s_b_0 = 1)
+@named dv = TV.Damper(d = 1, va = 1)
+@named dp = TP.Damper(d = 1, va = 1, flange_a__s = 3, flange_b__s = 1)
 nothing # hide
 ```
 
 #### Spring
 
-The spring will connect the flange/flange 1 (`flange_a`) to the mass, and flange/flange 2 (`flange_b`) to the fixed point.  For both position- and velocity-based domains, we set the spring constant `k=1`.  The velocity domain then requires the initial velocity `v_a_0` and initial spring stretch `delta_s_0`.  The position domain instead needs the initial positions for `flange_a` and `flange_b` and the natural spring length `l`.
+The spring will connect the flange/flange 1 (`flange_a`) to the mass, and flange/flange 2 (`flange_b`) to the fixed point.  For both position- and velocity-based domains, we set the spring constant `k=1`.  The velocity domain then requires the initial velocity `va` and initial spring stretch `delta_s`.  The position domain instead needs the initial positions for `flange_a` and `flange_b` and the natural spring length `l`.
 
 ```@example connections
-@named sv = TV.Spring(k = 1, v_a_0 = 1, delta_s_0 = 1)
-@named sp = TP.Spring(k = 1, s_a_0 = 3, s_b_0 = 1, l = 1)
+@named sv = TV.Spring(k = 1, va = 1, delta_s = 1)
+@named sp = TP.Spring(k = 1, flange_a__s = 3, flange_b__s = 1, l = 1)
 nothing # hide
 ```
 

src/Hydraulic/IsothermalCompressible/components.jl

@@ -506,7 +506,7 @@ dm ────►               │  │ area
 
     ports = @named begin
         port = HydraulicPort(; p_int)
-        flange = MechanicalPort(; f_int = p_int * area)
+        flange = MechanicalPort(; f = p_int * area)
         damper = ValveBase(; p_a_int = p_int, p_b_int = p_int, area_int = 1, Cd,
             Cd_reverse, minimum_area)
     end

src/Mechanical/Translational/components.jl

@@ -58,23 +58,22 @@ Sliding mass with inertia
 
   - `flange`: 1-dim. translational flange
 """
-@component function Mass(; name, v_0 = 0.0, m, s_0 = nothing, g = nothing)
+@component function Mass(; name, v = 0.0, m, s = nothing, g = nothing)
     pars = @parameters begin
         m = m
-        v_0 = v_0
     end
+    @named flange = MechanicalPort(; v = v)
+
     vars = @variables begin
-        v(t) = v_0
+        v(t) = v
         f(t) = 0
     end
 
-    @named flange = MechanicalPort()
-
     eqs = [flange.v ~ v
         flange.f ~ f]
 
     # gravity option
-    if !isnothing(g)
+    if g !== nothing
         @parameters g = g
         push!(pars, g)
         push!(eqs, D(v) ~ f / m + g)
@@ -83,99 +82,86 @@ Sliding mass with inertia
     end
 
     # position option
-    if !isnothing(s_0)
-        @parameters s_0 = s_0
-        push!(pars, s_0)
-
-        @variables s(t) = s_0
+    if s !== nothing
+        @variables s(t) = s
         push!(vars, s)
 
         push!(eqs, D(s) ~ v)
     end
 
-    return compose(ODESystem(eqs, t, vars, pars; name = name, defaults = [flange.v => v_0]),
+    return compose(ODESystem(eqs, t, vars, pars; name = name),
         flange)
 end
 
 const REL = Val(:relative)
 
 """
-    Spring(; name, k, delta_s_0 = 0.0,  v_a_0=0.0, v_b_0=0.0)
+    Spring(; name, k, delta_s = 0.0,  va=0.0, v_b_0=0.0)
 
 Linear 1D translational spring
 
 # Parameters:
 
   - `k`: [N/m] Spring constant
-  - `delta_s_0`: initial spring stretch
-  - `v_a_0`: [m/s] Initial value of absolute linear velocity at flange_a (default 0 m/s)
+  - `delta_s`: initial spring stretch
+  - `va`: [m/s] Initial value of absolute linear velocity at flange_a (default 0 m/s)
   - `v_b_0`: [m/s] Initial value of absolute linear velocity at flange_b (default 0 m/s)
 
 # Connectors:
 
   - `flange_a`: 1-dim. translational flange on one side of spring
   - `flange_b`: 1-dim. translational flange on opposite side of spring
 """
-@component function Spring(; name, k, delta_s_0 = 0.0, v_a_0 = 0.0, v_b_0 = 0.0)
-    Spring(REL; name, k, delta_s_0, v_a_0, v_b_0)
+@component function Spring(; name, k, delta_s = 0.0, flange_a__v = 0.0, flange_b__v = 0.0)
+    Spring(REL; name, k, delta_s, flange_a__v, flange_b__v)
 end # default
 
-@component function Spring(::Val{:relative}; name, k, delta_s_0 = 0.0, v_a_0 = 0.0,
-    v_b_0 = 0.0)
+@component function Spring(::Val{:relative}; name, k, delta_s = 0.0, flange_a__v = 0.0,
+    flange_b__v = 0.0)
     pars = @parameters begin
         k = k
-        delta_s_0 = delta_s_0
-        v_a_0 = v_a_0
-        v_b_0 = v_b_0
     end
     vars = @variables begin
-        delta_s(t) = delta_s_0
+        delta_s(t) = delta_s
         f(t) = 0
     end
 
-    @named flange_a = MechanicalPort()
-    @named flange_b = MechanicalPort()
+    @named flange_a = MechanicalPort(; v = flange_a__v)
+    @named flange_b = MechanicalPort(; v = flange_b__v)
 
     eqs = [D(delta_s) ~ flange_a.v - flange_b.v
         f ~ k * delta_s
         flange_a.f ~ +f
         flange_b.f ~ -f]
-    return compose(ODESystem(eqs, t, vars, pars; name = name,
-            defaults = [flange_a.v => v_a_0, flange_b.v => v_b_0]),
+    return compose(ODESystem(eqs, t, vars, pars; name = name),
         flange_a,
-        flange_b) #flange_a.f => +k*delta_s_0, flange_b.f => -k*delta_s_0
+        flange_b) #flange_a.f => +k*delta_s, flange_b.f => -k*delta_s
 end
 
 const ABS = Val(:absolute)
-@component function Spring(::Val{:absolute}; name, k, s_a_0 = 0, s_b_0 = 0, v_a_0 = 0.0,
-    v_b_0 = 0.0,
-    l = 0)
+@component function Spring(::Val{:absolute}; name, k, sa = 0, sb = 0, flange_a__v = 0.0,
+    flange_b__v = 0.0, l = 0)
     pars = @parameters begin
         k = k
-        s_a_0 = s_a_0
-        s_b_0 = s_b_0
-        v_a_0 = v_a_0
-        v_b_0 = v_b_0
         l = l
     end
     vars = @variables begin
-        s1(t) = s_a_0
-        s2(t) = s_b_0
+        sa(t) = sa
+        sb(t) = sb
         f(t) = 0
     end
 
-    @named flange_a = MechanicalPort()
-    @named flange_b = MechanicalPort()
+    @named flange_a = MechanicalPort(; v = flange_a__v)
+    @named flange_b = MechanicalPort(; v = flange_b__v)
 
-    eqs = [D(s1) ~ flange_a.v
-        D(s2) ~ flange_b.v
-        f ~ k * (s1 - s2 - l) #delta_s
+    eqs = [D(sa) ~ flange_a.v
+        D(sb) ~ flange_b.v
+        f ~ k * (sa - sb - l) #delta_s
         flange_a.f ~ +f
         flange_b.f ~ -f]
-    return compose(ODESystem(eqs, t, vars, pars; name = name,
-            defaults = [flange_a.v => v_a_0, flange_b.v => v_b_0]),
+    return compose(ODESystem(eqs, t, vars, pars; name = name,),
         flange_a,
-        flange_b) #, flange_a.f => k * (s_a_0 - s_b_0 - l)
+        flange_b) #, flange_a.f => k * (flange_a__s - flange_b__s - l)
 end
 
 """
@@ -213,3 +199,9 @@ Linear 1D translational damper
         flange_b.f ~ -f
     end
 end
+
+
+#=
+
+
+=#

src/Mechanical/Translational/sources.jl

@@ -29,53 +29,49 @@ Linear 1D position input source
   - `flange`: 1-dim. translational flange
   - `s`: real input. `s.u_start` accepts initial value and defaults to 0.0.
 """
-@mtkmodel Position begin
-    @parameters begin
-        solves_force = false
-    end
-    @components begin
-        flange = MechanicalPort(; v = 0.0)
-        s = RealInput(; u_start = 0.0)
-    end
-    @variables begin
-        x(t)
-    end
-    @equations begin
-        D(x) ~ flange.v
-        s.u ~ x
-        !getdefault(solves_force) && 0 ~ flange.f
+@component function Position(; solves_force = true, s__u_start = 0, name)
+    systems = @named begin
+        flange = MechanicalPort()
+        s = RealInput()
     end
+
+    vars = @variables x(t)
+
+    eqs = [D(x) ~ flange.v
+        s.u ~ x]
+
+    !solves_force && push!(eqs, 0 ~ flange.f)
+
+    ODESystem(eqs, t, vars, []; name, systems, defaults = [flange.v => 0, s.u => s__u_start])
 end
 
-@mtkmodel Velocity begin
-    @parameters begin
-        solves_force = false
-    end
-    @components begin
+@component function Velocity(; solves_force = true, name)
+    systems = @named begin
         flange = MechanicalPort()
         v = RealInput()
     end
-    @equations begin
-        v.u ~ flange.v
-        getdefault(solves_force) && 0 ~ flange.f
-    end
+
+    eqs = [
+        v.u ~ flange.v,
+    ]
+
+    !solves_force && push!(eqs, 0 ~ flange.f)
+
+    ODESystem(eqs, t, [], []; name, systems, defaults = [flange.v => 0])
 end
 
-@mtkmodel Acceleration begin
-    @parameters begin
-        solves_force = false
-    end
-    @components begin
-        flange = MechanicalPort(; v = 0.0)
-        a = RealInput()
-    end
-    @variables begin
-        v(t) = 0
+@component function Acceleration(solves_force = true; s__u_start = 0, name)
+    systems = @named begin
+        flange = MechanicalPort()
+        a = RealInput(; u_start = s__u_start)
     end
 
-    @equations begin
-        v ~ flange.v
-        D(v) ~ a.u
-        !getdefault(solves_force) && 0 ~ flange.f
-    end
-end
+    vars = @variables v(t) = 0
+
+    eqs = [v ~ flange.v
+        D(v) ~ a.u]
+
+    !solves_force && push!(eqs, 0 ~ flange.f)
+
+    ODESystem(eqs, t, vars, []; name, systems, defaults = [flange.v => 0])
+end