Merge pull request #31 from asinghvi17/as/dyad

Add Dyad component and refactor MTK extension

Author: langestefan

Project.toml

@@ -29,7 +29,7 @@ Aqua = "0.8"
 Dates = "1"
 DocStringExtensions = "0.8, 0.9"
 Makie = "0.24"
-ModelingToolkit = "10.3.0 - 10.26.1"
+ModelingToolkit = "10.3.0"
 OhMyThreads = "0.8"
 StructArrays = "0.7"
 Symbolics = "6,7"

dyad/solarpositionblock.dyad

@@ -0,0 +1,31 @@
+type Observer = Native
+type SolarAlgorithm = Native
+type RefractionAlgorithm = Native
+
+"""
+Predict the Sun's position at a given `observer` location at the current time (in seconds)
+and output the `azimuth`, `elevation`, and `zenith` angles.
+
+### Time Convention
+
+The simulation time is assumed to be in **seconds** from the reference time `t0`. For example:
+- `t = 0` corresponds to `t0`
+- `t = 3600` corresponds to `t0 + 1 hour`
+- `t = 86400` corresponds to `t0 + 24 hours`
+"""
+external component SolarPositionBlock
+    "Solar azimuth angle in degrees (0° = North, 90° = East, 180° = South, 270° = West)"
+    azimuth = RealOutput()
+    "Solar elevation angle in degrees (angle above horizon, positive when sun is visible)"
+    elevation = RealOutput()
+    "Solar zenith angle in degrees (angle from vertical, complementary to elevation: `zenith = 90° - elevation`)"
+    zenith = RealOutput()
+
+    parameter t0::Real
+    "location (latitude, longitude, altitude).  Construct via the `SolarPosition.Observer(lat, long, alt)` constructor."
+    parameter observer::Observer
+    "Solar positioning algorithm.  Must be a subtype of `SolarPosition.SolarAlgorithm`."
+    parameter algorithm::SolarAlgorithm = PSA()
+    "Atmospheric refraction correction.  Must be a subtype of `SolarPosition.RefractionAlgorithm`."
+    parameter refraction::RefractionAlgorithm = NoRefraction()
+end

ext/SolarPositionModelingToolkitExt.jl

@@ -4,7 +4,7 @@ using SolarPosition: Observer, SolarAlgorithm, RefractionAlgorithm, PSA, NoRefra
 using SolarPosition: SolPos, ApparentSolPos, SPASolPos, AbstractApparentSolPos
 using ModelingToolkit: @parameters, @variables, System
 using ModelingToolkit: t_nounits as t
-using Dates: DateTime, Millisecond
+using Dates: Dates, DateTime, Millisecond
 import Symbolics
 
 import SolarPosition: SolarPositionBlock, solar_position
@@ -23,28 +23,39 @@ get_zenith(pos::SolPos) = pos.zenith
 get_elevation(pos::AbstractApparentSolPos) = pos.apparent_elevation
 get_zenith(pos::AbstractApparentSolPos) = pos.apparent_zenith
 
-Symbolics.@register_symbolic seconds_to_datetime(t_sec, t0::DateTime)
+Symbolics.@register_symbolic seconds_to_datetime(t_sec, t0::DateTime)::DateTime
 Symbolics.@register_symbolic solar_position(
     observer::Observer,
     time::DateTime,
     algorithm::SolarAlgorithm,
     refraction::RefractionAlgorithm,
 )
 
-Symbolics.@register_symbolic get_azimuth(pos)
-Symbolics.@register_symbolic get_elevation(pos)
-Symbolics.@register_symbolic get_zenith(pos)
+Symbolics.@register_symbolic get_azimuth(pos)::Real
+Symbolics.@register_symbolic get_elevation(pos)::Real
+Symbolics.@register_symbolic get_zenith(pos)::Real
 
-function SolarPositionBlock(; name)
-    @parameters t0::DateTime [tunable = false] observer::Observer [tunable = false]
-    @parameters algorithm::SolarAlgorithm = PSA() [tunable = false]
-    @parameters refraction::RefractionAlgorithm = NoRefraction() [tunable = false]
+function SolarPositionBlock(;
+    name,
+    t0 = Dates.now(),
+    observer = Observer(0.0, 0.0, 0.0),
+    algorithm = PSA(),
+    refraction = NoRefraction(),
+)
+    @parameters t0::DateTime = t0 [tunable = false]
+    @parameters observer::Observer = observer [tunable = false]
+    @parameters algorithm::SolarAlgorithm = algorithm [tunable = false]
+    @parameters refraction::RefractionAlgorithm = refraction [tunable = false]
 
     @variables azimuth(t) [output = true]
     @variables elevation(t) [output = true]
     @variables zenith(t) [output = true]
 
-    time_expr = Symbolics.term(seconds_to_datetime, t, t0; type = DateTime)
+    # Ideally this should be expressed by a symbolic equation
+    # but because it would involve some amount of type manipulation,
+    # we can keep it this way for now.
+    # But this might cause the position to be recalculated thrice (I think)
+    time_expr = seconds_to_datetime(t, t0)
     pos = solar_position(observer, time_expr, algorithm, refraction)
 
     eqs = [
@@ -53,7 +64,13 @@ function SolarPositionBlock(; name)
         zenith ~ get_zenith(pos),
     ]
 
-    return System(eqs, t; name = name)
+    return System(
+        eqs,
+        t,
+        #=vars=#[azimuth, elevation, zenith],
+        #=params=#[t0, observer, algorithm, refraction];
+        name = name,
+    )
 end
 
 end # module SolarPositionModelingToolkitExt