imas-python 0.1.dev1618__py3-none-any.whl

imas/test/test_ids_coordinates.py

@@ -0,0 +1,165 @@
+import numpy as np
+import pytest
+
+from imas.ids_coordinates import IDSCoordinate
+from imas.ids_defs import IDS_TIME_MODE_HETEROGENEOUS, IDS_TIME_MODE_HOMOGENEOUS
+from imas.ids_factory import IDSFactory
+
+
+def test_coordinate_cache():
+    coordinate = IDSCoordinate("1...N")
+    coordinate2 = IDSCoordinate("1...N")
+    assert coordinate is coordinate2
+
+
+def test_coordinate_str_repr():
+    coordinate = IDSCoordinate("test_coordinate")
+    assert str(coordinate) == "test_coordinate"
+    assert repr(coordinate) == "IDSCoordinate('test_coordinate')"
+
+
+def test_coordinate_index_unbounded():
+    coordinate = IDSCoordinate("1...N")
+    assert coordinate.size is None
+    assert not coordinate.references
+    assert not coordinate.has_alternatives
+    assert not coordinate.has_validation
+
+
+@pytest.mark.parametrize("size", range(1, 5))
+def test_coordinate_index_bounded(size):
+    coordinate = IDSCoordinate(f"1...{size}")
+    assert coordinate.size == size
+    assert not coordinate.references
+    assert coordinate.has_validation
+    assert not coordinate.has_alternatives
+
+
+def test_coordinate_with_path():
+    coordinate = IDSCoordinate("time")
+    assert coordinate.size is None
+    assert len(coordinate.references) == 1
+    assert str(coordinate.references[0]) == "time"
+    assert coordinate.has_validation
+    assert not coordinate.has_alternatives
+
+
+def test_coordinate_with_multiple_paths():
+    coordinate = IDSCoordinate(
+        "distribution(i1)/profiles_2d(itime)/grid/r OR "
+        "distribution(i1)/profiles_2d(itime)/grid/rho_tor_norm"
+    )
+    assert coordinate.size is None
+    assert len(coordinate.references) == 2
+    assert coordinate.has_validation
+    assert coordinate.has_alternatives
+
+
+def test_coordinate_with_path_or_size():
+    coordinate = IDSCoordinate(
+        "coherent_wave(i1)/beam_tracing(itime)/beam(i2)/length OR 1...1"
+    )
+    assert coordinate.size == 1
+    assert len(coordinate.references) == 1
+    assert coordinate.has_validation
+    assert coordinate.has_alternatives
+
+
+@pytest.mark.parametrize("spec", ["1...N_charge_states", "1..2"])
+def test_coordinate_invalid(spec, caplog: pytest.LogCaptureFixture):
+    with caplog.at_level("DEBUG", "imas.ids_coordinates"):
+        caplog.clear()
+        IDSCoordinate._cache.pop(spec, None)  # Remove spec from cache (if exists)
+        coordinate = IDSCoordinate(spec)
+        assert len(caplog.records) == 1
+        assert not coordinate.has_validation
+
+
+def test_coordinate_immutable():
+    coordinate = IDSCoordinate("1...N")
+    with pytest.raises(RuntimeError):
+        coordinate.has_validation = True
+
+
+def test_format_refs():
+    core_profiles = IDSFactory(version="3.39.0").new("core_profiles")
+    core_profiles.profiles_1d.resize(2)
+    p1d = core_profiles.profiles_1d[1]
+    refs = p1d.magnetic_shear.metadata.coordinate1.format_refs(p1d)
+    assert refs == "`profiles_1d[1]/grid/rho_tor_norm`"
+
+    distributions = IDSFactory(version="3.39.0").new("distributions")
+    distributions.distribution.resize(2)
+    distributions.distribution[1].profiles_2d.resize(5)
+    p2d = distributions.distribution[1].profiles_2d[2]
+    refs1 = p2d.density.metadata.coordinate1.format_refs(p2d)
+    assert refs1 == (
+        "`distribution[1]/profiles_2d[2]/grid/r`, "
+        "`distribution[1]/profiles_2d[2]/grid/rho_tor_norm`"
+    )
+    refs2 = p2d.density.metadata.coordinate2.format_refs(p2d)
+    assert refs2 == (
+        "`distribution[1]/profiles_2d[2]/grid/z`, "
+        "`distribution[1]/profiles_2d[2]/grid/theta_geometric`, "
+        "`distribution[1]/profiles_2d[2]/grid/theta_straight`"
+    )
+
+
+def test_coordinates(ids_minimal_types):
+    root = IDSFactory(xml_path=ids_minimal_types)
+    ids = root.new("minimal")
+
+    assert len(ids.flt_0d.coordinates) == 0
+    assert len(ids.flt_1d.coordinates) == 1
+    assert len(ids.flt_2d.coordinates) == 2
+    assert len(ids.flt_3d.coordinates) == 3
+    assert len(ids.flt_4d.coordinates) == 4
+    assert len(ids.flt_5d.coordinates) == 5
+    assert len(ids.flt_6d.coordinates) == 6
+
+    ids.flt_1d = [1, 2, 4]
+    assert ids.flt_1d.metadata.coordinates[0].size == 3
+    assert all(ids.flt_1d.coordinates[0] == np.arange(3))
+
+    ids.flt_3d = np.ones((3, 4, 2))
+    assert ids.flt_3d.coordinates[0] is ids.flt_1d
+    assert all(ids.flt_3d.coordinates[1] == np.arange(4))
+    assert all(ids.flt_3d.coordinates[2] == np.arange(2))
+
+    ids.cpx_1d = [1 - 1j]
+    assert ids.cpx_1d.coordinates[0] is ids.flt_1d
+    # if both flt_1d and int_1d are set, this should give an error
+    ids.int_1d = [1]
+    with pytest.raises(Exception):
+        ids.cpx_1d.coordinates[0]
+
+
+def test_coordinates_with_core_profiles():
+    core_profiles = IDSFactory(version="3.39.0").new("core_profiles")
+    with pytest.raises(ValueError):  # homogeneous_time not set
+        core_profiles.profiles_1d.coordinates[0]
+
+    core_profiles.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    assert core_profiles.profiles_1d.coordinates[0] is core_profiles.time
+
+    core_profiles.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    # Test logic for getting time coordinates from inside the core_profiles AoS
+    core_profiles.profiles_1d.resize(2)
+    core_profiles.profiles_1d[0].time = 1
+    core_profiles.profiles_1d[1].time = 2
+    assert np.array_equal(core_profiles.profiles_1d.coordinates[0], [1.0, 2.0])
+
+
+def test_coordinates_with_equilibrium():
+    # Test error handling of a time-based coordinate outside our own timebasepath
+    # https://jira.iter.org/browse/IMAS-4675
+    equilibrium = IDSFactory(version="3.39.0").new("equilibrium")
+    equilibrium.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    equilibrium.grids_ggd.resize(1)
+    equilibrium.time_slice.resize(1)
+    with pytest.raises(RuntimeError):
+        equilibrium.time_slice[0].ggd.coordinates[0]
+
+
+# TODO: test "<path> OR 1...1" coordinates: https://jira.iter.org/browse/IMAS-4661
+# TODO: test complex amns_data coordinates: https://jira.iter.org/browse/IMAS-4666

imas/test/test_ids_data_type.py

@@ -0,0 +1,40 @@
+import pytest
+
+from imas.ids_data_type import IDSDataType
+
+
+def test_legacy_type():
+    assert IDSDataType.parse("str_type") == (IDSDataType.STR, 0)
+    assert IDSDataType.parse("str_1d_type") == (IDSDataType.STR, 1)
+    assert IDSDataType.parse("flt_type") == (IDSDataType.FLT, 0)
+    assert IDSDataType.parse("flt_1d_type") == (IDSDataType.FLT, 1)
+    assert IDSDataType.parse("int_type") == (IDSDataType.INT, 0)
+
+
+@pytest.mark.parametrize("ndim", range(2))  # max string dimension is STR_1D
+def test_str_types(ndim):
+    assert IDSDataType.parse(f"STR_{ndim}D") == (IDSDataType.STR, ndim)
+
+
+@pytest.mark.parametrize("ndim", range(4))  # max integer dimension is INT_3D
+def test_int_types(ndim):
+    assert IDSDataType.parse(f"INT_{ndim}D") == (IDSDataType.INT, ndim)
+
+
+@pytest.mark.parametrize("ndim", range(7))  # max floatt dimension is FLT_6D
+def test_flt_types(ndim):
+    assert IDSDataType.parse(f"FLT_{ndim}D") == (IDSDataType.FLT, ndim)
+
+
+@pytest.mark.parametrize("ndim", range(7))  # max complex dimension is CPX_6D
+def test_cpx_types(ndim):
+    assert IDSDataType.parse(f"CPX_{ndim}D") == (IDSDataType.CPX, ndim)
+
+
+def test_default_values():
+    assert IDSDataType.STR.default == ""
+    assert IDSDataType.INT.default == -999_999_999
+    assert IDSDataType.FLT.default == -9e40
+    assert IDSDataType.CPX.default == -9e40 - 9e40j
+    assert IDSDataType.STRUCT_ARRAY.default is None
+    assert IDSDataType.STRUCTURE.default is None

imas/test/test_ids_factory.py

@@ -0,0 +1,35 @@
+import pytest
+
+from imas.dd_zip import latest_dd_version
+from imas.ids_factory import IDSFactory
+
+
+def test_ids_factory_with_version():
+    IDSFactory(version="3.39.0")
+
+
+def test_ids_factory_with_invalid_version():
+    # This raises a packaging.version.InvalidVersion exception, but any exception is ok
+    with pytest.raises(Exception):
+        IDSFactory(version="invalid")
+    # This is a valid version string, but we don't have it available
+    with pytest.raises(ValueError):
+        IDSFactory(version="0.1.2.3.4")
+
+
+def test_ids_factory_with_xml_path(ids_minimal):
+    IDSFactory(xml_path=ids_minimal)
+
+
+def test_ids_factory_latest(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.delenv("IMAS_VERSION", raising=False)
+    monkeypatch.delenv("IMAS_PREFIX", raising=False)
+    factory = IDSFactory()
+    assert factory._version == latest_dd_version()
+
+
+def test_ids_factory_from_env(monkeypatch: pytest.MonkeyPatch):
+    version = "3.35.0"
+    monkeypatch.setenv("IMAS_VERSION", version)
+    factory = IDSFactory()
+    assert factory._version == version

imas/test/test_ids_metadata.py

@@ -0,0 +1,66 @@
+from copy import deepcopy
+
+import pytest
+
+from imas.ids_factory import IDSFactory
+from imas.ids_metadata import IDSType, get_toplevel_metadata
+
+
+def test_metadata_cache(fake_structure_xml):
+    meta = get_toplevel_metadata(fake_structure_xml)
+    meta2 = get_toplevel_metadata(fake_structure_xml)
+    assert meta is meta2
+
+
+def test_metadata_init_structure_xml(fake_structure_xml):
+    meta = get_toplevel_metadata(fake_structure_xml)
+    assert fake_structure_xml.attrib["name"] == "gyrokinetics"
+    assert meta.name == "gyrokinetics"
+
+
+def test_metadata_deepcopy(fake_structure_xml):
+    meta = get_toplevel_metadata(fake_structure_xml)
+    meta2 = deepcopy(meta)
+
+    # Test that deepcopy returns the same reference
+    assert meta is meta2
+    assert meta == meta2
+
+
+def test_metadata_immutable(fake_structure_xml):
+    meta = get_toplevel_metadata(fake_structure_xml)
+    with pytest.raises(RuntimeError):
+        meta.immutable = True
+    with pytest.raises(RuntimeError):
+        del meta.name
+
+
+def test_ids_type():
+    assert not IDSType.NONE.is_dynamic
+    assert not IDSType.CONSTANT.is_dynamic
+    assert not IDSType.STATIC.is_dynamic
+    assert IDSType.DYNAMIC.is_dynamic
+
+
+def test_metadata_indexing():
+    core_profiles = IDSFactory("3.39.0").core_profiles()
+    metadata = core_profiles.metadata
+    assert metadata["ids_properties"] is core_profiles.ids_properties.metadata
+    assert (
+        metadata["ids_properties/version_put"]
+        is core_profiles.ids_properties.version_put.metadata
+    )
+    assert metadata["time"] is core_profiles.time.metadata
+    p1d_time_meta = metadata["profiles_1d/time"]
+    core_profiles.profiles_1d.resize(1)
+    assert p1d_time_meta is core_profiles.profiles_1d[0].time.metadata
+
+    # Test period (.) as separator:
+    assert (
+        metadata["profiles_1d/electrons/temperature"]
+        is metadata["profiles_1d.electrons.temperature"]
+    )
+
+    # Test invalid path
+    with pytest.raises(KeyError):
+        metadata["DoesNotExist"]

imas/test/test_ids_mixin.py

@@ -0,0 +1,20 @@
+# This file is part of imas-python.
+# You should have received the imas-python LICENSE file with this project.
+
+
+def test_toplevel(fake_filled_toplevel):
+    top = fake_filled_toplevel
+    assert top.wavevector._toplevel == top
+    assert top.wavevector[0].radial_component_norm._toplevel == top
+
+
+def test_path(fake_filled_toplevel):
+    top = fake_filled_toplevel
+    assert top.wavevector._path == "wavevector"
+    assert top.ids_properties.creation_date._path == "ids_properties/creation_date"
+    assert top.wavevector._path == "wavevector"
+    assert top.wavevector[0]._path == "wavevector[0]"
+    assert (
+        top.wavevector[0].radial_component_norm._path
+        == "wavevector[0]/radial_component_norm"
+    )

imas/test/test_ids_path.py

@@ -0,0 +1,192 @@
+import pytest
+
+from imas.ids_factory import IDSFactory
+from imas.ids_path import IDSPath
+
+
+def test_path_cache():
+    path = IDSPath("uniq")
+    path2 = IDSPath("uniq")
+    assert path is path2
+
+
+def test_path_str_repr():
+    path = IDSPath("test/path")
+    assert str(path) == "test/path"
+    assert repr(path) == "IDSPath('test/path')"
+
+
+def test_empty_path():
+    path = IDSPath("")
+    assert path.parts == ()
+    assert path.indices == ()
+
+
+def test_path_without_slashes_and_indices():
+    path = IDSPath("ids_properties")
+    assert path.parts == ("ids_properties",)
+    assert path.indices == (None,)
+
+
+def test_path_without_slashes():
+    path = IDSPath("profiles_1d(itime)")
+    assert path.parts == ("profiles_1d",)
+    assert path.indices == ("itime",)
+
+
+def test_path_without_indices():
+    path = IDSPath("ids_properties/version_put/data_dictionary")
+    assert path.parts == ("ids_properties", "version_put", "data_dictionary")
+    assert path.indices == (None, None, None)
+
+
+def test_path_with_dummy_indices():
+    path = IDSPath(
+        "time_slice(itime)/ggd(i1)/grid/space(i2)/objects_per_dimension(i3)/"
+        "object(i4)/boundary(i5)"
+    )
+    assert path.parts == (
+        "time_slice",
+        "ggd",
+        "grid",
+        "space",
+        "objects_per_dimension",
+        "object",
+        "boundary",
+    )
+    assert path.indices == ("itime", "i1", None, "i2", "i3", "i4", "i5")
+
+
+def test_path_with_path_index():
+    path = IDSPath("coordinate_system(process(i1)/coordinate_index)/coordinate(1)")
+    assert path.parts == ("coordinate_system", "coordinate")
+    assert isinstance(path.indices[0], IDSPath)
+    assert path.indices[0].parts == ("process", "coordinate_index")
+    assert path.indices[0].indices == ("i1", None)
+    assert path.indices[1] == 0
+    assert len(path.indices) == 2
+
+
+@pytest.mark.parametrize(
+    "pth",
+    ["distribution(1:3)/process(:)/nbi_unit", "distribution[0:3]/process[:]/nbi_unit"],
+)
+def test_path_with_slices(pth):
+    path = IDSPath(pth)
+    assert path.parts == ("distribution", "process", "nbi_unit")
+    assert path.indices == (slice(0, 3), slice(None), None)
+
+
+def test_path_integer_indices():
+    py_path = IDSPath("a[1]/b[2]/c[:2]/d[1:]")
+    f_path = IDSPath("a(2)/b(3)/c(:2)/d(2:)")
+    assert py_path.indices[0] == f_path.indices[0] == 1
+    assert py_path.indices[1] == f_path.indices[1] == 2
+    assert py_path.indices[2] == f_path.indices[2] == slice(None, 2)
+    assert py_path.indices[3] == f_path.indices[3] == slice(1, None)
+
+
+def test_path_immutable():
+    path = IDSPath("")
+    with pytest.raises(RuntimeError):
+        path.some_attr = True
+    with pytest.raises(RuntimeError):
+        path.parts = (1, 2)
+
+
+def test_path_time():
+    assert not IDSPath("no_time").is_time_path
+    assert IDSPath("time").is_time_path
+    assert IDSPath("profiles_1d(itime)/time").is_time_path
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "empty//part",
+        "(empty_part)",
+        "_invalid_node_name",
+        "another__invalid_node_name",
+        "CAPS_IS_ALSO_NOT_ALLOWED",
+        "nor are spaces",
+        "or.periods",
+        "or_commas,",
+        "unmatched(parentheses()",
+        "unmatched)(parentheses",
+    ],
+)
+def test_invalid_paths(path):
+    with pytest.raises(ValueError):
+        IDSPath(path)
+
+
+def test_path_goto(fake_toplevel_xml):
+    ids = IDSFactory(xml_path=fake_toplevel_xml).new("gyrokinetics")
+
+    version_put_path = IDSPath("ids_properties/version_put")
+    assert version_put_path.goto(ids) is ids.ids_properties.version_put
+
+    ids.wavevector.resize(2)
+    ids.wavevector[0].eigenmode.resize(2)
+
+    ids.wavevector[0].eigenmode[0].growth_rate_norm = 1.23
+    growth_rate_norm_path = IDSPath("wavevector(i1)/eigenmode(i2)/growth_rate_norm")
+    # We cannot address this path from the root (because of the dummy 'i1' and 'i2'):
+    with pytest.raises(ValueError):
+        growth_rate_norm_path.goto(ids)
+    # But we can when there is a common parent
+    assert (
+        growth_rate_norm_path.goto(ids.wavevector[0].eigenmode[0].frequency_norm)
+        is ids.wavevector[0].eigenmode[0].growth_rate_norm
+    )
+    # One common parent (of the two) is not enough
+    with pytest.raises(ValueError):
+        growth_rate_norm_path.goto(ids.wavevector[0])
+
+    # With explicit (1-based) indices we can resolve from ids
+    growth_rate_norm_path2 = IDSPath("wavevector(1)/eigenmode(1)/growth_rate_norm")
+    assert (
+        growth_rate_norm_path2.goto(ids)
+        is ids.wavevector[0].eigenmode[0].growth_rate_norm
+    )
+
+    radial_component_norm_path = IDSPath("wavevector(i1)/radial_component_norm")
+    assert (
+        radial_component_norm_path.goto(ids.wavevector[0].eigenmode[0].frequency_norm)
+        is ids.wavevector[0].radial_component_norm
+    )
+
+    # Use homogeneous_time (the only INT_0D in this fake IDS) as an indirect index
+    ids.ids_properties.homogeneous_time = 1
+    indirect_path = IDSPath("wavevector(ids_properties/homogeneous_time)")
+    assert indirect_path.goto(ids) is ids.wavevector[0]
+    ids.ids_properties.homogeneous_time = 2
+    assert indirect_path.goto(ids) is ids.wavevector[1]
+
+    # But it's not allowed to use a non INT_0D as indirect index
+    with pytest.raises(ValueError):
+        IDSPath("wavevector(ids_properties/comment)").goto(ids)
+
+    # Test that we can goto the same path
+    assert IDSPath("wavevector").goto(ids.wavevector[1]) is ids.wavevector[1]
+
+
+def test_path_goto_metadata():
+    es = IDSFactory(version="3.42.0").new("edge_sources")
+    path = IDSPath("source/ggd/ion/energy")
+    energy_metadata = path.goto_metadata(es.metadata)
+
+    es.source.resize(1)
+    es.source[0].ggd.resize(1)
+    es.source[0].ggd[0].ion.resize(1)
+    energy = es.source[0].ggd[0].ion[0].energy
+    assert energy_metadata == energy.metadata
+
+    # Test when path does not exist in metadata
+    wrong_path = IDSPath("ggd/ion/energy")
+    with pytest.raises(ValueError):
+        wrong_path.goto_metadata(es.metadata)
+
+    sub_path = IDSPath("ggd/ion/energy")
+    energy_metadata = sub_path.goto_metadata(es.source.metadata)
+    assert energy_metadata == energy.metadata

imas/test/test_ids_primitive.py

@@ -0,0 +1,109 @@
+# This file is part of imas-python.
+# You should have received the imas-python LICENSE file with this project.
+import pprint
+
+import numpy as np
+
+from imas.ids_primitive import IDSPrimitive
+from imas.util import visit_children
+
+# As the IDSPrimitive class generally should not be used on its own. Instead we
+# take a very well defined toplevel, initialize it, and do our tests on the
+# tree structure that is generated. Keep the tests just to the functionality
+# that is defined in ids_primitive.py though!
+
+
+zero_to_two_pi = np.linspace(0, 2, num=10) * np.pi
+
+
+def test_pretty_print(fake_filled_toplevel):
+    eig = fake_filled_toplevel.wavevector[0].eigenmode[0]
+    assert pprint.pformat(fake_filled_toplevel).startswith("<IDSToplevel")
+    assert pprint.pformat(fake_filled_toplevel.wavevector[0].eigenmode).startswith(
+        "<IDSStructArray ("
+    )
+    assert pprint.pformat(fake_filled_toplevel.wavevector[0].eigenmode[0]).startswith(
+        "<IDSStructure ("
+    )
+    assert pprint.pformat(eig.time_norm).startswith("<IDSNumericArray")
+    assert pprint.pformat(eig.time_norm).endswith("empty FLT_1D)>")
+    assert pprint.pformat(eig.frequency_norm).startswith("<IDSFloat0D")
+    assert pprint.pformat(eig.frequency_norm).endswith("\nfloat(10.0)")
+    fake_filled_toplevel.ids_properties.comment = "A filled comment"
+    assert (
+        pprint.pformat(fake_filled_toplevel.ids_properties.comment)
+        == """<IDSString0D (IDS:gyrokinetics, ids_properties/comment, STR_0D)>
+str('A filled comment')"""
+    )
+
+
+def test_value_attribute(fake_filled_toplevel):
+    """Test if the value attribute acts as imas-python expects"""
+    eig = fake_filled_toplevel.wavevector[0].eigenmode[0]
+    assert isinstance(eig.frequency_norm, IDSPrimitive)
+    assert hasattr(eig.frequency_norm, "value")
+
+    # We should have a Python Primitive now:
+    assert eig.frequency_norm.data_type == "FLT_0D"
+    assert isinstance(eig.frequency_norm.value, float)
+    assert eig.frequency_norm.value == 10
+
+    # For arrays, we should get numpy arrays of the right type
+    # This one should be not-filled, e.g. default
+    assert not eig.phi_potential_perturbed_norm.has_value
+    assert eig.phi_potential_perturbed_norm.data_type == "CPX_2D"
+    assert isinstance(eig.phi_potential_perturbed_norm.value, np.ndarray)
+    assert np.array_equal(eig.phi_potential_perturbed_norm.value, np.ndarray((0, 0)))
+
+    # Finally, check a filled array
+    assert eig.poloidal_angle.has_value
+    assert eig.poloidal_angle.data_type == "FLT_1D"
+    assert isinstance(eig.poloidal_angle.value, np.ndarray)
+    assert np.array_equal(eig.poloidal_angle.value, zero_to_two_pi)
+
+
+def test_visit_children(fake_filled_toplevel):
+    # This should visit leaf nodes only. Lets test that, but check only
+    # filled fields explicitly
+    nodes = []
+
+    def append_if_has_value(xx):
+        if xx.has_value:
+            nodes.append(xx)
+
+    visit_children(append_if_has_value, fake_filled_toplevel)
+    assert len(nodes) == 3
+    assert nodes[0] == 2
+    assert nodes[1] == 10
+    assert np.array_equal(nodes[2], zero_to_two_pi)
+
+
+def test_visit_children_internal_nodes(fake_filled_toplevel):
+    nodes = []
+
+    def append_if_has_value(xx):
+        if xx.has_value:
+            nodes.append(xx)
+
+    visit_children(append_if_has_value, fake_filled_toplevel, leaf_only=False)
+    # We now visit the internal nodes too.
+
+    # We know we filled only endpoints frequency_norm and poloidal_angle
+    # We expect the following "mandatory" fields to be touched, which we check
+    # in the order visit_children visits
+    assert len(nodes) == 9
+    assert nodes[0] is fake_filled_toplevel
+    assert nodes[1] is fake_filled_toplevel.ids_properties
+    assert nodes[2] == 2
+    assert nodes[3] is fake_filled_toplevel.wavevector
+    assert nodes[4] is fake_filled_toplevel.wavevector[0]
+    assert nodes[5] is fake_filled_toplevel.wavevector[0].eigenmode
+    assert nodes[6] is fake_filled_toplevel.wavevector[0].eigenmode[0]
+    assert nodes[7] == 10
+    assert np.array_equal(nodes[8], zero_to_two_pi)
+
+
+def test_assign_nan(fake_filled_toplevel, caplog):
+    with caplog.at_level("DEBUG"):
+        fake_filled_toplevel.wavevector[0].radial_component_norm = float("nan")
+    assert len(caplog.records) == 0