feat: allow build_explicit_function to generate param-only observed

Author: AayushSabharwal

src/systems/diffeqs/odesystem.jl

@@ -380,6 +380,7 @@ function build_explicit_observed_function(sys, ts;
         checkbounds = true,
         drop_expr = drop_expr,
         ps = full_parameters(sys),
+        param_only = false,
         op = Operator,
         throw = true)
     if (isscalar = symbolic_type(ts) !== NotSymbolic())
@@ -392,16 +393,26 @@ function build_explicit_observed_function(sys, ts;
     ivs = independent_variables(sys)
     dep_vars = scalarize(setdiff(vars, ivs))
 
-    obs = observed(sys)
+    obs = param_only ? Equation[] : observed(sys)
+    if has_discrete_subsystems(sys) && (dss = get_discrete_subsystems(sys)) !== nothing
+        # each subsystem is topologically sorted independently. We can append the
+        # equations to override the `lhs ~ 0` equations in `observed(sys)`
+        syss, _, continuous_id, _... = dss
+        for (i, subsys) in enumerate(syss)
+            i == continuous_id && continue
+            append!(obs, observed(subsys))
+        end
+    end
 
     cs = collect_constants(obs)
     if !isempty(cs) > 0
         cmap = map(x -> x => getdefault(x), cs)
         obs = map(x -> x.lhs ~ substitute(x.rhs, cmap), obs)
     end
 
-    sts = Set(unknowns(sys))
-    sts = union(sts,
+    sts = param_only ? Set() : Set(unknowns(sys))
+    sts = param_only ? Set() :
+          union(sts,
         Set(arguments(st)[1] for st in sts if istree(st) && operation(st) === getindex))
 
     observed_idx = Dict(x.lhs => i for (i, x) in enumerate(obs))
@@ -413,7 +424,8 @@ function build_explicit_observed_function(sys, ts;
         Set(arguments(p)[1]
         for p in param_set_ns if istree(p) && operation(p) === getindex))
     namespaced_to_obs = Dict(unknowns(sys, x.lhs) => x.lhs for x in obs)
-    namespaced_to_sts = Dict(unknowns(sys, x) => x for x in unknowns(sys))
+    namespaced_to_sts = param_only ? Dict() :
+                        Dict(unknowns(sys, x) => x for x in unknowns(sys))
 
     # FIXME: This is a rather rough estimate of dependencies. We assume
     # the expression depends on everything before the `maxidx`.
@@ -472,17 +484,18 @@ function build_explicit_observed_function(sys, ts;
     end
     dvs = DestructuredArgs(unknowns(sys), inbounds = !checkbounds)
     if inputs === nothing
-        args = [dvs, ps..., ivs...]
+        args = param_only ? [ps..., ivs...] : [dvs, ps..., ivs...]
     else
         ipts = DestructuredArgs(inputs, inbounds = !checkbounds)
-        args = [dvs, ipts, ps..., ivs...]
+        args = param_only ? [ipts, ps..., ivs...] : [dvs, ipts, ps..., ivs...]
     end
     pre = get_postprocess_fbody(sys)
 
     ex = Func(args, [],
              pre(Let(obsexprs,
                  isscalar ? ts[1] : MakeArray(ts, output_type),
-                 false))) |> wrap_array_vars(sys, ts)[1] |> toexpr
+                 false))) |>
+         wrap_array_vars(sys, ts; dvs = param_only ? [] : unknowns(sys))[1] |> toexpr
     expression ? ex : drop_expr(@RuntimeGeneratedFunction(ex))
 end