Add SimulateSettings, configurable solver, and fixture-based tests

Introduce SimulateSettings struct so the ODE solver can be selected via
configure_simulate!() or passed directly to run_simulate/test_model/main.
Switch the default solver from Rodas5P to Rodas5Pr and log resolved
solver settings (abstol, reltol, adaptive, dense, saveat) by calling
init() before solve().

Split runtests.jl into per-concern files and add two fixture-based tests
that run without OMC: BusUsage (no-state model, saveat-grid path) and
AmplifierWithOpAmpDetailed (parse + simulate + reference verification).
Copy the required .bmo files and MAP-LIB reference results into
test/fixtures/.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: AnHeuermann

src/BaseModelicaLibraryTesting.jl

@@ -4,7 +4,7 @@ import Pkg
 import OMJulia
 import OMJulia: sendExpression
 import BaseModelica
-import DifferentialEquations: init, solve, ReturnCode
+import DifferentialEquations
 import OrdinaryDiffEqBDF
 import ModelingToolkit
 import Dates: now
@@ -22,11 +22,12 @@ include("pipeline.jl")
 # ── Public API ─────────────────────────────────────────────────────────────────
 
 # Shared types and constants
-export ModelResult, CompareSettings, RunInfo
+export ModelResult, CompareSettings, SimulateSettings, RunInfo
 export LIBRARY, LIBRARY_VERSION, CMP_REL_TOL, CMP_ABS_TOL
 
 # Comparison configuration
 export configure_comparison!, compare_settings
+export configure_simulate!, simulate_settings
 
 # Pipeline phases
 export run_export       # Phase 1: Base Modelica export via OMC

src/pipeline.jl

@@ -58,7 +58,9 @@ end
 Run the four-phase pipeline for a single model and return its result.
 """
 function test_model(omc::OMJulia.OMCSession, model::String, results_root::String,
-                    ref_root::String; csv_max_size_mb::Int = CSV_MAX_SIZE_MB)::ModelResult
+                    ref_root::String;
+                    sim_settings   ::SimulateSettings = _SIM_SETTINGS,
+                    csv_max_size_mb::Int              = CSV_MAX_SIZE_MB)::ModelResult
     model_dir = joinpath(results_root, "files", model)
     mkpath(model_dir)
 
@@ -93,6 +95,7 @@ function test_model(omc::OMJulia.OMCSession, model::String, results_root::String
 
     # Phase 3 ──────────────────────────────────────────────────────────────────
     sim_ok, sim_t, sim_err, sol = run_simulate(ode_prob, model_dir, model;
+                                               settings = sim_settings,
                                                csv_max_size_mb, cmp_signals)
 
     # Phase 4 (optional) ───────────────────────────────────────────────────────
@@ -132,6 +135,7 @@ function main(;
     results_root     :: String                = "",
     ref_root         :: String                = get(ENV, "MAPLIB_REF", ""),
     bm_options       :: String                = get(ENV, "BM_OPTIONS", "scalarize,moveBindings,inlineFunctions"),
+    sim_settings     :: SimulateSettings      = _SIM_SETTINGS,
     csv_max_size_mb  :: Int                   = CSV_MAX_SIZE_MB,
 )
     t0 = time()
@@ -200,7 +204,7 @@ function main(;
 
         for (i, model) in enumerate(models)
             @info "[$i/$(length(models))] $model"
-            result = test_model(omc, model, results_root, ref_root; csv_max_size_mb)
+            result = test_model(omc, model, results_root, ref_root; sim_settings, csv_max_size_mb)
             push!(results, result)
 
             phase = if result.sim_success && result.cmp_total > 0

src/simulate.jl

@@ -1,15 +1,50 @@
 # ── Phase 3: ODE simulation with DifferentialEquations / MTK ──────────────────
 
-import DifferentialEquations: init, solve, ReturnCode
+import DifferentialEquations
 import OrdinaryDiffEqBDF
 import Logging
 import ModelingToolkit
 import Printf: @sprintf
 
+"""Module-level default simulation settings.  Modify via `configure_simulate!`."""
+const _SIM_SETTINGS = SimulateSettings(solver = DifferentialEquations.Rodas5Pr())
+
+"""
+    configure_simulate!(; solver, saveat_n) → SimulateSettings
+
+Update the module-level simulation settings in-place and return them.
+
+# Keyword arguments
+- `solver`   — any SciML ODE/DAE algorithm instance (e.g. `FBDF()`, `Rodas5P()`).
+- `saveat_n` — number of uniform time points for purely algebraic systems.
+
+# Example
+
+```julia
+using OrdinaryDiffEqBDF
+configure_simulate!(solver = FBDF())
+```
+"""
+function configure_simulate!(;
+    solver   :: Union{Any,Nothing} = nothing,
+    saveat_n :: Union{Int,Nothing} = nothing,
+)
+    isnothing(solver)   || (_SIM_SETTINGS.solver   = solver)
+    isnothing(saveat_n) || (_SIM_SETTINGS.saveat_n = saveat_n)
+    return _SIM_SETTINGS
+end
+
+"""
+    simulate_settings() → SimulateSettings
+
+Return the current module-level simulation settings.
+"""
+simulate_settings() = _SIM_SETTINGS
+
 """
-    run_simulate(ode_prob, model_dir, model; cmp_signals, csv_max_size_mb) → (success, time, error, sol)
+    run_simulate(ode_prob, model_dir, model; settings, cmp_signals, csv_max_size_mb) → (success, time, error, sol)
 
-Solve `ode_prob` with FBDF (stiff solver).  On success, also writes the
+Solve `ode_prob` using the algorithm in `settings.solver`.  On success, also writes the
 solution as a CSV file `<Short>_sim.csv` in `model_dir`.
 Writes a `<model>_sim.log` file in `model_dir`.
 Returns `nothing` as the fourth element on failure.
@@ -21,10 +56,12 @@ of signals will be compared.
 CSV files larger than `csv_max_size_mb` MiB are replaced with a
 `<Short>_sim.csv.toobig` marker so that the report can note the omission.
 """
-function run_simulate(ode_prob, model_dir::String,
+function run_simulate(ode_prob,
+                      model_dir::String,
                       model::String;
-                      cmp_signals    ::Vector{String} = String[],
-                      csv_max_size_mb::Int            = CSV_MAX_SIZE_MB)::Tuple{Bool,Float64,String,Any}
+                      settings       ::SimulateSettings = _SIM_SETTINGS,
+                      cmp_signals    ::Vector{String}   = String[],
+                      csv_max_size_mb::Int              = CSV_MAX_SIZE_MB)::Tuple{Bool,Float64,String,Any}
     sim_success           = false
     sim_time              = 0.0
     sim_error             = ""
@@ -35,8 +72,9 @@ function run_simulate(ode_prob, model_dir::String,
     println(log_file, "Model:   $model")
     logger = Logging.SimpleLogger(log_file, Logging.Debug)
     t0 = time()
+
+    solver = settings.solver
     try
-        # FBDF handles stiff DAE-like systems and purely algebraic systems well.
         # Redirect all library log output (including Symbolics/MTK warnings)
         # to the log file so they don't clutter stdout.
         sol = Logging.with_logger(logger) do
@@ -46,27 +84,36 @@ function run_simulate(ode_prob, model_dir::String,
             # Supply explicit time points so observed variables can be evaluated.
             sys    = ode_prob.f.sys
             saveat = isempty(ModelingToolkit.unknowns(sys)) ?
-                         collect(range(ode_prob.tspan[1], ode_prob.tspan[end]; length = 500)) :
+                         collect(range(ode_prob.tspan[1], ode_prob.tspan[end]; length = settings.saveat_n)) :
                          Float64[]
             kwargs = (saveat = saveat, dense = true)
 
-            # Log solver settings
-            initializedSolver = init(ode_prob, OrdinaryDiffEqBDF.FBDF(); kwargs...)
-            solver_settings_string =
-            """
-            OrdinaryDiffEqBDF.FBDF()
-                saveat:   $(let sv = initializedSolver.opts.saveat; isempty(sv) ? "[]" : "$(length(sv)) points in [$(first(sv)), $(last(sv))]" end)
-                abstol:   $(@sprintf("%.2e", initializedSolver.opts.abstol))
-                reltol:   $(@sprintf("%.2e", initializedSolver.opts.reltol))
-                adaptive: $(initializedSolver.opts.adaptive)
-                dense:    $(initializedSolver.opts.dense)
-            """
+            # Log solver settings — init returns NullODEIntegrator (no .opts)
+            # when the problem has no unknowns (u::Nothing), so only inspect
+            # opts when a real integrator is returned.
+            integ = DifferentialEquations.init(ode_prob, solver; kwargs...)
+            solver_settings_string = if hasproperty(integ, :opts)
+                sv = integ.opts.saveat
+                """
+                Solver $(parentmodule(typeof(solver))).$(nameof(typeof(solver)))
+                    saveat:   $(isempty(sv) ? "[]" : "$(length(sv)) points in [$(first(sv)), $(last(sv))]")
+                    abstol:   $(@sprintf("%.2e", integ.opts.abstol))
+                    reltol:   $(@sprintf("%.2e", integ.opts.reltol))
+                    adaptive: $(integ.opts.adaptive)
+                    dense:    $(integ.opts.dense)
+                """
+            else
+                sv_str = isempty(saveat) ? "[]" : "$(length(saveat)) points in [$(first(saveat)), $(last(saveat))]"
+                "Solver (NullODEIntegrator — no unknowns)
+                    saveat: $sv_str
+                    dense:  true"
+            end
 
             # Solve
-            solve(ode_prob, OrdinaryDiffEqBDF.FBDF(); kwargs...)
+            DifferentialEquations.solve(ode_prob, OrdinaryDiffEqBDF.FBDF(); kwargs...)
         end
         sim_time = time() - t0
-        if sol.retcode == ReturnCode.Success
+        if sol.retcode == DifferentialEquations.ReturnCode.Success
             sys    = sol.prob.f.sys
             n_vars = length(ModelingToolkit.unknowns(sys))
             n_obs  = length(ModelingToolkit.observed(sys))
@@ -84,7 +131,7 @@ function run_simulate(ode_prob, model_dir::String,
         sim_time  = time() - t0
         sim_error = sprint(showerror, e, catch_backtrace())
     end
-    println(log_file, "Solver settings: $solver_settings_string")
+    println(log_file, solver_settings_string)
     println(log_file, "Time: $(round(sim_time; digits=3)) s")
     println(log_file, "Success: $sim_success")
     isempty(sim_error) || println(log_file, "\n--- Error ---\n$sim_error")

src/types.jl

@@ -37,6 +37,25 @@ Base.@kwdef mutable struct CompareSettings
     error_fn :: Symbol  = :mixed
 end
 
+# ── Simulation settings ────────────────────────────────────────────────────────
+
+"""
+    SimulateSettings
+
+Mutable configuration struct for ODE simulation.
+
+# Fields
+- `solver`   — any SciML ODE/DAE algorithm instance.  Default: `nothing`,
+               resolved to `Rodas5Pr()` when the module-level singleton is
+               constructed in `simulate.jl`.
+- `saveat_n` — number of evenly-spaced time points used for purely algebraic
+               systems (all mass-matrix rows zero).  Default: `500`.
+"""
+Base.@kwdef mutable struct SimulateSettings
+    solver   :: Any = nothing
+    saveat_n :: Int = 500
+end
+
 # ── Run metadata ───────────────────────────────────────────────────────────────
 
 """

test/amplifier_with_op_amp.jl

@@ -0,0 +1,28 @@
+@testset "AmplifierWithOpAmpDetailed verification" begin
+    model    = "Modelica.Electrical.Analog.Examples.AmplifierWithOpAmpDetailed"
+    bmo_path = joinpath(FIXTURES, "$model.bmo")
+    ref_dir  = joinpath(FIXTURES, "AmplifierWithOpAmpDetailed")
+    ref_csv  = joinpath(ref_dir, "AmplifierWithOpAmpDetailed.csv")
+    sig_file = joinpath(ref_dir, "comparisonSignals.txt")
+    signals  = String.(filter(s -> lowercase(s) != "time" && !isempty(s),
+                              strip.(readlines(sig_file))))
+    mktempdir() do tmpdir
+        par_ok, _, par_err, ode_prob = run_parse(bmo_path, tmpdir, model)
+        @test par_ok
+        par_ok || @warn "Parse error: $par_err"
+
+        if par_ok
+            sim_ok, _, sim_err, sol = run_simulate(ode_prob, tmpdir, model;
+                                                   cmp_signals = signals)
+            @test sim_ok
+            sim_ok || @warn "Simulation error: $sim_err"
+
+            if sim_ok
+                total, pass, skip, _ = compare_with_reference(
+                    sol, ref_csv, tmpdir, model; signals)
+                @test pass == total
+                @info "AmplifierWithOpAmpDetailed: $pass/$total signals pass (skip=$skip)"
+            end
+        end
+    end
+end

test/bus_usage.jl

@@ -0,0 +1,17 @@
+@testset "BusUsage simulation (no states)" begin
+    # Modelica.Blocks.Examples.BusUsage has no unknowns after structural_simplify.
+    # The saveat-grid path in run_simulate must handle this without error.
+    model    = "Modelica.Blocks.Examples.BusUsage"
+    bmo_path = joinpath(FIXTURES, "$model.bmo")
+    mktempdir() do tmpdir
+        par_ok, _, par_err, ode_prob = run_parse(bmo_path, tmpdir, model)
+        @test par_ok
+        par_ok || @warn "Parse error: $par_err"
+
+        if par_ok
+            sim_ok, _, sim_err, _ = run_simulate(ode_prob, tmpdir, model)
+            @test sim_ok
+            sim_ok || @warn "Simulation error: $sim_err"
+        end
+    end
+end

test/chua_circuit.jl

@@ -0,0 +1,31 @@
+@testset "ChuaCircuit pipeline" begin
+    tmpdir    = mktempdir()
+    model_dir = joinpath(tmpdir, "files", TEST_MODEL_CHUA)
+    mkpath(model_dir)
+    bm_path = replace(abspath(joinpath(model_dir, "$TEST_MODEL_CHUA.bmo")), "\\" => "/")
+
+    omc = OMJulia.OMCSession(TEST_OMC)
+    try
+        OMJulia.sendExpression(omc, """setCommandLineOptions("--baseModelica --baseModelicaOptions=scalarize,moveBindings -d=evaluateAllParameters")""")
+        ok = OMJulia.sendExpression(omc, """loadModel(Modelica, {"4.1.0"})""")
+        @test ok == true
+
+        exp_ok, _, exp_err = run_export(omc, TEST_MODEL_CHUA, model_dir, bm_path)
+        @test exp_ok
+        exp_ok || @warn "Export error: $exp_err"
+
+        if exp_ok
+            par_ok, _, par_err, ode_prob = run_parse(bm_path, model_dir, TEST_MODEL_CHUA)
+            @test par_ok
+            par_ok || @warn "Parse error: $par_err"
+
+            if par_ok
+                sim_ok, _, sim_err, _ = run_simulate(ode_prob, model_dir, TEST_MODEL_CHUA)
+                @test sim_ok
+                sim_ok || @warn "Simulation error: $sim_err"
+            end
+        end
+    finally
+        OMJulia.quit(omc)
+    end
+end