TST: Delete old tests for iterative, time dependent and reference ad operators

These have been replaced with a more refined suite of tests

Author: keileg

tests/numerics/ad/test_operators.py

@@ -650,307 +650,6 @@ def _compare_ad_objects(a, b):
     )
 
 
-@pytest.mark.parametrize("prev_time", [True, False])
-def test_ad_variable_prev_time_and_iter(prev_time):
-    # Test only 1 variable, the rest should be covered by other tests
-    mdg, _ = pp.mdg_library.square_with_orthogonal_fractures(
-        "cartesian",
-        {"cell_size": 0.5},
-        fracture_indices=[1],
-    )
-    equation_system = pp.ad.EquationSystem(mdg)
-
-    # Integer to test the depth of prev _*, could be a test parameter, but no need
-    depth = 4
-    var_name = "foo"
-    vec = np.ones(mdg.num_subdomain_cells())
-
-    equation_system.create_variables(
-        var_name, dof_info={"cells": 1}, subdomains=mdg.subdomains()
-    )
-    var = equation_system.md_variable(var_name)
-
-    # Starting point is time step index is None, iterate index is 0
-    # (current time and iter)
-    assert var.time_step_index is None
-    assert var.iterate_index == 0
-
-    # For AD to work, we need at least values at iterate_index = 0
-    equation_system.set_variable_values(vec * 0.0, [var], iterate_index=0)
-
-    # Test configuration dependent on whether prev iter or prev time is tested.
-    # Code is analogous
-    if prev_time:
-        index_key = "time_step_index"
-        other_index_key = "iterate_index"
-        get_prev_key = "previous_timestep"
-
-        # prohibit prev time step variable to also be prev iter
-        with pytest.raises(ValueError):
-            var_pt = var.previous_timestep()
-            _ = var_pt.previous_iteration()
-    else:
-        index_key = "iterate_index"
-        other_index_key = "time_step_index"
-        get_prev_key = "previous_iteration"
-
-        # prohibit prev iter variable to also be prev time
-        with pytest.raises(ValueError):
-            var_pi = var.previous_iteration()
-            _ = var_pi.previous_timestep()
-
-    # Set values except for the last step. The current value is set above
-    for i in range(depth - 1):
-        equation_system.set_variable_values(vec * i, [var], **{index_key: i})
-
-    # Evaluating the last step, should raise a key error because no values set
-    with pytest.raises(KeyError):
-        var_prev = getattr(var, get_prev_key)(steps=depth)
-        _ = equation_system.evaluate(var_prev)
-
-    # Evaluate prev var and check that the values are what they're supposed to be. First
-    # check current variable value.
-    var = getattr(var, get_prev_key)(steps=0)
-    val_0 = equation_system.evaluate(var)
-    assert np.allclose(val_0, 0)
-    # Then do the same for all previous steps.
-    for i in range(depth - 1):
-        var_i = getattr(var, get_prev_key)(steps=i + 1)
-        val_i = equation_system.evaluate(var_i)
-        assert np.allclose(val_i, i)
-        if i > 0:
-            # prev var has no Jacobian. That is not the case for i=0, corresponding to
-            # the variable itself.
-            ad_i = var_i.value_and_jacobian(equation_system)
-            assert np.all(ad_i.jac.toarray() == 0.0)
-
-    # Test creating with explicit stepping and recursive stepping
-    vars_exp = [getattr(var, get_prev_key)(steps=i) for i in range(0, depth)]
-
-    vars_rec = []
-    for i in range(0, depth):
-        var_i = copy.copy(var)
-        for _ in range(i):
-            var_i = getattr(var_i, get_prev_key)()
-        vars_rec.append(var_i)
-
-    assert len(vars_exp) == len(vars_rec)
-    vals_exp = [equation_system.evaluate(v) for v in vars_exp]
-    vals_rec = [equation_system.evaluate(v) for v in vars_rec]
-
-    for v_e, v_r in zip(vals_exp, vals_rec):
-        assert np.allclose(v_e, v_r)
-
-    # Testing IDs. NOTE as of now, variables at prev iter have the same ID until
-    # full support is given
-    all_ids = set([var.id] + [v.id for v in vars_exp] + [v.id for v in vars_rec])
-    assert len(all_ids) == 1
-
-    # Testing index values.
-    # For prev time, time step index increases starting from 0, while iterate is None
-    # For prev iter, iterate index increases starting from 0, while time is always None
-    # Only relevant for previous values, not the variable itself.
-    for i in range(depth - 1):
-        assert getattr(vars_exp[i + 1], index_key) == i
-        assert getattr(vars_exp[i + 1], other_index_key) is None
-        assert getattr(vars_rec[i + 1], index_key) == i
-        assert getattr(vars_rec[i + 1], other_index_key) is None
-
-
-@pytest.mark.parametrize("reference", [None, "set", "shift"])
-@pytest.mark.parametrize("state", [None, "previous_timestep", "previous_iteration"])
-def test_ad_variable_reference(reference, state):
-    """Test the reference values of variables.
-
-    Test whether explicitly set and default reference values are correctly evaluated,
-    and that the associated Jacobian of the reference is zero.
-
-    Test both for the current variable, and for variables at previous time steps and
-    iterations.
-
-    """
-    mdg, _ = pp.mdg_library.square_with_orthogonal_fractures(
-        "cartesian",
-        {"cell_size": 0.5},
-        fracture_indices=[1],
-    )
-    equation_system = pp.ad.EquationSystem(mdg)
-
-    # Integer to test the depth of prev _*, could be a test parameter, but no need
-    var_name = "foo"
-    vec = np.ones(mdg.num_subdomain_cells())
-
-    equation_system.create_variables(
-        var_name, dof_info={"cells": 1}, subdomains=mdg.subdomains()
-    )
-    var = equation_system.md_variable(var_name)
-
-    # Starting point is that the variable is not a reference.
-    assert var.is_reference is False
-
-    # For AD to work, we need at least values at iterate_index = 0.
-    # Set purposefully different values than for reference.
-    equation_system.set_variable_values(vec * 3.0, [var], iterate_index=0)
-    equation_system.set_variable_values(vec * 2.0, [var], time_step_index=0)
-
-    # Define reference values, depending on the test parameter.
-    if reference is None:
-        # No action, the reference values should be the default (empty/zero).
-        pass
-    elif reference == "set":
-        # Explicitly set the reference values.
-        equation_system.set_variable_values(vec * 1.0, [var], reference=True)
-    elif reference == "shift":
-        # Shift current approximation to reference values.
-        for _, data in mdg.subdomains(return_data=True):
-            pp.shift_solution_values(var.name, data, pp.REFERENCE_SOLUTIONS)
-
-    # Bring variable in correct state for testing.
-    if state is None:
-        # No action, variable is already in correct state.
-        pass
-    elif state == "previous_timestep":
-        var = var.previous_timestep()
-    elif state == "previous_iteration":
-        var = var.previous_iteration()
-
-    # Value of variable.
-    ad_var = var.value_and_jacobian(equation_system)
-
-    # Evaluate reference and check that the values are what they're supposed to be.
-    ref = var.reference()
-    # Only expect reference for current iteration.
-    assert ref.is_reference == (state == None)
-    # Expected value.
-    if reference is None:
-        expected_ref_val = 0.0 if ref.is_reference else ad_var.val
-    elif reference == "set":
-        expected_ref_val = 1.0 if ref.is_reference else ad_var.val
-    elif reference == "shift":
-        expected_ref_val = 3.0 if ref.is_reference else ad_var.val
-
-    val_ref = equation_system.evaluate(ref)
-    ad_ref = ref.value_and_jacobian(equation_system)
-    assert np.allclose(val_ref, expected_ref_val)
-    assert np.allclose(ad_ref.val, expected_ref_val)
-    assert np.all(ad_ref.jac.toarray() == 0.0)
-
-    # Evaluate perturbation to reference and check that the values are what they're
-    # supposed to be.
-    perturbation = var.perturbation_from_reference()
-    val_perturbation = equation_system.evaluate(perturbation)
-    ad_perturbation = perturbation.value_and_jacobian(equation_system)
-    assert np.allclose(val_perturbation, ad_var.val - expected_ref_val)
-    assert np.allclose(ad_perturbation.val, ad_var.val - expected_ref_val)
-    assert np.all(ad_perturbation.jac.toarray() == ad_var.jac.toarray())
-
-    # Combine reference and perturbation, should give the same value as the
-    # variable itself.
-    combined = ref + perturbation
-    val_combined = equation_system.evaluate(combined)
-    assert np.allclose(val_combined, ad_var.val)
-    ad_combined = combined.value_and_jacobian(equation_system)
-    assert np.allclose(ad_combined.val, ad_var.val)
-    assert np.allclose(ad_combined.jac.toarray(), ad_var.jac.toarray())
-
-    # Check time increments of reference is zero.
-    if state is None:
-        ref_increment = pp.ad.time_increment(ref)
-        val_ref_increment = equation_system.evaluate(ref_increment)
-        assert np.allclose(val_ref_increment, 0.0)
-
-
-@pytest.mark.parametrize("state", [None, "previous_timestep"])
-@pytest.mark.parametrize("reference", [None, "set", "shift"])
-def test_time_dependent_array_reference(state, reference):
-    # Time-dependent arrays are defined on grids.
-    # Some boilerplate is needed to define these.
-    mdg, _ = pp.mdg_library.square_with_orthogonal_fractures(
-        "cartesian",
-        {"cell_size": 0.2},
-        fracture_indices=[1],
-    )
-    for sd, sd_data in mdg.subdomains(return_data=True):
-        vals_sol = np.zeros(sd.num_cells)
-        pp.set_solution_values(
-            name="foo", values=vals_sol, data=sd_data, time_step_index=0
-        )
-        vals_it = 2 * np.ones(sd.num_cells)
-        pp.set_solution_values(
-            name="foo", values=vals_it, data=sd_data, iterate_index=0
-        )
-
-        if reference is None:
-            # No action, the reference values should be the default (empty/zero).
-            pass
-        elif reference == "set":
-            # Explicitly set the reference values.
-            vals_ref = np.ones(sd.num_cells)
-            pp.set_solution_values(
-                name="foo", values=vals_ref, data=sd_data, reference=True
-            )
-        elif reference == "shift":
-            # Shift current approximation to reference values.
-            pp.shift_solution_values(
-                name="foo", data=sd_data, location=pp.REFERENCE_SOLUTIONS
-            )
-
-    # We make three arrays: One defined on a single subdomain, one on all subdomains of
-    # mdg and one on an interface.
-    sd_array = pp.ad.TimeDependentDenseArray(
-        "foo", domains=mdg.subdomains(dim=mdg.dim_max())
-    )
-
-    # Bring array in correct state for testing.
-    # Value of variable.
-    if state is None:
-        # No action, variable is already in correct state.
-        assert np.allclose(sd_array.parse(mdg), 2)
-    elif state == "previous_timestep":
-        sd_array = sd_array.previous_timestep()
-        assert np.allclose(sd_array.parse(mdg), 0)
-
-    # Build reference and check status.
-    ref = sd_array.reference()
-    # Only expect reference for current iteration.
-    if isinstance(ref, pp.numerics.ad._derived_operators.ReferenceOperator):
-        assert ref.is_reference == (state == None)
-
-    # Expected value.
-    array_val = sd_array.parse(mdg)
-    if reference is None:
-        expected_ref_val = 0.0 if ref.is_reference else array_val
-    elif reference == "set":
-        expected_ref_val = 1.0 if ref.is_reference else array_val
-    elif reference == "shift":
-        expected_ref_val = 2.0 if ref.is_reference else array_val
-
-    # Evaluate reference and check that the values are what they're supposed to be.
-    val_ref = ref.parse(mdg)
-    assert np.allclose(val_ref, expected_ref_val)
-
-    # Evaluate and check perturbation to reference.
-    # Require equation system for evaluation - parsing not sufficient.
-    equation_system = pp.ad.EquationSystem(mdg)
-    var_name = "foo_var"
-    equation_system.create_variables(
-        var_name, dof_info={"cells": 1}, subdomains=mdg.subdomains()
-    )
-    var = equation_system.md_variable(var_name)
-    vec = np.ones(mdg.num_subdomain_cells())
-    equation_system.set_variable_values(vec * 3.0, [var], iterate_index=0)
-    equation_system.set_variable_values(vec * 2.0, [var], time_step_index=0)
-    perturbation = sd_array.perturbation_from_reference()
-    val_perturbation = equation_system.evaluate(perturbation)
-    assert np.allclose(val_perturbation, array_val - expected_ref_val)
-
-    # Check time increments of reference is zero.
-    if state is None:
-        ref_increment = pp.ad.time_increment(ref)
-        val_ref_increment = equation_system.evaluate(ref_increment)
-        assert np.allclose(val_ref_increment, 0.0)
-
-
 @pytest.mark.parametrize(
     "grids",
     [