diff --git a/lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl b/lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl index fda67f03d6..448af25852 100644 --- a/lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl +++ b/lib/OrdinaryDiffEqAdamsBashforthMoulton/src/OrdinaryDiffEqAdamsBashforthMoulton.jl @@ -10,7 +10,7 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCac trivial_limiter!, get_fsalfirstlast, generic_solver_docstring, full_cache, - _bool_to_ADType + _bool_to_ADType, @SciMLMessage import OrdinaryDiffEqLowOrderRK: BS3ConstantCache, BS3Cache, RK4ConstantCache, RK4Cache import RecursiveArrayTools: recursivefill! using MuladdMacro, FastBroadcast diff --git a/lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl b/lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl index fb7ab3d305..864ec2243d 100644 --- a/lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl +++ b/lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl @@ -21,7 +21,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, step_reject_controller!, post_newton_controller!, u_modified!, DAEAlgorithm, _unwrap_val, DummyController, get_fsalfirstlast, generic_solver_docstring, _bool_to_ADType, - _process_AD_choice + _process_AD_choice, @SciMLMessage using OrdinaryDiffEqSDIRK: ImplicitEulerConstantCache, ImplicitEulerCache using TruncatedStacktraces: @truncate_stacktrace diff --git a/lib/OrdinaryDiffEqCore/Project.toml b/lib/OrdinaryDiffEqCore/Project.toml index 4cf4f09a5e..b88d7339ab 100644 --- a/lib/OrdinaryDiffEqCore/Project.toml +++ b/lib/OrdinaryDiffEqCore/Project.toml @@ -7,6 +7,7 @@ version = "1.36.0" SciMLOperators = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" Reexport = "189a3867-3050-52da-a836-e630ba90ab69" Accessors = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +ConcreteStructs = "2569d6c7-a4a2-43d3-a901-331e8e4be471" StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" FunctionWrappersWrappers = "77dc65aa-8811-40c2-897b-53d922fa7daf" FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" @@ -25,6 +26,7 @@ Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" Preferences = "21216c6a-2e73-6563-6e65-726566657250" +SciMLLogging = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1" SymbolicIndexingInterface = "2efcf032-c050-4f8e-a9bb-153293bab1f5" MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" @@ -50,6 +52,7 @@ SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f" SafeTestsets = "0.1.0" SciMLOperators = "1.4" Accessors = "0.1.36" +ConcreteStructs = "0.2" StaticArraysCore = "1.4.3" SciMLStructures = "1.7" FunctionWrappersWrappers = "0.1" @@ -67,6 +70,7 @@ LinearAlgebra = "1.10" TruncatedStacktraces = "1.4" SimpleUnPack = "1.1" SciMLBase = "2.115" +SciMLLogging = "1.3.1" FastClosures = "0.3" DataStructures = "0.18.22, 0.19" Static = "1.2" diff --git a/lib/OrdinaryDiffEqCore/src/OrdinaryDiffEqCore.jl b/lib/OrdinaryDiffEqCore/src/OrdinaryDiffEqCore.jl index 53e3383b49..10f7f7a75a 100644 --- a/lib/OrdinaryDiffEqCore/src/OrdinaryDiffEqCore.jl +++ b/lib/OrdinaryDiffEqCore/src/OrdinaryDiffEqCore.jl @@ -90,8 +90,14 @@ import Accessors: @reset # SciMLStructures symbols imported but not directly used in OrdinaryDiffEqCore # using SciMLStructures: canonicalize, Tunable, isscimlstructure +using SciMLLogging: SciMLLogging, @SciMLMessage, AbstractVerbositySpecifier, AbstractVerbosityPreset, + None, Minimal, Standard, Detailed, All, Silent, InfoLevel, WarnLevel, ErrorLevel, + CustomLevel, AbstractMessageLevel + using SymbolicIndexingInterface: state_values, parameter_values +using ConcreteStructs: @concrete + const CompiledFloats = Union{Float32, Float64} import Preferences @@ -136,6 +142,7 @@ end include("doc_utils.jl") include("misc_utils.jl") +include("verbosity.jl") include("algorithms.jl") include("composite_algs.jl") diff --git a/lib/OrdinaryDiffEqCore/src/initdt.jl b/lib/OrdinaryDiffEqCore/src/initdt.jl index 991ed87ac9..615b806e3d 100644 --- a/lib/OrdinaryDiffEqCore/src/initdt.jl +++ b/lib/OrdinaryDiffEqCore/src/initdt.jl @@ -128,10 +128,8 @@ # because it also checks if partials are NaN # https://discourse.julialang.org/t/incorporating-forcing-functions-in-the-ode-model/70133/26 if isnan(d₁) - if integrator.opts.verbose - @warn("First function call produced NaNs. Exiting. Double check that none of the initial conditions, parameters, or timespan values are NaN.") - end - + @SciMLMessage("First function call produced NaNs. Exiting. Double check that none of the initial conditions, parameters, or timespan values are NaN.", + integrator.opts.verbose, :init_NaN) return tdir * dtmin end @@ -249,8 +247,10 @@ end d₀ = internalnorm(u0 ./ sk, t) f₀ = f(u0, p, t) - if integrator.opts.verbose && any(x -> any(isnan, x), f₀) - @warn("First function call produced NaNs. Exiting. Double check that none of the initial conditions, parameters, or timespan values are NaN.") + + if any(x -> any(isnan, x), f₀) + @SciMLMessage("First function call produced NaNs. Exiting. Double check that none of the initial conditions, parameters, or timespan values are NaN.", + integrator.opts.verbose, :init_NaN) end inferredtype = Base.promote_op(/, typeof(u0), typeof(oneunit(t))) diff --git a/lib/OrdinaryDiffEqCore/src/integrators/controllers.jl b/lib/OrdinaryDiffEqCore/src/integrators/controllers.jl index 9c58c48432..1348fc2bdd 100644 --- a/lib/OrdinaryDiffEqCore/src/integrators/controllers.jl +++ b/lib/OrdinaryDiffEqCore/src/integrators/controllers.jl @@ -297,7 +297,9 @@ end k = min(alg_order(alg), alg_adaptive_order(alg)) + 1 dt_factor = err1^(beta1 / k) * err2^(beta2 / k) * err3^(beta3 / k) if isnan(dt_factor) - @warn "unlimited dt_factor" dt_factor err1 err2 err3 beta1 beta2 beta3 k + @SciMLMessage("unlimited dt_factor", + integrator.opts.verbose, :unlimited_dt) + #@warn "unlimited dt_factor" dt_factor err1 err2 err3 beta1 beta2 beta3 k end dt_factor = controller.limiter(dt_factor) diff --git a/lib/OrdinaryDiffEqCore/src/integrators/type.jl b/lib/OrdinaryDiffEqCore/src/integrators/type.jl index 7dc9e1a9c6..1c94d2464d 100644 --- a/lib/OrdinaryDiffEqCore/src/integrators/type.jl +++ b/lib/OrdinaryDiffEqCore/src/integrators/type.jl @@ -42,7 +42,7 @@ mutable struct DEOptions{absType, relType, QT, tType, Controller, F1, F2, F3, F4 callback::F4 isoutofdomain::F5 unstable_check::F7 - verbose::Bool + verbose::ODEVerbosity calck::Bool force_dtmin::Bool advance_to_tstop::Bool diff --git a/lib/OrdinaryDiffEqCore/src/solve.jl b/lib/OrdinaryDiffEqCore/src/solve.jl index 6ddd866f87..de112f5dee 100644 --- a/lib/OrdinaryDiffEqCore/src/solve.jl +++ b/lib/OrdinaryDiffEqCore/src/solve.jl @@ -54,7 +54,7 @@ function SciMLBase.__init( internalopnorm = opnorm, isoutofdomain = ODE_DEFAULT_ISOUTOFDOMAIN, unstable_check = ODE_DEFAULT_UNSTABLE_CHECK, - verbose = true, + verbose = ODEVerbosity(), timeseries_errors = true, dense_errors = false, advance_to_tstop = false, @@ -96,14 +96,25 @@ function SciMLBase.__init( error("This solver is not able to use mass matrices. For compatible solvers see https://docs.sciml.ai/DiffEqDocs/stable/solvers/dae_solve/") end + if verbose isa Bool + if verbose + verbose = ODEVerbosity() + else + verbose = ODEVerbosity(None()) + end + elseif verbose isa AbstractVerbosityPreset + verbose = ODEVerbosity(verbose) + end + if alg isa OrdinaryDiffEqRosenbrockAdaptiveAlgorithm && # https://github.com/SciML/OrdinaryDiffEq.jl/pull/2079 fixes this for Rosenbrock23 and 32 !only_diagonal_mass_matrix(alg) && prob.f.mass_matrix isa AbstractMatrix && all(isequal(0), prob.f.mass_matrix) # technically this should also warn for zero operators but those are hard to check for - if (dense || !isempty(saveat)) && verbose - @warn("Rosenbrock methods on equations without differential states do not bound the error on interpolations.") + if (dense || !isempty(saveat)) + @SciMLMessage("Rosenbrock methods on equations without differential states do not bound the error on interpolations.", + verbose, :rosenbrock_no_differential_states) end end @@ -114,7 +125,8 @@ function SciMLBase.__init( end if !isempty(saveat) && dense - @warn("Dense output is incompatible with saveat. Please use the SavingCallback from the Callback Library to mix the two behaviors.") + @SciMLMessage("Dense output is incompatible with saveat. Please use the SavingCallback from the Callback Library to mix the two behaviors.", + verbose, :dense_output_saveat) end progress && @logmsg(LogLevel(-1), progress_name, _id=progress_id, progress=0) @@ -641,9 +653,8 @@ function handle_dt!(integrator) error("Automatic dt setting has the wrong sign. Exiting. Please report this error.") end if isnan(integrator.dt) - if integrator.opts.verbose - @warn("Automatic dt set the starting dt as NaN, causing instability. Exiting.") - end + @SciMLMessage("Automatic dt set the starting dt as NaN, causing instability. Exiting.", + integrator.opts.verbose, :dt_NaN) end elseif integrator.opts.adaptive && integrator.dt > zero(integrator.dt) && integrator.tdir < 0 diff --git a/lib/OrdinaryDiffEqCore/src/verbosity.jl b/lib/OrdinaryDiffEqCore/src/verbosity.jl new file mode 100644 index 0000000000..3af61677e5 --- /dev/null +++ b/lib/OrdinaryDiffEqCore/src/verbosity.jl @@ -0,0 +1,293 @@ +""" + ODEVerbosity <: AbstractVerbositySpecifier + +Verbosity configuration for OrdinaryDiffEq.jl solvers, providing fine-grained control over +diagnostic messages, warnings, and errors during ODE solution. + +# Fields + +## Error Control Group +- `dt_NaN`: Messages when time step becomes NaN +- `init_NaN`: Messages when initial conditions contain NaN +- `dense_output_saveat`: Messages about dense output with saveat +- `max_iters`: Messages when maximum iterations are reached +- `dt_min_unstable`: Messages when time step becomes too small/unstable +- `instability`: Messages when numerical instability is detected +- `newton_convergence`: Messages when Newton iteration fails to converge + +## Performance Group +- `alg_switch`: Messages when algorithm switching occurs +- `mismatched_input_output_type`: Messages when input/output types don't match + +## Numerical Group +- `rosenbrock_no_differential_states`: Messages when Rosenbrock has no differential states +- `shampine_dt`: Messages about Shampine time step selection +- `unlimited_dt`: Messages when time step is unlimited +- `dt_epsilon`: Messages when timestep goes below floating point epsilon + +## Solver Verbosity Groups +- `linear_verbosity`: Verbosity configuration for linear solvers +- `nonlinear_verbosity`: Verbosity configuration for nonlinear solvers + +# Constructors + + ODEVerbosity(preset::AbstractVerbosityPreset) + +Create an `ODEVerbosity` using a preset configuration: +- `SciMLLogging.None()`: All messages disabled +- `SciMLLogging.Minimal()`: Only critical errors and fatal issues +- `SciMLLogging.Standard()`: Balanced verbosity (default) +- `SciMLLogging.Detailed()`: Comprehensive debugging information +- `SciMLLogging.All()`: Maximum verbosity + + ODEVerbosity(; error_control=nothing, performance=nothing, numerical=nothing, linear_verbosity=nothing, nonlinear_verbosity=nothing, kwargs...) + +Create an `ODEVerbosity` with group-level or individual field control. + +# Examples + +```julia +# Use a preset +verbose = ODEVerbosity(SciMLLogging.Standard()) + +# Set entire groups +verbose = ODEVerbosity( + error_control = SciMLLogging.WarnLevel(), + numerical = SciMLLogging.InfoLevel() +) + +# Set individual fields +verbose = ODEVerbosity( + dt_NaN = SciMLLogging.ErrorLevel(), + alg_switch = SciMLLogging.InfoLevel() +) + +# Mix group and individual settings +verbose = ODEVerbosity( + numerical = SciMLLogging.InfoLevel(), # Set all numerical to InfoLevel + unlimited_dt = SciMLLogging.ErrorLevel() # Override specific field +) +``` +""" +@concrete struct ODEVerbosity <: AbstractVerbositySpecifier + # Solver verbosity + linear_verbosity + nonlinear_verbosity + # Error control + dt_NaN + init_NaN + dense_output_saveat + max_iters + dt_min_unstable + instability + newton_convergence + # Performance + alg_switch + mismatched_input_output_type + # Numerical + rosenbrock_no_differential_states + shampine_dt + unlimited_dt + dt_epsilon +end + +# Group classifications +const error_control_options = (:dt_NaN, :init_NaN, :dense_output_saveat, :max_iters, :dt_min_unstable, :instability, :newton_convergence) +const performance_options = (:alg_switch, :mismatched_input_output_type) +const numerical_options = (:rosenbrock_no_differential_states, :shampine_dt, :unlimited_dt, :dt_epsilon) + +function option_group(option::Symbol) + if option in error_control_options + return :error_control + elseif option in performance_options + return :performance + elseif option in numerical_options + return :numerical + else + error("Unknown verbosity option: $option") + end +end + +# Get all options in a group +function group_options(verbosity::ODEVerbosity, group::Symbol) + if group === :error_control + return NamedTuple{error_control_options}(getproperty(verbosity, opt) + for opt in error_control_options) + elseif group === :performance + return NamedTuple{performance_options}(getproperty(verbosity, opt) + for opt in performance_options) + elseif group === :numerical + return NamedTuple{numerical_options}(getproperty(verbosity, opt) + for opt in numerical_options) + else + error("Unknown group: $group") + end +end + + +function ODEVerbosity(; + error_control = nothing, performance = nothing, numerical = nothing, + linear_verbosity = nothing, nonlinear_verbosity = nothing, kwargs...) + # Validate group arguments + if error_control !== nothing && !(error_control isa AbstractMessageLevel) + throw(ArgumentError("error_control must be a SciMLLogging.AbstractMessageLevel, got $(typeof(error_control))")) + end + if performance !== nothing && !(performance isa AbstractMessageLevel) + throw(ArgumentError("performance must be a SciMLLogging.AbstractMessageLevel, got $(typeof(performance))")) + end + if numerical !== nothing && !(numerical isa AbstractMessageLevel) + throw(ArgumentError("numerical must be a SciMLLogging.AbstractMessageLevel, got $(typeof(numerical))")) + end + + # Validate individual kwargs + for (key, value) in kwargs + if !(key in error_control_options || key in performance_options || + key in numerical_options) + throw(ArgumentError("Unknown verbosity option: $key. Valid options are: $(tuple(error_control_options..., performance_options..., numerical_options...))")) + end + if !(value isa AbstractMessageLevel) + throw(ArgumentError("$key must be a SciMLLogging.AbstractMessageLevel, got $(typeof(value))")) + end + end + + # Build arguments using NamedTuple for type stability + default_args = ( + linear_verbosity = linear_verbosity === nothing ? Minimal() : linear_verbosity, + nonlinear_verbosity = nonlinear_verbosity === nothing ? Minimal() : nonlinear_verbosity, + dt_NaN = WarnLevel(), + init_NaN = WarnLevel(), + dense_output_saveat = WarnLevel(), + max_iters = WarnLevel(), + dt_min_unstable = WarnLevel(), + instability = WarnLevel(), + newton_convergence = WarnLevel(), + alg_switch = WarnLevel(), + mismatched_input_output_type = WarnLevel(), + rosenbrock_no_differential_states = WarnLevel(), + shampine_dt = WarnLevel(), + unlimited_dt = WarnLevel(), + dt_epsilon = WarnLevel() + ) + + # Apply group-level settings + final_args = if error_control !== nothing || performance !== nothing || + numerical !== nothing + NamedTuple{keys(default_args)}( + _resolve_arg_value( + key, default_args[key], error_control, performance, numerical) + for key in keys(default_args) + ) + else + default_args + end + + # Apply individual overrides + if !isempty(kwargs) + final_args = merge(final_args, NamedTuple(kwargs)) + end + + ODEVerbosity(values(final_args)...) +end + +# Constructor for verbosity presets following the hierarchical levels: +# None < Minimal < Standard < Detailed < All +# Each level includes all messages from levels below it plus additional ones +function ODEVerbosity(verbose::AbstractVerbosityPreset) + if verbose isa Minimal + # Minimal: Only fatal errors and critical warnings + ODEVerbosity( + linear_verbosity = Minimal(), + nonlinear_verbosity = Minimal(), + dt_NaN = WarnLevel(), + init_NaN = WarnLevel(), + dense_output_saveat = Silent(), + max_iters = WarnLevel(), + dt_min_unstable = WarnLevel(), + instability = WarnLevel(), + newton_convergence = WarnLevel(), + alg_switch = Silent(), + mismatched_input_output_type = Silent(), + rosenbrock_no_differential_states = WarnLevel(), + shampine_dt = Silent(), + unlimited_dt = WarnLevel(), + dt_epsilon = Silent() + ) + elseif verbose isa Standard + # Standard: Everything from Minimal + non-fatal warnings + ODEVerbosity() + elseif verbose isa Detailed + # Detailed: Everything from Standard + debugging/solver behavior + ODEVerbosity( + linear_verbosity = Detailed(), + nonlinear_verbosity = Detailed(), + dt_NaN = WarnLevel(), + init_NaN = WarnLevel(), + dense_output_saveat = InfoLevel(), + max_iters = WarnLevel(), + dt_min_unstable = WarnLevel(), + instability = WarnLevel(), + newton_convergence = WarnLevel(), + alg_switch = InfoLevel(), + mismatched_input_output_type = WarnLevel(), + rosenbrock_no_differential_states = WarnLevel(), + shampine_dt = InfoLevel(), + unlimited_dt = WarnLevel(), + dt_epsilon = InfoLevel() + ) + elseif verbose isa All + # All: Maximum verbosity - every possible logging message at InfoLevel + ODEVerbosity( + linear_verbosity = All(), + nonlinear_verbosity = All(), + dt_NaN = WarnLevel(), + init_NaN = WarnLevel(), + dense_output_saveat = InfoLevel(), + max_iters = WarnLevel(), + dt_min_unstable = WarnLevel(), + instability = WarnLevel(), + newton_convergence = WarnLevel(), + alg_switch = InfoLevel(), + mismatched_input_output_type = InfoLevel(), + rosenbrock_no_differential_states = WarnLevel(), + shampine_dt = InfoLevel(), + unlimited_dt = WarnLevel(), + dt_epsilon = InfoLevel() + ) + end +end + +@inline function ODEVerbosity(verbose::None) + ODEVerbosity( + None(), + None(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent(), + Silent() + ) +end + +# Helper function to resolve argument values based on group membership +@inline function _resolve_arg_value( + key::Symbol, default_val, error_control, performance, numerical) + if key === :linear_verbosity || key === :nonlinear_verbosity + return default_val + elseif key in error_control_options && error_control !== nothing + return error_control + elseif key in performance_options && performance !== nothing + return performance + elseif key in numerical_options && numerical !== nothing + return numerical + else + return default_val + end +end diff --git a/lib/OrdinaryDiffEqDefault/src/OrdinaryDiffEqDefault.jl b/lib/OrdinaryDiffEqDefault/src/OrdinaryDiffEqDefault.jl index ea030b19ca..5873de2582 100644 --- a/lib/OrdinaryDiffEqDefault/src/OrdinaryDiffEqDefault.jl +++ b/lib/OrdinaryDiffEqDefault/src/OrdinaryDiffEqDefault.jl @@ -10,7 +10,7 @@ using OrdinaryDiffEqRosenbrock: Rosenbrock23, Rodas5P using OrdinaryDiffEqBDF: FBDF import OrdinaryDiffEqCore -import OrdinaryDiffEqCore: is_mass_matrix_alg, default_autoswitch, isdefaultalg +import OrdinaryDiffEqCore: is_mass_matrix_alg, default_autoswitch, isdefaultalg, @SciMLMessage import ADTypes: AutoFiniteDiff, AutoForwardDiff, AbstractADType import LinearSolve using LinearAlgebra: I, isdiag diff --git a/lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl b/lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl index 677b81e880..607e7ad268 100644 --- a/lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl +++ b/lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl @@ -6,7 +6,7 @@ import ADTypes: AutoFiniteDiff, AutoForwardDiff, AbstractADType, AutoSparse import ForwardDiff, FiniteDiff import ForwardDiff.Dual import LinearSolve -import LinearSolve: OperatorAssumptions +import LinearSolve: OperatorAssumptions, LinearVerbosity import FunctionWrappersWrappers import DiffEqBase @@ -44,7 +44,7 @@ using OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, OrdinaryDiffEqAdaptiveImplici get_new_W_γdt_cutoff, TryAgain, DIRK, COEFFICIENT_MULTISTEP, NORDSIECK_MULTISTEP, GLM, FastConvergence, Convergence, SlowConvergence, - VerySlowConvergence, Divergence, NLStatus, MethodType, constvalue + VerySlowConvergence, Divergence, NLStatus, MethodType, constvalue, @SciMLMessage import OrdinaryDiffEqCore: get_chunksize, resize_J_W!, resize_nlsolver!, alg_autodiff, _get_fwd_tag diff --git a/lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl b/lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl index 553e128857..86a3671174 100644 --- a/lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl +++ b/lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl @@ -866,10 +866,10 @@ build_uf(alg, nf, t, p, ::Val{false}) = UDerivativeWrapper(nf, t, p) function LinearSolve.init_cacheval( alg::LinearSolve.DefaultLinearSolver, A::WOperator, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) LinearSolve.init_cacheval(alg, A.J, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) end @@ -897,10 +897,10 @@ for alg in [LinearSolve.AppleAccelerateLUFactorization, LinearSolve.SparspakFactorization, LinearSolve.UMFPACKFactorization] @eval function LinearSolve.init_cacheval(alg::$alg, A::WOperator, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) LinearSolve.init_cacheval(alg, A.J, b, u, Pl, Pr, - maxiters::Int, abstol, reltol, verbose::Bool, + maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions) end end diff --git a/lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl b/lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl index 2c5d1d1758..a8491eac32 100644 --- a/lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl +++ b/lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl @@ -6,7 +6,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, alg_stability_size, unwrap_alg, OrdinaryDiffEqMutableCache, initialize!, perform_step!, isfsal, CompositeAlgorithm, calculate_residuals!, calculate_residuals, - full_cache, get_fsalfirstlast + full_cache, get_fsalfirstlast, @SciMLMessage using TruncatedStacktraces: @truncate_stacktrace using RecursiveArrayTools, FastBroadcast, MuladdMacro, DiffEqBase import LinearAlgebra: norm diff --git a/lib/OrdinaryDiffEqExponentialRK/src/OrdinaryDiffEqExponentialRK.jl b/lib/OrdinaryDiffEqExponentialRK/src/OrdinaryDiffEqExponentialRK.jl index ad51a34e39..70af626d91 100644 --- a/lib/OrdinaryDiffEqExponentialRK/src/OrdinaryDiffEqExponentialRK.jl +++ b/lib/OrdinaryDiffEqExponentialRK/src/OrdinaryDiffEqExponentialRK.jl @@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, ismultistep, OrdinaryDiffEqAdaptiveExponentialAlgorithm, CompositeAlgorithm, ExponentialAlgorithm, fsal_typeof, isdtchangeable, calculate_residuals, calculate_residuals!, - full_cache, get_fsalfirstlast, + full_cache, get_fsalfirstlast, @SciMLMessage, generic_solver_docstring, _bool_to_ADType, _process_AD_choice import OrdinaryDiffEqCore using RecursiveArrayTools diff --git a/lib/OrdinaryDiffEqExtrapolation/src/OrdinaryDiffEqExtrapolation.jl b/lib/OrdinaryDiffEqExtrapolation/src/OrdinaryDiffEqExtrapolation.jl index 194b30e166..1affe2d063 100644 --- a/lib/OrdinaryDiffEqExtrapolation/src/OrdinaryDiffEqExtrapolation.jl +++ b/lib/OrdinaryDiffEqExtrapolation/src/OrdinaryDiffEqExtrapolation.jl @@ -18,7 +18,7 @@ import OrdinaryDiffEqCore: alg_order, alg_maximum_order, get_current_adaptive_or _digest_beta1_beta2, timedepentdtmin, _unwrap_val, _reshape, _vec, get_fsalfirstlast, generic_solver_docstring, differentiation_rk_docstring, _bool_to_ADType, - _process_AD_choice, LinearAliasSpecifier + _process_AD_choice, LinearAliasSpecifier, @SciMLMessage, Minimal using FastBroadcast, Polyester, MuladdMacro, RecursiveArrayTools, LinearSolve import OrdinaryDiffEqCore import FastPower diff --git a/lib/OrdinaryDiffEqExtrapolation/src/extrapolation_caches.jl b/lib/OrdinaryDiffEqExtrapolation/src/extrapolation_caches.jl index 418ef01b5a..b557a55879 100644 --- a/lib/OrdinaryDiffEqExtrapolation/src/extrapolation_caches.jl +++ b/lib/OrdinaryDiffEqExtrapolation/src/extrapolation_caches.jl @@ -271,7 +271,7 @@ function alg_cache(alg::ImplicitEulerExtrapolation, u, rate_prototype, linprob = LinearProblem(W[1], _vec(linsolve_tmps[1]); u0 = _vec(k_tmps[1])) linsolve1 = init( - linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -280,7 +280,7 @@ function alg_cache(alg::ImplicitEulerExtrapolation, u, rate_prototype, for i in 2:get_thread_count(alg) linprob = LinearProblem(W[i], _vec(linsolve_tmps[i]); u0 = _vec(k_tmps[i])) linsolve[i] = init(linprob, alg.linsolve, - alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) end @@ -1160,7 +1160,7 @@ function alg_cache(alg::ImplicitDeuflhardExtrapolation, u, rate_prototype, linprob = LinearProblem(W[1], _vec(linsolve_tmps[1]); u0 = _vec(k_tmps[1])) linsolve1 = init( - linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -1169,7 +1169,7 @@ function alg_cache(alg::ImplicitDeuflhardExtrapolation, u, rate_prototype, for i in 2:get_thread_count(alg) linprob = LinearProblem(W[i], _vec(linsolve_tmps[i]); u0 = _vec(k_tmps[i])) linsolve[i] = init(linprob, alg.linsolve, - alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) end @@ -1490,7 +1490,7 @@ function alg_cache(alg::ImplicitHairerWannerExtrapolation, u, rate_prototype, linprob = LinearProblem(W[1], _vec(linsolve_tmps[1]); u0 = _vec(k_tmps[1])) linsolve1 = init( - linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -1499,7 +1499,7 @@ function alg_cache(alg::ImplicitHairerWannerExtrapolation, u, rate_prototype, for i in 2:get_thread_count(alg) linprob = LinearProblem(W[i], _vec(linsolve_tmps[i]); u0 = _vec(k_tmps[i])) linsolve[i] = init(linprob, alg.linsolve, - alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) end @@ -1688,7 +1688,7 @@ function alg_cache(alg::ImplicitEulerBarycentricExtrapolation, u, rate_prototype linprob = LinearProblem(W[1], _vec(linsolve_tmps[1]); u0 = _vec(k_tmps[1])) linsolve1 = init( - linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -1697,7 +1697,7 @@ function alg_cache(alg::ImplicitEulerBarycentricExtrapolation, u, rate_prototype for i in 2:get_thread_count(alg) linprob = LinearProblem(W[i], _vec(linsolve_tmps[i]); u0 = _vec(k_tmps[i])) linsolve[i] = init(linprob, alg.linsolve, - alias = LinearAliasSpecifier(alias_A = true, alias_b = true)) + alias = LinearAliasSpecifier(alias_A = true, alias_b = true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) end diff --git a/lib/OrdinaryDiffEqFIRK/src/OrdinaryDiffEqFIRK.jl b/lib/OrdinaryDiffEqFIRK/src/OrdinaryDiffEqFIRK.jl index 7ab3cffccf..b6e2ae1e9e 100644 --- a/lib/OrdinaryDiffEqFIRK/src/OrdinaryDiffEqFIRK.jl +++ b/lib/OrdinaryDiffEqFIRK/src/OrdinaryDiffEqFIRK.jl @@ -18,7 +18,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, fac_default_gamma, get_current_adaptive_order, get_fsalfirstlast, isfirk, generic_solver_docstring, _bool_to_ADType, - _process_AD_choice, LinearAliasSpecifier + _process_AD_choice, LinearAliasSpecifier, @SciMLMessage, Minimal using MuladdMacro, DiffEqBase, RecursiveArrayTools, Polyester isfirk, generic_solver_docstring using SciMLOperators: AbstractSciMLOperator diff --git a/lib/OrdinaryDiffEqFIRK/src/firk_caches.jl b/lib/OrdinaryDiffEqFIRK/src/firk_caches.jl index 6f99a62cf3..4d0160328b 100644 --- a/lib/OrdinaryDiffEqFIRK/src/firk_caches.jl +++ b/lib/OrdinaryDiffEqFIRK/src/firk_caches.jl @@ -105,7 +105,7 @@ function alg_cache(alg::RadauIIA3, u, rate_prototype, ::Type{uEltypeNoUnits}, linprob = LinearProblem(W1, _vec(cubuff); u0 = _vec(dw12)) linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -245,13 +245,13 @@ function alg_cache(alg::RadauIIA5, u, rate_prototype, ::Type{uEltypeNoUnits}, linprob = LinearProblem(W1, _vec(ubuff); u0 = _vec(dw1)) linsolve1 = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) linprob = LinearProblem(W2, _vec(cubuff); u0 = _vec(dw23)) linsolve2 = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -437,19 +437,19 @@ function alg_cache(alg::RadauIIA9, u, rate_prototype, ::Type{uEltypeNoUnits}, linprob = LinearProblem(W1, _vec(ubuff); u0 = _vec(dw1)) linsolve1 = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) linprob = LinearProblem(W2, _vec(cubuff1); u0 = _vec(dw23)) linsolve2 = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) linprob = LinearProblem(W3, _vec(cubuff2); u0 = _vec(dw45)) linsolve3 = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) #Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), #Pr = Diagonal(_vec(weight))) @@ -644,12 +644,12 @@ function alg_cache(alg::AdaptiveRadau, u, rate_prototype, ::Type{uEltypeNoUnits} linprob = LinearProblem(W1, _vec(ubuff); u0 = _vec(dw1)) linsolve1 = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) linsolve2 = [init(LinearProblem(W2[i], _vec(cubuff[i]); u0 = _vec(dw2[i])), alg.linsolve, alias = LinearAliasSpecifier( alias_A = true, alias_b = true), - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), verbose = Minimal()) for i in 1:((max_stages - 1) ÷ 2)] rtol = reltol isa Number ? reltol : zero(reltol) diff --git a/lib/OrdinaryDiffEqFeagin/src/OrdinaryDiffEqFeagin.jl b/lib/OrdinaryDiffEqFeagin/src/OrdinaryDiffEqFeagin.jl index a796596133..dc9b244dce 100644 --- a/lib/OrdinaryDiffEqFeagin/src/OrdinaryDiffEqFeagin.jl +++ b/lib/OrdinaryDiffEqFeagin/src/OrdinaryDiffEqFeagin.jl @@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, alg_cache, _vec, _reshape, @cache, isfsal, full_cache, constvalue, _unwrap_val, get_fsalfirstlast, generic_solver_docstring, trivial_limiter!, - _ode_interpolant!, _ode_addsteps! + _ode_interpolant!, _ode_addsteps!, @SciMLMessage using FastBroadcast, Polyester, MuladdMacro, RecursiveArrayTools using DiffEqBase: @def, @tight_loop_macros using Static: False diff --git a/lib/OrdinaryDiffEqFunctionMap/src/OrdinaryDiffEqFunctionMap.jl b/lib/OrdinaryDiffEqFunctionMap/src/OrdinaryDiffEqFunctionMap.jl index 7f35f5dc06..7e917727da 100644 --- a/lib/OrdinaryDiffEqFunctionMap/src/OrdinaryDiffEqFunctionMap.jl +++ b/lib/OrdinaryDiffEqFunctionMap/src/OrdinaryDiffEqFunctionMap.jl @@ -6,7 +6,7 @@ import OrdinaryDiffEqCore: isfsal, beta2_default, beta1_default, OrdinaryDiffEqA alg_cache, @cache, _ode_addsteps!, _ode_interpolant!, _ode_interpolant, get_fsalfirstlast, alg_order, OrdinaryDiffEqConstantCache, dt_required, - isdiscretecache, isdiscretealg, full_cache + isdiscretecache, isdiscretealg, full_cache, @SciMLMessage using DiffEqBase import RecursiveArrayTools: recursivecopy! import FastBroadcast: @.. diff --git a/lib/OrdinaryDiffEqHighOrderRK/src/OrdinaryDiffEqHighOrderRK.jl b/lib/OrdinaryDiffEqHighOrderRK/src/OrdinaryDiffEqHighOrderRK.jl index db7e15ffe0..b021ab2fc8 100644 --- a/lib/OrdinaryDiffEqHighOrderRK/src/OrdinaryDiffEqHighOrderRK.jl +++ b/lib/OrdinaryDiffEqHighOrderRK/src/OrdinaryDiffEqHighOrderRK.jl @@ -11,7 +11,7 @@ import OrdinaryDiffEqCore: alg_order, qmax_default, qmin_default, beta2_default, calculate_residuals!, calculate_residuals, CompiledFloats, copyat_or_push!, get_fsalfirstlast, unwrap_alg, _ode_interpolant, _ode_interpolant!, - DerivativeOrderNotPossibleError, full_cache, isdp8 + DerivativeOrderNotPossibleError, full_cache, isdp8, @SciMLMessage import Static: False import MuladdMacro: @muladd using DiffEqBase diff --git a/lib/OrdinaryDiffEqIMEXMultistep/src/OrdinaryDiffEqIMEXMultistep.jl b/lib/OrdinaryDiffEqIMEXMultistep/src/OrdinaryDiffEqIMEXMultistep.jl index 09ce3c180a..5fc328d6db 100644 --- a/lib/OrdinaryDiffEqIMEXMultistep/src/OrdinaryDiffEqIMEXMultistep.jl +++ b/lib/OrdinaryDiffEqIMEXMultistep/src/OrdinaryDiffEqIMEXMultistep.jl @@ -4,7 +4,7 @@ import OrdinaryDiffEqCore: alg_order, issplit, OrdinaryDiffEqNewtonAlgorithm, _u DEFAULT_PRECS, OrdinaryDiffEqConstantCache, OrdinaryDiffEqMutableCache, @cache, alg_cache, initialize!, perform_step!, @unpack, - full_cache, get_fsalfirstlast, + full_cache, get_fsalfirstlast, @SciMLMessage, generic_solver_docstring, _bool_to_ADType, _process_AD_choice using FastBroadcast diff --git a/lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl b/lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl index 0fdb370b03..38cc7a0843 100644 --- a/lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl +++ b/lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl @@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, alg_extrapolates, dt_required, initialize!, perform_step!, @unpack, unwrap_alg, calculate_residuals!, get_fsalfirstlast, _vec, isdtchangeable, full_cache, - generic_solver_docstring + generic_solver_docstring, @SciMLMessage using LinearAlgebra: mul!, I using SciMLOperators: AbstractSciMLOperator using ExponentialUtilities diff --git a/lib/OrdinaryDiffEqLowOrderRK/src/OrdinaryDiffEqLowOrderRK.jl b/lib/OrdinaryDiffEqLowOrderRK/src/OrdinaryDiffEqLowOrderRK.jl index 19d4c7ab50..e826a9e10d 100644 --- a/lib/OrdinaryDiffEqLowOrderRK/src/OrdinaryDiffEqLowOrderRK.jl +++ b/lib/OrdinaryDiffEqLowOrderRK/src/OrdinaryDiffEqLowOrderRK.jl @@ -16,7 +16,7 @@ import OrdinaryDiffEqCore: alg_order, isfsal, beta2_default, beta1_default, @cache, CompiledFloats, alg_cache, CompositeAlgorithm, AutoAlgSwitch, _ode_interpolant, _ode_interpolant!, full_cache, accept_step_controller, DerivativeOrderNotPossibleError, - du_cache, u_cache, get_fsalfirstlast, copyat_or_push! + du_cache, u_cache, get_fsalfirstlast, copyat_or_push!, @SciMLMessage using SciMLBase import MuladdMacro: @muladd import FastBroadcast: @.. diff --git a/lib/OrdinaryDiffEqLowStorageRK/src/OrdinaryDiffEqLowStorageRK.jl b/lib/OrdinaryDiffEqLowStorageRK/src/OrdinaryDiffEqLowStorageRK.jl index 22596ff12b..cf5c5a5e66 100644 --- a/lib/OrdinaryDiffEqLowStorageRK/src/OrdinaryDiffEqLowStorageRK.jl +++ b/lib/OrdinaryDiffEqLowStorageRK/src/OrdinaryDiffEqLowStorageRK.jl @@ -11,7 +11,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, calculate_residuals!, alg_cache, _vec, _reshape, @cache, isfsal, full_cache, constvalue, _unwrap_val, trivial_limiter!, perform_step!, initialize!, - explicit_rk_docstring, get_fsalfirstlast + explicit_rk_docstring, get_fsalfirstlast, @SciMLMessage using FastBroadcast, Polyester, MuladdMacro, RecursiveArrayTools, Adapt import StaticArrays: SArray, MVector, SVector, @SVector, StaticArray, MMatrix, SA import Static: False diff --git a/lib/OrdinaryDiffEqNonlinearSolve/src/OrdinaryDiffEqNonlinearSolve.jl b/lib/OrdinaryDiffEqNonlinearSolve/src/OrdinaryDiffEqNonlinearSolve.jl index 4e58484ffb..ea9b98d586 100644 --- a/lib/OrdinaryDiffEqNonlinearSolve/src/OrdinaryDiffEqNonlinearSolve.jl +++ b/lib/OrdinaryDiffEqNonlinearSolve/src/OrdinaryDiffEqNonlinearSolve.jl @@ -29,7 +29,7 @@ import SciMLStructures: canonicalize, Tunable, isscimlstructure import OrdinaryDiffEqCore import SciMLOperators: islinear -import OrdinaryDiffEqCore: nlsolve_f, set_new_W!, set_W_γdt! +import OrdinaryDiffEqCore: nlsolve_f, set_new_W!, set_W_γdt!, @SciMLMessage @static if isdefined(OrdinaryDiffEqCore, :default_nlsolve) import OrdinaryDiffEqCore: default_nlsolve @@ -50,7 +50,7 @@ using OrdinaryDiffEqCore: resize_nlsolver!, _initialize_dae!, import OrdinaryDiffEqCore: _initialize_dae!, isnewton, get_W, isfirstcall, isfirststage, isJcurrent, get_new_W_γdt_cutoff, resize_nlsolver!, apply_step!, - postamble! + postamble!, @SciMLMessage, Minimal import OrdinaryDiffEqDifferentiation: update_W!, is_always_new, build_uf, build_J_W, WOperator, StaticWOperator, wrapprecs, diff --git a/lib/OrdinaryDiffEqNonlinearSolve/src/initialize_dae.jl b/lib/OrdinaryDiffEqNonlinearSolve/src/initialize_dae.jl index e87963f362..807238ddc6 100644 --- a/lib/OrdinaryDiffEqNonlinearSolve/src/initialize_dae.jl +++ b/lib/OrdinaryDiffEqNonlinearSolve/src/initialize_dae.jl @@ -152,7 +152,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::OD nlprob = NonlinearProblem(nlfunc, integrator.u, p) nlsolve = default_nlsolve(alg.nlsolve, isinplace, u0, nlprob, isAD) nlsol = solve(nlprob, nlsolve; abstol = integrator.opts.abstol, - reltol = integrator.opts.reltol) + reltol = integrator.opts.reltol, verbose = Minimal()) integrator.u .= nlsol.u failed = nlsol.retcode != ReturnCode.Success end @@ -162,7 +162,8 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::OD end if failed - @warn "ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`." + @SciMLMessage("ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`.", + integrator.opts.verbose, :shampine_dt) integrator.sol = SciMLBase.solution_new_retcode(integrator.sol, ReturnCode.InitialFailure) end @@ -230,7 +231,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::OD nlsolve = default_nlsolve(alg.nlsolve, isinplace, nlprob, u0) nlsol = solve(nlprob, nlsolve; abstol = integrator.opts.abstol, - reltol = integrator.opts.reltol) + reltol = integrator.opts.reltol, verbose = Minimal()) integrator.u = nlsol.u failed = nlsol.retcode != ReturnCode.Success end @@ -241,7 +242,8 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::OD end if failed - @warn "ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`." + @SciMLMessage("ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`.", + integrator.opts.verbose, :shampine_dt) integrator.sol = SciMLBase.solution_new_retcode(integrator.sol, ReturnCode.InitialFailure) end @@ -310,7 +312,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::DA nlprob = NonlinearProblem(nlfunc, u0, p) nlsolve = default_nlsolve(alg.nlsolve, isinplace, u0, nlprob, isAD) nlsol = solve(nlprob, nlsolve; abstol = integrator.opts.abstol, - reltol = integrator.opts.reltol) + reltol = integrator.opts.reltol, verbose = Minimal()) integrator.u = nlsol.u recursivecopy!(integrator.uprev, integrator.u) @@ -318,7 +320,8 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::DA recursivecopy!(integrator.uprev2, integrator.uprev) end if nlsol.retcode != ReturnCode.Success - @warn "ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`." + @SciMLMessage("ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`.", + integrator.opts.verbose, :shampine_dt) integrator.sol = SciMLBase.solution_new_retcode(integrator.sol, ReturnCode.InitialFailure) end @@ -357,7 +360,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::DA nlfunc = NonlinearFunction(nlequation; jac_prototype = f.jac_prototype) nlprob = NonlinearProblem(nlfunc, u0) nlsol = solve(nlprob, nlsolve; abstol = integrator.opts.abstol, - reltol = integrator.opts.reltol) + reltol = integrator.opts.reltol, verbose = Minimal()) integrator.u = nlsol.u @@ -366,7 +369,8 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::DA integrator.uprev2 = copy(integrator.uprev) end if nlsol.retcode != ReturnCode.Success - @warn "ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`." + @SciMLMessage("ShampineCollocationInit DAE initialization algorithm failed with dt=$dt. Try to adjust initdt like `ShampineCollocationInit(initdt)`.", + integrator.opts.verbose, :shampine_dt) integrator.sol = SciMLBase.solution_new_retcode(integrator.sol, ReturnCode.InitialFailure) end @@ -455,7 +459,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::OD nlprob = NonlinearProblem(nlfunc, alg_u, p) nlsolve = default_nlsolve(alg.nlsolve, isinplace, u, nlprob, isAD) - nlsol = solve(nlprob, nlsolve; abstol = alg.abstol, reltol = integrator.opts.reltol) + nlsol = solve(nlprob, nlsolve; abstol = alg.abstol, reltol = integrator.opts.reltol, verbose = Minimal()) alg_u .= nlsol recursivecopy!(integrator.uprev, integrator.u) @@ -515,7 +519,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::OD nlprob = NonlinearProblem(nlfunc, u0[algebraic_vars]) nlsolve = default_nlsolve(alg.nlsolve, isinplace, u0, nlprob, isAD) - nlsol = solve(nlprob, nlsolve) + nlsol = solve(nlprob, nlsolve, verbose = Minimal()) u[algebraic_vars] .= nlsol.u @@ -603,7 +607,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::DA nlfunc = NonlinearFunction(nlequation!; jac_prototype = f.jac_prototype) nlprob = NonlinearProblem(nlfunc, ifelse.(differential_vars, du, u), p) - nlsol = solve(nlprob, nlsolve; abstol = alg.abstol, reltol = integrator.opts.reltol) + nlsol = solve(nlprob, nlsolve; abstol = alg.abstol, reltol = integrator.opts.reltol, verbose = Minimal()) @. du = ifelse(differential_vars, nlsol.u, du) @. u = ifelse(differential_vars, u, nlsol.u) @@ -654,7 +658,7 @@ function _initialize_dae!(integrator::OrdinaryDiffEqCore.ODEIntegrator, prob::DA @show nlsolve - nlsol = solve(nlprob, nlsolve) + nlsol = solve(nlprob, nlsolve, verbose = Minimal()) du = ifelse.(differential_vars, nlsol.u, du) u = ifelse.(differential_vars, u, nlsol.u) diff --git a/lib/OrdinaryDiffEqNonlinearSolve/src/utils.jl b/lib/OrdinaryDiffEqNonlinearSolve/src/utils.jl index 49a0db411d..635675c2c6 100644 --- a/lib/OrdinaryDiffEqNonlinearSolve/src/utils.jl +++ b/lib/OrdinaryDiffEqNonlinearSolve/src/utils.jl @@ -219,7 +219,8 @@ function build_nlsolver( linsolve = init(linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) tType = typeof(t) invγdt = inv(oneunit(t) * one(uTolType)) @@ -325,7 +326,7 @@ function build_nlsolver( (tmp, γ, α, tstep, invγdt, DIRK, p, dt, f) end prob = NonlinearProblem(NonlinearFunction{false}(nlf), copy(ztmp), nlp_params) - cache = init(prob, nlalg.alg) + cache = init(prob, nlalg.alg, verbose = Minimal()) nlcache = NonlinearSolveCache( nothing, tstep, nothing, nothing, invγdt, prob, cache) else diff --git a/lib/OrdinaryDiffEqNordsieck/src/OrdinaryDiffEqNordsieck.jl b/lib/OrdinaryDiffEqNordsieck/src/OrdinaryDiffEqNordsieck.jl index 5db6344b12..45a2a0370e 100644 --- a/lib/OrdinaryDiffEqNordsieck/src/OrdinaryDiffEqNordsieck.jl +++ b/lib/OrdinaryDiffEqNordsieck/src/OrdinaryDiffEqNordsieck.jl @@ -11,7 +11,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, qsteady_max_default, calculate_residuals, calculate_residuals!, get_current_adaptive_order, get_fsalfirstlast, ode_interpolant, ode_interpolant!, trivial_limiter!, - generic_solver_docstring + generic_solver_docstring, @SciMLMessage using MuladdMacro, FastBroadcast, RecursiveArrayTools import LinearAlgebra: rmul! import Static: False diff --git a/lib/OrdinaryDiffEqPDIRK/src/OrdinaryDiffEqPDIRK.jl b/lib/OrdinaryDiffEqPDIRK/src/OrdinaryDiffEqPDIRK.jl index f286f5631b..0537f37589 100644 --- a/lib/OrdinaryDiffEqPDIRK/src/OrdinaryDiffEqPDIRK.jl +++ b/lib/OrdinaryDiffEqPDIRK/src/OrdinaryDiffEqPDIRK.jl @@ -6,7 +6,7 @@ import OrdinaryDiffEqCore: isfsal, alg_order, _unwrap_val, uses_uprev, @unpack, unwrap_alg, @cache, DEFAULT_PRECS, @threaded, initialize!, perform_step!, isthreaded, full_cache, get_fsalfirstlast, differentiation_rk_docstring, - _bool_to_ADType, _process_AD_choice + _bool_to_ADType, _process_AD_choice, @SciMLMessage import StaticArrays: SVector import MuladdMacro: @muladd import FastBroadcast: @.. diff --git a/lib/OrdinaryDiffEqPRK/src/OrdinaryDiffEqPRK.jl b/lib/OrdinaryDiffEqPRK/src/OrdinaryDiffEqPRK.jl index 8e0f3fe0d8..61d6a975f1 100644 --- a/lib/OrdinaryDiffEqPRK/src/OrdinaryDiffEqPRK.jl +++ b/lib/OrdinaryDiffEqPRK/src/OrdinaryDiffEqPRK.jl @@ -4,7 +4,7 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, alg_order, OrdinaryDiffEqMut OrdinaryDiffEqConstantCache, constvalue, @unpack, @cache, alg_cache, get_fsalfirstlast, unwrap_alg, perform_step!, @threaded, initialize!, isthreaded, - full_cache, generic_solver_docstring + full_cache, generic_solver_docstring, @SciMLMessage import MuladdMacro: @muladd import FastBroadcast: @.. using Polyester diff --git a/lib/OrdinaryDiffEqQPRK/src/OrdinaryDiffEqQPRK.jl b/lib/OrdinaryDiffEqQPRK/src/OrdinaryDiffEqQPRK.jl index 9e268acbe5..905764d7c8 100644 --- a/lib/OrdinaryDiffEqQPRK/src/OrdinaryDiffEqQPRK.jl +++ b/lib/OrdinaryDiffEqQPRK/src/OrdinaryDiffEqQPRK.jl @@ -7,7 +7,7 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqAdaptiveAlgorithm, OrdinaryDiffEqConsta trivial_limiter!, alg_cache, alg_order, initialize!, perform_step!, get_fsalfirstlast, constvalue, calculate_residuals!, calculate_residuals, - full_cache + full_cache, @SciMLMessage using Static: False using MuladdMacro, FastBroadcast using RecursiveArrayTools: recursive_unitless_bottom_eltype, recursivefill! diff --git a/lib/OrdinaryDiffEqRKN/src/OrdinaryDiffEqRKN.jl b/lib/OrdinaryDiffEqRKN/src/OrdinaryDiffEqRKN.jl index cf23486570..f48eb1e923 100644 --- a/lib/OrdinaryDiffEqRKN/src/OrdinaryDiffEqRKN.jl +++ b/lib/OrdinaryDiffEqRKN/src/OrdinaryDiffEqRKN.jl @@ -12,7 +12,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, constvalue, _unwrap_val, _ode_interpolant, get_fsalfirstlast, trivial_limiter!, _ode_interpolant!, _ode_addsteps!, - generic_solver_docstring + generic_solver_docstring, @SciMLMessage using FastBroadcast, Polyester, MuladdMacro, RecursiveArrayTools using DiffEqBase: @def, @tight_loop_macros import OrdinaryDiffEqCore diff --git a/lib/OrdinaryDiffEqRosenbrock/src/OrdinaryDiffEqRosenbrock.jl b/lib/OrdinaryDiffEqRosenbrock/src/OrdinaryDiffEqRosenbrock.jl index ed279f8d43..1f3943e628 100644 --- a/lib/OrdinaryDiffEqRosenbrock/src/OrdinaryDiffEqRosenbrock.jl +++ b/lib/OrdinaryDiffEqRosenbrock/src/OrdinaryDiffEqRosenbrock.jl @@ -13,7 +13,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, isWmethod, isfsal, _un calculate_residuals, has_stiff_interpolation, ODEIntegrator, resize_non_user_cache!, _ode_addsteps!, full_cache, DerivativeOrderNotPossibleError, _bool_to_ADType, - _process_AD_choice, LinearAliasSpecifier, copyat_or_push! + _process_AD_choice, LinearAliasSpecifier, @SciMLMessage, Minimal, copyat_or_push! using MuladdMacro, FastBroadcast, RecursiveArrayTools import MacroTools: namify using MacroTools: @capture diff --git a/lib/OrdinaryDiffEqRosenbrock/src/generic_rosenbrock.jl b/lib/OrdinaryDiffEqRosenbrock/src/generic_rosenbrock.jl index ce714f99c6..702889c49b 100644 --- a/lib/OrdinaryDiffEqRosenbrock/src/generic_rosenbrock.jl +++ b/lib/OrdinaryDiffEqRosenbrock/src/generic_rosenbrock.jl @@ -254,7 +254,8 @@ function gen_algcache(cacheexpr::Expr,constcachename::Symbol,algname::Symbol,tab linprob = LinearProblem(W,_vec(linsolve_tmp); u0=_vec(tmp)) linsolve = init(linprob,alg.linsolve,alias = LinearAliasSpecifier(alias_A=true,alias_b=true), Pl = LinearSolve.InvPreconditioner(Diagonal(_vec(weight))), - Pr = Diagonal(_vec(weight))) + Pr = Diagonal(_vec(weight)), + verbose = Minimal()) $cachename($(valsyms...)) end end diff --git a/lib/OrdinaryDiffEqRosenbrock/src/rosenbrock_caches.jl b/lib/OrdinaryDiffEqRosenbrock/src/rosenbrock_caches.jl index 1764a14430..b9d3606df5 100644 --- a/lib/OrdinaryDiffEqRosenbrock/src/rosenbrock_caches.jl +++ b/lib/OrdinaryDiffEqRosenbrock/src/rosenbrock_caches.jl @@ -164,7 +164,8 @@ function alg_cache(alg::Rosenbrock23, u, rate_prototype, ::Type{uEltypeNoUnits}, linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) algebraic_vars = f.mass_matrix === I ? nothing : @@ -215,7 +216,8 @@ function alg_cache(alg::Rosenbrock32, u, rate_prototype, ::Type{uEltypeNoUnits}, linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) algebraic_vars = f.mass_matrix === I ? nothing : [all(iszero, x) for x in eachcol(f.mass_matrix)] @@ -367,7 +369,8 @@ function alg_cache(alg::ROS3P, u, rate_prototype, ::Type{uEltypeNoUnits}, linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) Rosenbrock33Cache(u, uprev, du, du1, du2, k1, k2, k3, k4, fsalfirst, fsallast, dT, J, W, tmp, atmp, weight, tab, tf, uf, @@ -458,7 +461,8 @@ function alg_cache(alg::Rodas3, u, rate_prototype, ::Type{uEltypeNoUnits}, linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) Rosenbrock34Cache(u, uprev, du, du1, du2, k1, k2, k3, k4, fsalfirst, fsallast, dT, J, W, tmp, atmp, weight, tab, tf, uf, @@ -656,7 +660,8 @@ function alg_cache(alg::Rodas23W, u, rate_prototype, ::Type{uEltypeNoUnits}, linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) Rodas23WCache(u, uprev, dense1, dense2, dense3, du, du1, du2, k1, k2, k3, k4, k5, fsalfirst, fsallast, dT, J, W, tmp, atmp, weight, tab, tf, uf, linsolve_tmp, @@ -705,7 +710,8 @@ function alg_cache(alg::Rodas3P, u, rate_prototype, ::Type{uEltypeNoUnits}, linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A = true, alias_b = true), Pl = Pl, Pr = Pr, - assumptions = LinearSolve.OperatorAssumptions(true)) + assumptions = LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) Rodas3PCache(u, uprev, dense1, dense2, dense3, du, du1, du2, k1, k2, k3, k4, k5, fsalfirst, fsallast, dT, J, W, tmp, atmp, weight, tab, tf, uf, linsolve_tmp, @@ -820,7 +826,8 @@ function alg_cache( linsolve = init( linprob, alg.linsolve, alias = LinearAliasSpecifier(alias_A=true, alias_b=true), Pl=Pl, Pr=Pr, - assumptions=LinearSolve.OperatorAssumptions(true)) + assumptions=LinearSolve.OperatorAssumptions(true), + verbose = Minimal()) # Return the cache struct with vectors diff --git a/lib/OrdinaryDiffEqSDIRK/src/OrdinaryDiffEqSDIRK.jl b/lib/OrdinaryDiffEqSDIRK/src/OrdinaryDiffEqSDIRK.jl index a72d1e0584..d0c41bd0f8 100644 --- a/lib/OrdinaryDiffEqSDIRK/src/OrdinaryDiffEqSDIRK.jl +++ b/lib/OrdinaryDiffEqSDIRK/src/OrdinaryDiffEqSDIRK.jl @@ -14,7 +14,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, trivial_limiter!, _ode_interpolant!, isesdirk, issplit, ssp_coefficient, get_fsalfirstlast, generic_solver_docstring, - _bool_to_ADType, _process_AD_choice, current_extrapolant! + _bool_to_ADType, _process_AD_choice, current_extrapolant!, @SciMLMessage using TruncatedStacktraces: @truncate_stacktrace using MuladdMacro, MacroTools, FastBroadcast, RecursiveArrayTools using SciMLBase: SplitFunction diff --git a/lib/OrdinaryDiffEqSSPRK/src/OrdinaryDiffEqSSPRK.jl b/lib/OrdinaryDiffEqSSPRK/src/OrdinaryDiffEqSSPRK.jl index 911c3099ae..452556302d 100644 --- a/lib/OrdinaryDiffEqSSPRK/src/OrdinaryDiffEqSSPRK.jl +++ b/lib/OrdinaryDiffEqSSPRK/src/OrdinaryDiffEqSSPRK.jl @@ -12,7 +12,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, constvalue, _unwrap_val, explicit_rk_docstring, trivial_limiter!, _ode_interpolant, _ode_interpolant!, - _ode_addsteps!, get_fsalfirstlast, copyat_or_push! + _ode_addsteps!, get_fsalfirstlast, @SciMLMessage, copyat_or_push! using FastBroadcast, Polyester, MuladdMacro, RecursiveArrayTools using DiffEqBase: @def using Static: False diff --git a/lib/OrdinaryDiffEqStabilizedIRK/src/OrdinaryDiffEqStabilizedIRK.jl b/lib/OrdinaryDiffEqStabilizedIRK/src/OrdinaryDiffEqStabilizedIRK.jl index 2410c2a55b..c99731f919 100644 --- a/lib/OrdinaryDiffEqStabilizedIRK/src/OrdinaryDiffEqStabilizedIRK.jl +++ b/lib/OrdinaryDiffEqStabilizedIRK/src/OrdinaryDiffEqStabilizedIRK.jl @@ -7,7 +7,7 @@ import OrdinaryDiffEqCore: alg_order, alg_maximum_order, calculate_residuals, fac_default_gamma, OrdinaryDiffEqAlgorithm, OrdinaryDiffEqNewtonAdaptiveAlgorithm, OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCache, - OrdinaryDiffEqAdaptiveAlgorithm, + OrdinaryDiffEqAdaptiveAlgorithm, @SciMLMessage, OrdinaryDiffEqAdaptiveImplicitAlgorithm, alg_cache, _unwrap_val, DEFAULT_PRECS, @cache, _reshape, _vec, full_cache, get_fsalfirstlast, diff --git a/lib/OrdinaryDiffEqStabilizedRK/src/OrdinaryDiffEqStabilizedRK.jl b/lib/OrdinaryDiffEqStabilizedRK/src/OrdinaryDiffEqStabilizedRK.jl index 8ee60216d9..05025801b6 100644 --- a/lib/OrdinaryDiffEqStabilizedRK/src/OrdinaryDiffEqStabilizedRK.jl +++ b/lib/OrdinaryDiffEqStabilizedRK/src/OrdinaryDiffEqStabilizedRK.jl @@ -10,7 +10,7 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, calculate_residuals!, OrdinaryDiffEqAdaptiveAlgorithm, calc_dt_propose!, alg_cache, _vec, _reshape, @cache, constvalue, _unwrap_val, full_cache, get_fsalfirstlast, - generic_solver_docstring + generic_solver_docstring, @SciMLMessage using FastBroadcast, MuladdMacro, RecursiveArrayTools import StaticArrays: SArray, MVector, SVector, @SVector, StaticArray, MMatrix, SA import OrdinaryDiffEqCore diff --git a/lib/OrdinaryDiffEqSymplecticRK/src/OrdinaryDiffEqSymplecticRK.jl b/lib/OrdinaryDiffEqSymplecticRK/src/OrdinaryDiffEqSymplecticRK.jl index 2e05b19997..f57ded2674 100644 --- a/lib/OrdinaryDiffEqSymplecticRK/src/OrdinaryDiffEqSymplecticRK.jl +++ b/lib/OrdinaryDiffEqSymplecticRK/src/OrdinaryDiffEqSymplecticRK.jl @@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, OrdinaryDiffEqPartitionedAlgorithm, CompiledFloats, uses_uprev, alg_cache, _vec, _reshape, @cache, isfsal, full_cache, - constvalue, _unwrap_val, + constvalue, _unwrap_val, @SciMLMessage, explicit_rk_docstring, trivial_limiter!, _ode_interpolant!, _ode_addsteps!, get_fsalfirstlast, generic_solver_docstring, default_linear_interpolation diff --git a/lib/OrdinaryDiffEqTaylorSeries/src/OrdinaryDiffEqTaylorSeries.jl b/lib/OrdinaryDiffEqTaylorSeries/src/OrdinaryDiffEqTaylorSeries.jl index a06dabaaf6..afcc1527d2 100644 --- a/lib/OrdinaryDiffEqTaylorSeries/src/OrdinaryDiffEqTaylorSeries.jl +++ b/lib/OrdinaryDiffEqTaylorSeries/src/OrdinaryDiffEqTaylorSeries.jl @@ -9,7 +9,7 @@ import OrdinaryDiffEqCore: alg_order, alg_stability_size, explicit_rk_docstring, CompiledFloats, @OnDemandTableauExtract, initialize!, perform_step!, OrdinaryDiffEqAlgorithm, CompositeAlgorithm, _ode_addsteps!, copyat_or_push!, - AutoAlgSwitch, get_fsalfirstlast, + AutoAlgSwitch, get_fsalfirstlast, @SciMLMessage, full_cache, DerivativeOrderNotPossibleError import Static: False import MuladdMacro: @muladd diff --git a/lib/OrdinaryDiffEqTsit5/src/OrdinaryDiffEqTsit5.jl b/lib/OrdinaryDiffEqTsit5/src/OrdinaryDiffEqTsit5.jl index 1bc8fe1cf0..0cb4dfff5e 100644 --- a/lib/OrdinaryDiffEqTsit5/src/OrdinaryDiffEqTsit5.jl +++ b/lib/OrdinaryDiffEqTsit5/src/OrdinaryDiffEqTsit5.jl @@ -7,7 +7,7 @@ import OrdinaryDiffEqCore: alg_order, alg_stability_size, explicit_rk_docstring, constvalue, @unpack, perform_step!, calculate_residuals, @cache, calculate_residuals!, _ode_interpolant, _ode_interpolant!, CompiledFloats, @OnDemandTableauExtract, initialize!, - perform_step!, + perform_step!, @SciMLMessage, CompositeAlgorithm, _ode_addsteps!, copyat_or_push!, AutoAlgSwitch, get_fsalfirstlast, full_cache, DerivativeOrderNotPossibleError diff --git a/lib/OrdinaryDiffEqVerner/src/OrdinaryDiffEqVerner.jl b/lib/OrdinaryDiffEqVerner/src/OrdinaryDiffEqVerner.jl index 389227688c..fb7f646cf6 100644 --- a/lib/OrdinaryDiffEqVerner/src/OrdinaryDiffEqVerner.jl +++ b/lib/OrdinaryDiffEqVerner/src/OrdinaryDiffEqVerner.jl @@ -8,7 +8,7 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!, OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCache, OrdinaryDiffEqAdaptiveAlgorithm, CompiledFloats, uses_uprev, alg_cache, _vec, _reshape, @cache, isfsal, full_cache, - constvalue, _unwrap_val, + constvalue, _unwrap_val, @SciMLMessage, explicit_rk_docstring, trivial_limiter!, _ode_interpolant, _ode_interpolant!, _ode_addsteps!, @fold, @OnDemandTableauExtract, AutoAlgSwitch, diff --git a/lib/SimpleImplicitDiscreteSolve/src/SimpleImplicitDiscreteSolve.jl b/lib/SimpleImplicitDiscreteSolve/src/SimpleImplicitDiscreteSolve.jl index d392ddfa50..b575961ee3 100644 --- a/lib/SimpleImplicitDiscreteSolve/src/SimpleImplicitDiscreteSolve.jl +++ b/lib/SimpleImplicitDiscreteSolve/src/SimpleImplicitDiscreteSolve.jl @@ -65,7 +65,7 @@ function SciMLBase.solve(prob::ImplicitDiscreteProblem, alg::SimpleIDSolve; nlf = isinplace(f) ? (out, u, p) -> f(out, u, uprev, p, t) : (u, p) -> f(u, uprev, p, t) nlprob = NonlinearProblem{isinplace(f)}(nlf, uprev, p) - nlsol = solve(nlprob, SimpleNewtonRaphson()) + nlsol = solve(nlprob, SimpleNewtonRaphson(), verbose = Minimal()) u = nlsol.u save_everystep && (us[i] = u) convfail = (nlsol.retcode != ReturnCode.Success) diff --git a/test/interface/verbosity.jl b/test/interface/verbosity.jl new file mode 100644 index 0000000000..8c3ae0a815 --- /dev/null +++ b/test/interface/verbosity.jl @@ -0,0 +1,260 @@ +using OrdinaryDiffEqCore +using OrdinaryDiffEqCore: ODEVerbosity, option_group, group_options +using ODEProblemLibrary: prob_ode_vanderpol_stiff +using SciMLLogging +using Test + +@testset "ODEVerbosity Tests" begin + @testset "Default constructor" begin + v1 = ODEVerbosity() + @test v1 isa ODEVerbosity + @test v1.dt_NaN isa SciMLLogging.WarnLevel + @test v1.init_NaN isa SciMLLogging.WarnLevel + @test v1.dense_output_saveat isa SciMLLogging.WarnLevel + @test v1.alg_switch isa SciMLLogging.WarnLevel + @test v1.mismatched_input_output_type isa SciMLLogging.WarnLevel + @test v1.rosenbrock_no_differential_states isa SciMLLogging.WarnLevel + @test v1.shampine_dt isa SciMLLogging.WarnLevel + @test v1.unlimited_dt isa SciMLLogging.WarnLevel + @test v1.linear_verbosity isa SciMLLogging.AbstractVerbosityPreset + @test v1.nonlinear_verbosity isa SciMLLogging.AbstractVerbosityPreset + end + + @testset "ODEVerbosity preset constructors" begin + v_none = ODEVerbosity(SciMLLogging.None()) + v_all = ODEVerbosity(SciMLLogging.All()) + v_minimal = ODEVerbosity(SciMLLogging.Minimal()) + v_standard = ODEVerbosity(SciMLLogging.Standard()) + v_detailed = ODEVerbosity(SciMLLogging.Detailed()) + + @test v_none.dt_NaN isa SciMLLogging.Silent + @test v_none.init_NaN isa SciMLLogging.Silent + @test v_none.alg_switch isa SciMLLogging.Silent + @test v_none.rosenbrock_no_differential_states isa SciMLLogging.Silent + + @test v_minimal.dt_NaN isa SciMLLogging.ErrorLevel + @test v_minimal.init_NaN isa SciMLLogging.ErrorLevel + @test v_minimal.alg_switch isa SciMLLogging.Silent + @test v_minimal.dense_output_saveat isa SciMLLogging.Silent + + @test v_standard.dt_NaN isa SciMLLogging.WarnLevel + @test v_standard.init_NaN isa SciMLLogging.WarnLevel + @test v_standard.alg_switch isa SciMLLogging.WarnLevel + + @test v_detailed.alg_switch isa SciMLLogging.InfoLevel + @test v_detailed.dense_output_saveat isa SciMLLogging.InfoLevel + @test v_detailed.shampine_dt isa SciMLLogging.InfoLevel + + @test v_all.alg_switch isa SciMLLogging.InfoLevel + @test v_all.shampine_dt isa SciMLLogging.InfoLevel + @test v_all.dense_output_saveat isa SciMLLogging.InfoLevel + end + + @testset "Group-level keyword constructors" begin + v_error = ODEVerbosity(error_control = ErrorLevel()) + @test v_error.dt_NaN isa SciMLLogging.ErrorLevel + @test v_error.init_NaN isa SciMLLogging.ErrorLevel + @test v_error.dense_output_saveat isa SciMLLogging.ErrorLevel + + v_numerical = ODEVerbosity(numerical = Silent()) + @test v_numerical.rosenbrock_no_differential_states isa SciMLLogging.Silent + @test v_numerical.shampine_dt isa SciMLLogging.Silent + @test v_numerical.unlimited_dt isa SciMLLogging.Silent + + v_performance = ODEVerbosity(performance = InfoLevel()) + @test v_performance.alg_switch isa SciMLLogging.InfoLevel + @test v_performance.mismatched_input_output_type isa SciMLLogging.InfoLevel + end + + @testset "Mixed group and individual settings" begin + v_mixed = ODEVerbosity( + numerical = Silent(), + shampine_dt = WarnLevel(), + performance = InfoLevel() + ) + # Individual override should take precedence + @test v_mixed.shampine_dt isa SciMLLogging.WarnLevel + # Other numerical options should use group setting + @test v_mixed.rosenbrock_no_differential_states isa SciMLLogging.Silent + @test v_mixed.unlimited_dt isa SciMLLogging.Silent + # Performance group setting should apply + @test v_mixed.alg_switch isa SciMLLogging.InfoLevel + @test v_mixed.mismatched_input_output_type isa SciMLLogging.InfoLevel + end + + @testset "Individual keyword arguments" begin + v_individual = ODEVerbosity( + dt_NaN = ErrorLevel(), + alg_switch = InfoLevel(), + shampine_dt = Silent() + ) + @test v_individual.dt_NaN isa SciMLLogging.ErrorLevel + @test v_individual.alg_switch isa SciMLLogging.InfoLevel + @test v_individual.shampine_dt isa SciMLLogging.Silent + # Unspecified options should use defaults + @test v_individual.init_NaN isa SciMLLogging.WarnLevel + @test v_individual.unlimited_dt isa SciMLLogging.WarnLevel + end + + @testset "Linear and nonlinear verbosity passthrough" begin + v_with_solvers = ODEVerbosity( + linear_verbosity = SciMLLogging.Detailed(), + nonlinear_verbosity = SciMLLogging.Minimal() + ) + @test v_with_solvers.linear_verbosity isa SciMLLogging.Detailed + @test v_with_solvers.nonlinear_verbosity isa SciMLLogging.Minimal + + v_with_solvers2 = ODEVerbosity( + linear_verbosity = SciMLLogging.None(), + nonlinear_verbosity = SciMLLogging.All() + ) + @test v_with_solvers2.linear_verbosity isa SciMLLogging.None + @test v_with_solvers2.nonlinear_verbosity isa SciMLLogging.All + end + + @testset "Group classification functions" begin + @test option_group(:dt_NaN) == :error_control + @test option_group(:init_NaN) == :error_control + @test option_group(:dense_output_saveat) == :error_control + @test option_group(:alg_switch) == :performance + @test option_group(:mismatched_input_output_type) == :performance + @test option_group(:rosenbrock_no_differential_states) == :numerical + @test option_group(:shampine_dt) == :numerical + @test option_group(:unlimited_dt) == :numerical + + # Test error for unknown option + @test_throws ErrorException option_group(:unknown_option) + end + + @testset "Group options function" begin + v = ODEVerbosity(numerical = WarnLevel()) + numerical_opts = group_options(v, :numerical) + @test numerical_opts isa NamedTuple + @test :rosenbrock_no_differential_states in keys(numerical_opts) + @test :shampine_dt in keys(numerical_opts) + @test :unlimited_dt in keys(numerical_opts) + @test numerical_opts.rosenbrock_no_differential_states isa SciMLLogging.WarnLevel + @test numerical_opts.shampine_dt isa SciMLLogging.WarnLevel + @test numerical_opts.unlimited_dt isa SciMLLogging.WarnLevel + + error_opts = group_options(v, :error_control) + @test :dt_NaN in keys(error_opts) + @test :init_NaN in keys(error_opts) + @test :dense_output_saveat in keys(error_opts) + + performance_opts = group_options(v, :performance) + @test :alg_switch in keys(performance_opts) + @test :mismatched_input_output_type in keys(performance_opts) + + # Test error for unknown group + @test_throws ErrorException group_options(v, :unknown_group) + end + + @testset "Group getproperty access" begin + v = ODEVerbosity() + + # Test getting groups returns NamedTuples + error_group = v.error_control + performance_group = v.performance + numerical_group = v.numerical + + @test error_group isa NamedTuple + @test performance_group isa NamedTuple + @test numerical_group isa NamedTuple + + # Test correct keys are present + @test :dt_NaN in keys(error_group) + @test :init_NaN in keys(error_group) + @test :dense_output_saveat in keys(error_group) + + @test :alg_switch in keys(performance_group) + @test :mismatched_input_output_type in keys(performance_group) + + @test :rosenbrock_no_differential_states in keys(numerical_group) + @test :shampine_dt in keys(numerical_group) + @test :unlimited_dt in keys(numerical_group) + + # Test values are AbstractMessageLevel types + @test error_group.dt_NaN isa SciMLLogging.AbstractMessageLevel + @test performance_group.alg_switch isa SciMLLogging.AbstractMessageLevel + @test numerical_group.shampine_dt isa SciMLLogging.AbstractMessageLevel + + # Individual field access should still work + @test v.dt_NaN isa SciMLLogging.WarnLevel + @test v.alg_switch isa SciMLLogging.WarnLevel + @test v.shampine_dt isa SciMLLogging.WarnLevel + end + + @testset "Argument validation" begin + # Test invalid error_control type + @test_throws ArgumentError ODEVerbosity(error_control = "invalid") + @test_throws ArgumentError ODEVerbosity(performance = 123) + @test_throws ArgumentError ODEVerbosity(numerical = :symbol) + + # Test unknown keyword argument + @test_throws ArgumentError ODEVerbosity(unknown_field = WarnLevel()) + + # Test invalid value for individual field + @test_throws ArgumentError ODEVerbosity(dt_NaN = "not_a_level") + end + + @testset "All error control fields" begin + v = ODEVerbosity(error_control = InfoLevel()) + @test v.dt_NaN isa SciMLLogging.InfoLevel + @test v.init_NaN isa SciMLLogging.InfoLevel + @test v.dense_output_saveat isa SciMLLogging.InfoLevel + end + + @testset "All performance fields" begin + v = ODEVerbosity(performance = ErrorLevel()) + @test v.alg_switch isa SciMLLogging.ErrorLevel + @test v.mismatched_input_output_type isa SciMLLogging.ErrorLevel + end + + @testset "All numerical fields" begin + v = ODEVerbosity(numerical = InfoLevel()) + @test v.rosenbrock_no_differential_states isa SciMLLogging.InfoLevel + @test v.shampine_dt isa SciMLLogging.InfoLevel + @test v.unlimited_dt isa SciMLLogging.InfoLevel + end + + @testset "Multiple group settings" begin + v = ODEVerbosity( + error_control = ErrorLevel(), + performance = InfoLevel(), + numerical = Silent() + ) + @test v.dt_NaN isa SciMLLogging.ErrorLevel + @test v.alg_switch isa SciMLLogging.InfoLevel + @test v.shampine_dt isa SciMLLogging.Silent + end + + @testset "Complex mixed settings" begin + v = ODEVerbosity( + error_control = WarnLevel(), + performance = InfoLevel(), + numerical = Silent(), + linear_verbosity = SciMLLogging.Detailed(), + nonlinear_verbosity = SciMLLogging.Minimal(), + dt_NaN = ErrorLevel(), # Override specific error_control field + shampine_dt = WarnLevel() # Override specific numerical field + ) + # Check overrides took precedence + @test v.dt_NaN isa SciMLLogging.ErrorLevel + @test v.shampine_dt isa SciMLLogging.WarnLevel + # Check other fields follow group settings + @test v.init_NaN isa SciMLLogging.WarnLevel + @test v.alg_switch isa SciMLLogging.InfoLevel + @test v.unlimited_dt isa SciMLLogging.Silent + # Check solver verbosity + @test v.linear_verbosity isa SciMLLogging.Detailed + @test v.nonlinear_verbosity isa SciMLLogging.Minimal + end + + @testset "Stiff Switching Message" begin + verb = ODEVerbosity(performance = ODEPerformanceVerbosity(alg_switch = Verbosity.Info())) + solve(prob_ode_vanderpol_stiff, AutoTsit5(Rodas5()), verbose = verb) + end +end + +