add attributes to simvals and x, add test

Author: wpbonelli

autotest/test_gwf_bmi_var_attributes.py

@@ -0,0 +1,83 @@
+"""
+Test that the memory manager's readonly/output variable attributes are
+enforced uniformly through the BMI, not just by convention:
+
+- get_input_var_names()/get_output_var_names() are filtered on these
+  attributes rather than dumping the whole memory store.
+- a readonly variable (WEL's SIMVALS) cannot be written via set_value(),
+  regardless of which BMI entry point is used.
+- a variable that is both writable and output (the model's X/head array)
+  can legitimately appear in both lists and be written.
+"""
+
+import flopy
+import numpy as np
+import pytest
+from modflow_devtools.markers import requires_pkg
+
+name = "bmiattrs"
+nlay, nrow, ncol = 1, 1, 5
+delr = delc = 1.0
+top = 1.0
+botm = [0.0]
+k = 1.0
+strt = 10.0
+chd_head = 10.0
+wellq = -1.0
+
+
+@pytest.fixture
+def simple_sim(tmp_path):
+    """A trivial, linear, steady-state 1D column: CHD on one end, WEL on the other."""
+    sim = flopy.mf6.MFSimulation(sim_name=name, sim_ws=str(tmp_path))
+    flopy.mf6.ModflowTdis(sim, nper=1, perioddata=[(1.0, 1, 1.0)])
+    flopy.mf6.ModflowIms(sim, outer_dvclose=1e-8, inner_dvclose=1e-8)
+    gwf = flopy.mf6.ModflowGwf(sim, modelname=name)
+    flopy.mf6.ModflowGwfdis(
+        gwf, nlay=nlay, nrow=nrow, ncol=ncol, delr=delr, delc=delc, top=top, botm=botm
+    )
+    flopy.mf6.ModflowGwfic(gwf, strt=strt)
+    flopy.mf6.ModflowGwfnpf(gwf, icelltype=0, k=k)
+    flopy.mf6.ModflowGwfchd(gwf, stress_period_data=[[(0, 0, 0), chd_head]])
+    flopy.mf6.ModflowGwfwel(
+        gwf, pname="WEL_0", stress_period_data=[[(0, 0, ncol - 1), wellq]]
+    )
+    sim.write_simulation()
+    return sim
+
+
+@requires_pkg("xmipy")
+def test_var_attributes(simple_sim, targets):
+    from xmipy import XmiWrapper
+    from xmipy.errors import XMIError
+
+    sim = simple_sim
+    mf6 = XmiWrapper(lib_path=targets["libmf6"], working_directory=sim.sim_path)
+    mf6.initialize()
+
+    simvals_addr = mf6.get_var_address("SIMVALS", name, "WEL_0")
+    x_addr = mf6.get_var_address("X", name)
+
+    input_vars = mf6.get_input_var_names()
+    output_vars = mf6.get_output_var_names()
+
+    # SIMVALS is readonly + output: input-excluded, output-included
+    assert simvals_addr not in input_vars
+    assert simvals_addr in output_vars
+
+    # X is writable + output: appears in both
+    assert x_addr in input_vars
+    assert x_addr in output_vars
+
+    # writing SIMVALS should be rejected uniformly, regardless of entry point
+    simvals = mf6.get_value_ptr(simvals_addr)
+    with pytest.raises(XMIError, match="read-only"):
+        mf6.set_value(simvals_addr, np.zeros_like(simvals))
+
+    # writing X should succeed, since it's not readonly
+    x = mf6.get_value_ptr(x_addr)
+    new_x = np.full_like(x, 5.0)
+    mf6.set_value(x_addr, new_x)
+    np.testing.assert_array_equal(mf6.get_value_ptr(x_addr), new_x)
+
+    mf6.finalize()

src/Model/ModelUtilities/BoundaryPackage.f90

@@ -1004,7 +1004,7 @@ end subroutine allocate_scalars
   !<
   subroutine allocate_arrays(this, nodelist, auxvar)
     ! -- modules
-    use MemoryManagerModule, only: mem_allocate, mem_setptr
+    use MemoryManagerModule, only: mem_allocate, mem_setptr, mem_set_attributes
     ! -- dummy
     class(BndType) :: this !< BndType object
     integer(I4B), dimension(:), pointer, contiguous, optional :: nodelist !< package nodelist
@@ -1044,6 +1044,10 @@ subroutine allocate_arrays(this, nodelist, auxvar)
     !
     ! -- Allocate the simvals array
     call mem_allocate(this%simvals, this%maxbound, 'SIMVALS', this%memoryPath)
+    ! -- simvals is a computed, per-timestep budget term: not user-writable,
+    !    and it's the canonical example of a pure output variable
+    call mem_set_attributes('SIMVALS', this%memoryPath, readonly=.true., &
+                             output=.true.)
     if (this%imover == 1) then
       call mem_allocate(this%simtomvr, this%maxbound, 'SIMTOMVR', &
                         this%memoryPath)

src/Model/NumericalModel.f90

@@ -294,7 +294,7 @@ subroutine allocate_arrays(this)
   end subroutine allocate_arrays
 
   subroutine set_xptr(this, xsln, sln_offset, varNameTgt, memPathTgt)
-    use MemoryManagerModule, only: mem_checkin
+    use MemoryManagerModule, only: mem_checkin, mem_set_attributes
     ! dummy
     class(NumericalModelType) :: this
     real(DP), dimension(:), pointer, contiguous, intent(in) :: xsln
@@ -307,6 +307,10 @@ subroutine set_xptr(this, xsln, sln_offset, varNameTgt, memPathTgt)
     offset = this%moffset - sln_offset
     this%x => xsln(offset + 1:offset + this%neq)
     call mem_checkin(this%x, 'X', this%memoryPath, varNameTgt, memPathTgt)
+    ! X is the model's primary dependent-variable output, but unlike SIMVALS
+    ! it's also a legitimate write target (e.g. coupled-model workflows write
+    ! it directly) - output, but not readonly
+    call mem_set_attributes('X', this%memoryPath, output=.true.)
   end subroutine set_xptr
 
   subroutine set_rhsptr(this, rhssln, sln_offset, varNameTgt, memPathTgt)