Merge pull request #2148 from SciML/myb/generic_consistency

Make consistency check more generic

Author: YingboMa

src/structural_transformation/StructuralTransformations.jl

@@ -23,7 +23,7 @@ using ModelingToolkit: ODESystem, AbstractSystem, var_from_nested_derivative, Di
                        IncrementalCycleTracker, add_edge_checked!, topological_sort,
                        invalidate_cache!, Substitutions, get_or_construct_tearing_state,
                        AliasGraph, filter_kwargs, lower_varname, setio, SparseMatrixCLIL,
-                       fast_substitute
+                       fast_substitute, get_fullvars, has_equations
 
 using ModelingToolkit.BipartiteGraphs
 import .BipartiteGraphs: invview, complete

src/structural_transformation/utils.jl

@@ -12,15 +12,21 @@ function BipartiteGraphs.maximal_matching(s::SystemStructure, eqfilter = eq -> t
     maximal_matching(s.graph, eqfilter, varfilter)
 end
 
+n_concrete_eqs(state::TransformationState) = n_concrete_eqs(state.structure)
+n_concrete_eqs(structure::SystemStructure) = n_concrete_eqs(structure.graph)
+function n_concrete_eqs(graph::BipartiteGraph)
+    neqs = count(e -> !isempty(𝑠neighbors(graph, e)), 𝑠vertices(graph))
+end
+
 function error_reporting(state, bad_idxs, n_highest_vars, iseqs, orig_inputs)
     io = IOBuffer()
-    neqs = length(equations(state))
+    neqs = n_concrete_eqs(state)
     if iseqs
         error_title = "More equations than variables, here are the potential extra equation(s):\n"
-        out_arr = equations(state)[bad_idxs]
+        out_arr = has_equations(state) ? equations(state)[bad_idxs] : bad_idxs
     else
         error_title = "More variables than equations, here are the potential extra variable(s):\n"
-        out_arr = state.fullvars[bad_idxs]
+        out_arr = get_fullvars(state)[bad_idxs]
         unset_inputs = intersect(out_arr, orig_inputs)
         n_missing_eqs = n_highest_vars - neqs
         n_unset_inputs = length(unset_inputs)
@@ -52,14 +58,14 @@ end
 ###
 ### Structural check
 ###
-function check_consistency(state::TearingState, ag, orig_inputs)
-    fullvars = state.fullvars
+function check_consistency(state::TransformationState, ag, orig_inputs)
+    fullvars = get_fullvars(state)
+    neqs = n_concrete_eqs(state)
     @unpack graph, var_to_diff = state.structure
     n_highest_vars = count(v -> var_to_diff[v] === nothing &&
                                     !isempty(𝑑neighbors(graph, v)) &&
                                     (ag === nothing || !haskey(ag, v) || ag[v] != v),
                            vertices(var_to_diff))
-    neqs = nsrcs(graph)
     is_balanced = n_highest_vars == neqs
 
     if neqs > 0 && !is_balanced

src/systems/abstractsystem.jl

@@ -238,6 +238,8 @@ for prop in [:eqs
     end
 end
 
+has_equations(::AbstractSystem) = true
+
 const EMPTY_TGRAD = Vector{Num}(undef, 0)
 const EMPTY_JAC = Matrix{Num}(undef, 0, 0)
 function invalidate_cache!(sys::AbstractSystem)

src/systems/systemstructure.jl

@@ -10,7 +10,7 @@ import ..ModelingToolkit: isdiffeq, var_from_nested_derivative, vars!, flatten,
                           isparameter, isconstant,
                           independent_variables, SparseMatrixCLIL, AbstractSystem,
                           equations, isirreducible, input_timedomain, TimeDomain,
-                          VariableType, getvariabletype
+                          VariableType, getvariabletype, has_equations
 using ..BipartiteGraphs
 import ..BipartiteGraphs: invview, complete
 using Graphs
@@ -140,6 +140,7 @@ abstract type TransformationState{T} end
 abstract type AbstractTearingState{T} <: TransformationState{T} end
 
 get_fullvars(ts::TransformationState) = ts.fullvars
+has_equations(::TransformationState) = true
 
 Base.@kwdef mutable struct SystemStructure
     # Maps the (index of) a variable to the (index of) the variable describing