Removes the MethodError crash sites on the path reported in #2929. #2929 itself stays open — see below.

Bug

Several places in OrdinaryDiffEqDifferentiation seed a sparsity pattern from the mass matrix with

idxs = findall(!iszero, f.mass_matrix)
@. @view(sparsity[idxs]) = @view(f.mass_matrix[idxs])

Both findall and getindex need a concrete matrix. A SciMLOperator mass matrix supports neither, so combining one with a jac_prototype throws MethodError: no method matching keys(::MatrixOperator{...}):

using OrdinaryDiffEqDifferentiation, SparseArrays, SciMLOperators, SciMLBase, ADTypes
M = sparse([1.0 2.0; 0.0 1.0])
mass_matrix = MatrixOperator(M; update_func = (A, u, p, t) -> M)
jac_prototype = sparse([1.0 0.0; 0.0 1.0])
f!(du, u, p, t) = (du .= u; nothing)
odef = ODEFunction(f!; mass_matrix, jac_prototype, sparsity = copy(jac_prototype))
prob = ODEProblem(odef, ones(2), (0.0, 1.0))
OrdinaryDiffEqDifferentiation.prepare_user_sparsity(AutoForwardDiff(), prob)
# MethodError: no method matching keys(::MatrixOperator{...})

Fix

One helper, used at all four sites that had the pattern — prepare_user_sparsity and its sparsity unwrap in alg_utils.jl, and build_jac_config and sparsity_colorvec in derivative_wrappers.jl:

concrete_mass_matrix(mm) = mm
concrete_mass_matrix(mm::AbstractSciMLOperator) = convert(AbstractMatrix, mm)

convert reads the operator's currently-cached array rather than re-evaluating it, so no update_coefficients! is involved. That is what is wanted here: only the structural pattern matters, and prepare_alg runs before init, so the cached array is the one the operator was constructed with. Non-operator mass matrices dispatch to the identity method, so plain-matrix behaviour is unchanged.

Besides MatrixOperator this also covers DiagonalOperator, IdentityOperator, ScaledOperator, AddedOperator, ComposedOperator and TensorProductOperator, which all define convert(AbstractMatrix, ·). ScalarOperator, FunctionOperator and AffineOperator have no such method and still error, but they were already failing earlier on keys and none is a plausible mass matrix here.

What this does not fix

#2929's reproducer calls solve, and that still fails — but for a different reason and further along. With these four sites fixed it gets past every keys error and reaches the sparse-W branch of jacobian2W! (derivative_utils.jl), which broadcasts the operator directly into a SparseMatrixCSC and stack-overflows. So #2929 needs at least one more change and should stay open; this PR is a strict improvement rather than a resolution.

Measured, same MWE: master fails with MethodError: keys(::MatrixOperator); this branch fails with StackOverflowError from jacobian2W!.

An earlier version of this description blamed a SciMLOperators setfield! bug for the remaining failure. That was SciML/SciMLOperators.jl#409, fixed by #416 and released in SciMLOperators v1.25.2, and is no longer relevant.

Tests

New prepare_user_sparsity_tests.jl: MatrixOperator and DiagonalOperator mass matrices, plus a case where sparsity is left to default to jac_prototype (how #2929 constructs the problem). Three of those error on master with the keys MethodError and pass here. Two further testsets pin the UniformScaling and plain-sparse paths as unchanged, and pass on both sides.

Branch: 9/9. OrdinaryDiffEqDifferentiation Core suite goes from 61 passes on master to 67 here.

AI Disclosure

Claude assisted with this work.