dropzeros the mm

Author: oscardssmith

lib/ModelingToolkitTearing/src/reassemble.jl

@@ -787,7 +787,8 @@ function __reduce_linear_system!(A::StateSelection.CLIL.SparseMatrixCLIL{Num, In
             cst += coeff * other_cst
         end
 
-        aliases[var] = SparseArrays.sparsevec(new_I, new_V, length(coeffs))
+        # `sparsevec` sums duplicate indices but keeps explicit zeros; drop them.
+        aliases[var] = SparseArrays.dropzeros!(SparseArrays.sparsevec(new_I, new_V, length(coeffs)))
         constants[var] = cst
     end
 

src/math/sparsematrixclil.jl

@@ -91,6 +91,24 @@ zero!(a::SparseVector) = (empty!(a.nzind); empty!(a.nzval))
 zero!(a::CLILVector) = zero!(a.vec)
 SparseArrays.dropzeros!(a::CLILVector) = SparseArrays.dropzeros!(a.vec)
 
+# Remove explicitly-stored zeros from each row, in place.
+function SparseArrays.dropzeros!(S::SparseMatrixCLIL)
+    for r in eachindex(S.row_vals)
+        cols = S.row_cols[r]
+        vals = S.row_vals[r]
+        j = 0
+        for k in eachindex(vals)
+            iszero(vals[k]) && continue
+            j += 1
+            cols[j] = cols[k]
+            vals[j] = vals[k]
+        end
+        resize!(cols, j)
+        resize!(vals, j)
+    end
+    return S
+end
+
 struct NonZeros{T <: AbstractArray}
     v::T
 end

src/utils.jl

@@ -341,10 +341,8 @@ function get_new_mm(
         push!(final_row_vals, new_row_val_i[indices[1]])
         for i in Iterators.drop(eachindex(indices), 1)
             col = new_row_col_i[indices[i]]
-            # Compare against the last *retained* column rather than the previous
-            # sorted entry: a prior cancellation may have `pop!`ed the matching
-            # entry, in which case the remaining duplicates of `col` must start a
-            # fresh accumulator instead of folding into an unrelated column.
+            # Compare against the last retained column, not the previous sorted
+            # entry: a prior cancellation may have `pop!`ed the matching entry.
             if !isempty(final_row_cols) && col == final_row_cols[end]
                 final_row_vals[end] += new_row_val_i[indices[i]]
                 if iszero(final_row_vals[end])
@@ -356,13 +354,16 @@ function get_new_mm(
                 push!(final_row_vals, new_row_val_i[indices[i]])
             end
         end
-        
+
         push!(new_row_cols, final_row_cols)
         push!(new_row_vals, final_row_vals)
         push!(new_nzrows, old_to_new_eq[eq])
     end
 
-    return typeof(mm)(new_nparentrows, count(!iszero, old_to_new_var), new_nzrows, new_row_cols, new_row_vals)
+    # Drop explicit zeros (e.g. from an alias that cancelled to zero) so they
+    # don't survive as phantom structural nonzeros.
+    new_mm = typeof(mm)(new_nparentrows, count(!iszero, old_to_new_var), new_nzrows, new_row_cols, new_row_vals)
+    return SparseArrays.dropzeros!(new_mm)
 end
 
 struct BadMMAliasError <: Exception

test/runtests.jl

@@ -59,4 +59,16 @@ include("carpanzano_tearing.jl")
     @test mm2.row_cols == [[1, 2]]
     @test mm2.row_vals == [[7, 5]]
     @test mm2.ncols == 2
+
+    # An alias carrying an explicit stored zero (as `sparsevec` produces when
+    # duplicate indices cancel) must not leak in as a phantom structural nonzero.
+    # Row references var2 (removed, aliased to 0*var1) and var3 (retained); there
+    # is no direct var1 term, so the only contribution to col 1 is the zero.
+    mm = SSel.CLIL.SparseMatrixCLIL([0 1 1])
+    old_to_new_eq = [1]
+    old_to_new_var = [1, 0, 2]
+    aliases = Dict(2 => sparsevec([1, 1], [2, -2], 3))
+    mm2 = SSel.get_new_mm(aliases, old_to_new_eq, old_to_new_var, mm)
+    @test mm2.row_cols == [[2]]
+    @test mm2.row_vals == [[1]]
 end