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

imas/test/test_latest_dd_resample.py

@@ -0,0 +1,102 @@
+"""A testcase checking if resampling works for the latest data dictionary version.
+"""
+
+import numpy as np
+
+import imas
+from imas.ids_defs import IDS_TIME_MODE_HOMOGENEOUS
+from imas.ids_factory import IDSFactory
+
+
+def test_single_resample_inplace():
+    nbi = IDSFactory().new("nbi")
+    nbi.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    nbi.time = [1, 2, 3]
+    nbi.unit.resize(1)
+    nbi.unit[0].energy.data = 2 * nbi.time
+    old_id = id(nbi.unit[0].energy.data)
+
+    assert nbi.unit[0].energy.data.coordinates.time_index == 0
+
+    imas.util.resample(
+        nbi.unit[0].energy.data,
+        nbi.time,
+        [0.5, 1.5],
+        nbi.ids_properties.homogeneous_time,
+        inplace=True,
+        fill_value="extrapolate",
+    )
+
+    assert old_id == id(nbi.unit[0].energy.data)
+    assert np.array_equal(nbi.unit[0].energy.data, [1, 3])
+
+
+def test_single_resample_copy():
+    nbi = IDSFactory().new("nbi")
+    nbi.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    nbi.time = [1, 2, 3]
+    nbi.unit.resize(1)
+    nbi.unit[0].energy.data = 2 * nbi.time
+    old_id = id(nbi.unit[0].energy.data)
+
+    assert nbi.unit[0].energy.data.coordinates.time_index == 0
+
+    new_data = imas.util.resample(
+        nbi.unit[0].energy.data,
+        nbi.time,
+        [0.5, 1.5],
+        nbi.ids_properties.homogeneous_time,
+        inplace=False,
+        fill_value="extrapolate",
+    )
+
+    assert old_id != id(new_data)
+    assert np.array_equal(new_data, [1, 3])
+
+
+def test_full_resample_inplace():
+    nbi = IDSFactory().new("nbi")
+    nbi.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    nbi.time = [1, 2, 3]
+    nbi.unit.resize(1)
+    nbi.unit[0].energy.data = 2 * nbi.time
+    old_id = id(nbi.unit[0].energy.data)
+
+    assert nbi.unit[0].energy.data.coordinates.time_index == 0
+
+    _ = imas.util.resample(
+        nbi,
+        nbi.time,
+        [0.5, 1.5],
+        nbi.ids_properties.homogeneous_time,
+        inplace=True,
+        fill_value="extrapolate",
+    )
+
+    assert old_id == id(nbi.unit[0].energy.data)
+    assert np.array_equal(nbi.unit[0].energy.data, [1, 3])
+    assert np.array_equal(nbi.time, [0.5, 1.5])
+
+
+def test_full_resample_copy():
+    nbi = IDSFactory().new("nbi")
+    nbi.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    nbi.time = [1, 2, 3]
+    nbi.unit.resize(1)
+    nbi.unit[0].energy.data = 2 * nbi.time
+    old_id = id(nbi.unit[0].energy.data)
+
+    assert nbi.unit[0].energy.data.coordinates.time_index == 0
+
+    new_nbi = imas.util.resample(
+        nbi,
+        nbi.time,
+        [0.5, 1.5],
+        nbi.ids_properties.homogeneous_time,
+        inplace=False,
+        fill_value="extrapolate",
+    )
+
+    assert old_id != id(new_nbi.unit[0].energy.data)
+    assert np.array_equal(new_nbi.unit[0].energy.data, [1, 3])
+    assert np.array_equal(new_nbi.time, [0.5, 1.5])

imas/test/test_lazy_loading.py

@@ -0,0 +1,201 @@
+import random
+from unittest.mock import DEFAULT, patch
+
+import numpy
+import pytest
+
+from imas.backends.imas_core.imas_interface import ll_interface
+from imas.db_entry import DBEntry
+from imas.ids_defs import (
+    ASCII_BACKEND,
+    IDS_TIME_MODE_HETEROGENEOUS,
+    IDS_TIME_MODE_HOMOGENEOUS,
+    MEMORY_BACKEND,
+    PREVIOUS_INTERP,
+)
+from imas.ids_factory import IDSFactory
+from imas.ids_primitive import IDSPrimitive
+from imas.test.test_helpers import compare_children, fill_consistent, open_dbentry
+
+
+def test_lazy_load_aos(backend, worker_id, tmp_path, log_lowlevel_calls):
+    if backend == ASCII_BACKEND:
+        pytest.skip("Lazy loading is not supported by the ASCII backend.")
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path, dd_version="3.39.0")
+    ids = dbentry.factory.new("core_profiles")
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    ids.profiles_1d.resize(10)
+    for i in range(10):
+        ids.profiles_1d[i].time = i
+    dbentry.put(ids)
+
+    # Test a random access pattern of the AOS elements
+    lazy_ids = dbentry.get("core_profiles", lazy=True)
+    random_list = list(range(10))
+    random.shuffle(random_list)
+    for i in random_list:
+        assert lazy_ids.profiles_1d[i].time == i
+    # Now all profiles_1d/time are loaded, check that we use loaded values and do not
+    # read data from the lowlevel
+    to_patch = {"read_data": DEFAULT, "begin_arraystruct_action": DEFAULT}
+    with patch.multiple(ll_interface, **to_patch) as values:
+        assert len(lazy_ids.profiles_1d) == 10
+        for i in range(10):
+            assert lazy_ids.profiles_1d[i].time == i
+        for method in to_patch:
+            assert values[method].call_count == 0
+
+    # Test get_slice
+    lazy_ids_slice = dbentry.get_slice("core_profiles", 3.5, PREVIOUS_INTERP, lazy=True)
+    assert lazy_ids_slice.profiles_1d.shape == (1,)
+    assert lazy_ids_slice.profiles_1d[0].time == 3
+
+    dbentry.close()
+
+
+def test_lazy_loading_distributions_random(backend, worker_id, tmp_path):
+    if backend == ASCII_BACKEND:
+        pytest.skip("Lazy loading is not supported by the ASCII backend.")
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    ids = IDSFactory().new("distributions")
+    fill_consistent(ids)
+    dbentry.put(ids)
+
+    def iterate(structure):
+        for child in structure:
+            if not isinstance(child, IDSPrimitive):
+                iterate(child)
+
+    lazy_ids = dbentry.get("distributions", lazy=True)
+    # Iterate over whole IDS to force-load everything
+    iterate(lazy_ids)
+    compare_children(ids, lazy_ids, accept_lazy=True)
+
+    dbentry.close()
+
+
+def test_lazy_load_close_dbentry(requires_imas):
+    dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1)
+    dbentry.create()
+
+    ids = dbentry.factory.core_profiles()
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    dbentry.put(ids)
+
+    lazy_ids = dbentry.get("core_profiles", lazy=True)
+    dbentry.close()
+
+    with pytest.raises(RuntimeError):
+        print(lazy_ids.time)
+
+
+def test_lazy_load_readonly(requires_imas):
+    dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1)
+    dbentry.create()
+
+    ids = dbentry.factory.core_profiles()
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    ids.time = [1, 2]
+    dbentry.put(ids)
+
+    lazy_ids = dbentry.get("core_profiles", lazy=True)
+    assert lazy_ids._lazy is True
+
+    # AoS modifiers
+    with pytest.raises(ValueError):
+        lazy_ids.profiles_1d.resize(1)
+    with pytest.raises(ValueError):
+        lazy_ids.profiles_1d.append(lazy_ids.profiles_1d._element_structure)
+    with pytest.raises(ValueError):
+        lazy_ids.profiles_1d[0] = None
+
+    # Set IDSPrimitive
+    with pytest.raises(ValueError):
+        lazy_ids.ids_properties.homogeneous_time = 1
+    with pytest.raises(ValueError):
+        lazy_ids.time = [1, 2]
+    # Modify numpy arrays
+    with pytest.raises(ValueError):
+        lazy_ids.time.resize(3)
+    with pytest.raises(ValueError):
+        lazy_ids.time.value[0] = 10
+
+    dbentry.close()
+
+
+def test_lazy_load_no_put(requires_imas):
+    dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1)
+    dbentry.create()
+
+    ids = dbentry.factory.core_profiles()
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    dbentry.put(ids)
+
+    lazy_ids = dbentry.get("core_profiles", lazy=True)
+
+    with pytest.raises(ValueError):
+        dbentry.put(lazy_ids)
+    with pytest.raises(ValueError):
+        dbentry.put_slice(lazy_ids)
+
+    dbentry.close()
+
+
+def test_lazy_load_with_new_aos(requires_imas):
+    dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1, dd_version="3.30.0")
+    dbentry.create()
+    et = dbentry.factory.edge_transport()
+
+    et.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    et.time = [1.0]
+    et.model.resize(1)
+    et.model[0].ggd.resize(1)
+    et.model[0].ggd[0].electrons.particles.d.resize(1)
+    et.model[0].ggd[0].electrons.particles.d[0].grid_index = -1
+    dbentry.put(et)
+
+    entry2 = DBEntry(MEMORY_BACKEND, "ITER", 1, 1, dd_version="3.39.0")
+    entry2.open()
+    lazy_et = entry2.get("edge_transport", lazy=True)
+    assert numpy.array_equal(lazy_et.time, [1.0])
+    assert lazy_et.model[0].ggd[0].electrons.particles.d[0].grid_index == -1
+    # d_radial did not exist in 3.30.0
+    assert len(lazy_et.model[0].ggd[0].electrons.particles.d_radial) == 0
+
+    dbentry.close()
+
+
+def test_lazy_load_with_new_structure(requires_imas):
+    dbentry = DBEntry(MEMORY_BACKEND, "ITER", 1, 1, dd_version="3.30.0")
+    dbentry.create()
+
+    eq = dbentry.factory.equilibrium()
+    eq.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    eq.time = [0.0]
+    eq.time_slice.resize(1)
+    dbentry.put(eq)
+
+    entry2 = DBEntry(MEMORY_BACKEND, "ITER", 1, 1, data_version="3", dd_version="4.0.0")
+    entry2.open()
+    lazy_eq = entry2.get("equilibrium", lazy=True)
+    assert not lazy_eq.time_slice[0].boundary.dr_dz_zero_point.r.has_value
+
+
+def test_lazy_load_multiple_ids(backend, worker_id, tmp_path):
+    if backend == ASCII_BACKEND:
+        pytest.skip("Lazy loading is not supported by the ASCII backend.")
+
+    with open_dbentry(backend, "w", worker_id, tmp_path) as dbentry:
+        cp = dbentry.factory.core_profiles()
+        cp.ids_properties.homogeneous_time = 1
+        cp.time = [0.0, 1.0]
+        dbentry.put(cp)
+        eq = dbentry.factory.equilibrium()
+        eq.ids_properties.homogeneous_time = 1
+        eq.time = [1.0, 2.0]
+        dbentry.put(eq)
+
+        lazy_cp = dbentry.get("core_profiles", lazy=True)
+        lazy_eq = dbentry.get("equilibrium", lazy=True)
+        assert all(cp.time - eq.time == -1)
+        assert all(lazy_cp.time - lazy_eq.time == -1)

imas/test/test_list_occurrences.py

@@ -0,0 +1,82 @@
+import pytest
+from packaging.version import Version
+
+import imas
+from imas.backends.imas_core.imas_interface import ll_interface
+from imas.test.test_helpers import open_dbentry
+
+
+@pytest.fixture
+def filled_dbentry(backend, worker_id, tmp_path):
+    if backend == imas.ids_defs.MEMORY_BACKEND:
+        pytest.skip("list_occurrences is not implemented for the MEMORY backend")
+    entry = open_dbentry(backend, "w", worker_id, tmp_path)
+
+    for i in range(3):
+        cp = entry.factory.core_profiles()
+        cp.ids_properties.homogeneous_time = 0
+        cp.ids_properties.comment = f"core_profiles occurrence {i}"
+        entry.put(cp, i)
+
+    for i in [0, 1, 3, 6]:
+        mag = entry.factory.core_sources()
+        mag.ids_properties.homogeneous_time = 0
+        mag.ids_properties.comment = f"core_sources occurrence {i}"
+        entry.put(mag, i)
+
+    yield entry
+    entry.close()
+
+
+def test_list_occurrences_no_path(filled_dbentry):
+    if ll_interface._al_version >= Version("5.1"):
+        occurrences = filled_dbentry.list_all_occurrences("core_profiles")
+        assert occurrences == [0, 1, 2]
+
+        occurrences = filled_dbentry.list_all_occurrences("core_sources")
+        assert occurrences == [0, 1, 3, 6]
+
+        assert filled_dbentry.list_all_occurrences("magnetics") == []
+
+    else:  # AL 5.0 or lower
+        with pytest.raises(RuntimeError):
+            filled_dbentry.list_all_occurrences("core_profiles")
+        with pytest.raises(RuntimeError):
+            filled_dbentry.list_all_occurrences("core_sources")
+        with pytest.raises(RuntimeError):
+            filled_dbentry.list_all_occurrences("magnetics")
+
+
+def test_list_occurrences_with_path(backend, filled_dbentry):
+    if backend == imas.ids_defs.ASCII_BACKEND:
+        pytest.skip("Lazy loading is not supported by the ASCII backend")
+
+    comment = "ids_properties/comment"
+    if ll_interface._al_version >= Version("5.1"):
+        res = filled_dbentry.list_all_occurrences("core_profiles", comment)
+        assert res[0] == [0, 1, 2]
+        assert res[1] == [
+            "core_profiles occurrence 0",
+            "core_profiles occurrence 1",
+            "core_profiles occurrence 2",
+        ]
+
+        res = filled_dbentry.list_all_occurrences("core_sources", comment)
+        assert res[0] == [0, 1, 3, 6]
+        assert res[1] == [
+            "core_sources occurrence 0",
+            "core_sources occurrence 1",
+            "core_sources occurrence 3",
+            "core_sources occurrence 6",
+        ]
+
+        res = filled_dbentry.list_all_occurrences("magnetics", comment)
+        assert res == ([], [])
+
+    else:  # AL 5.0 or lower
+        with pytest.raises(RuntimeError):
+            filled_dbentry.list_all_occurrences("core_profiles", comment)
+        with pytest.raises(RuntimeError):
+            filled_dbentry.list_all_occurrences("core_sources", comment)
+        with pytest.raises(RuntimeError):
+            filled_dbentry.list_all_occurrences("magnetics", comment)

imas/test/test_minimal.py

@@ -0,0 +1,37 @@
+# A minimal testcase loading an IDS file and checking that the structure built is ok
+
+from imas.ids_factory import IDSFactory
+
+
+def test_load_minimal(ids_minimal):
+    minimal = IDSFactory(xml_path=ids_minimal).new("minimal")
+
+    # Check if the datatypes are loaded correctly
+    assert minimal.a.data_type == "FLT_0D"
+    assert minimal.ids_properties.comment.data_type == "STR_0D"
+
+    # Check the documentation
+    assert minimal.a.metadata.documentation == "A float"
+    assert minimal.ids_properties.metadata.documentation == "Properties of this IDS"
+    assert minimal.ids_properties.comment.metadata.documentation == "A string comment"
+
+    # Check the units
+    assert minimal.a.metadata.units == "unitless"
+
+    # Check the static/dynamic/constant annotation
+    assert minimal.a.metadata.type.value == "static"
+    assert minimal.ids_properties.comment.metadata.type.value == "constant"
+
+
+def test_load_multiple_minimal(ids_minimal, ids_minimal_types):
+    minimal = IDSFactory(xml_path=ids_minimal).new("minimal")
+
+    # Check if the datatypes are loaded correctly
+    assert minimal.a.data_type == "FLT_0D"
+    assert minimal.ids_properties.comment.data_type == "STR_0D"
+
+    minimal2 = IDSFactory(xml_path=ids_minimal_types).new("minimal")
+
+    # Check if the datatypes are loaded correctly
+    assert minimal2.flt_0d.data_type == "FLT_0D"
+    assert minimal2.ids_properties.comment.data_type == "STR_0D"

imas/test/test_minimal_conversion.py

@@ -0,0 +1,44 @@
+from imas.ids_defs import IDS_TIME_MODE_INDEPENDENT, MEMORY_BACKEND
+from imas.test.test_helpers import open_dbentry
+
+
+def test_minimal_io_read_flt_int(
+    backend, ids_minimal, ids_minimal2, worker_id, tmp_path
+):
+    """Write and then read again a number on our minimal IDS."""
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path, xml_path=ids_minimal)
+    minimal = dbentry.factory.new("minimal")
+    minimal.a = 2.4
+    minimal.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry.put(minimal)
+    assert minimal.a.value == 2.4
+
+    # ids_minimal2 changed a float to an int
+    dbentry2 = open_dbentry(backend, "r", worker_id, tmp_path, xml_path=ids_minimal2)
+    minimal2 = dbentry2.get("minimal")
+    assert minimal2.a.value == 2
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()
+
+
+def test_minimal_io_read_int_flt(
+    backend, ids_minimal, ids_minimal2, worker_id, tmp_path
+):
+    """Write and then read again a number on our minimal IDS."""
+    dbentry2 = open_dbentry(backend, "w", worker_id, tmp_path, xml_path=ids_minimal2)
+    minimal2 = dbentry2.factory.new("minimal")
+    minimal2.a = 2
+    minimal2.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry2.put(minimal2)
+    assert minimal2.a.value == 2
+
+    # ids_minimal2 changed a float to an int
+    dbentry = open_dbentry(backend, "r", worker_id, tmp_path, xml_path=ids_minimal)
+    minimal = dbentry.get("minimal")
+    assert minimal.a.value == 2.0
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()

imas/test/test_minimal_io.py

@@ -0,0 +1,21 @@
+# A minimal testcase loading an IDS file and checking that the structure built is ok
+from imas.ids_defs import IDS_TIME_MODE_INDEPENDENT, MEMORY_BACKEND
+from imas.test.test_helpers import open_dbentry
+
+
+def test_minimal_io(backend, ids_minimal, worker_id, tmp_path):
+    """Write and then read again a number on our minimal IDS."""
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path, xml_path=ids_minimal)
+    minimal = dbentry.factory.new("minimal")
+    minimal.a = 2.0
+    minimal.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    dbentry.put(minimal)
+    assert minimal.a.value == 2.0
+
+    dbentry2 = open_dbentry(backend, "a", worker_id, tmp_path, xml_path=ids_minimal)
+    minimal2 = dbentry2.get("minimal")
+    assert minimal2.a.value == 2.0
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()

imas/test/test_minimal_struct_array_io.py

@@ -0,0 +1,60 @@
+# A minimal testcase loading an IDS file and checking that the structure built is ok
+import pytest
+
+from imas.ids_defs import IDS_TIME_MODE_INDEPENDENT, MDSPLUS_BACKEND, MEMORY_BACKEND
+from imas.test.test_helpers import open_dbentry
+
+
+def test_minimal_struct_array_maxoccur(
+    backend, ids_minimal_struct_array, worker_id, tmp_path
+):
+    dbentry = open_dbentry(
+        backend, "w", worker_id, tmp_path, xml_path=ids_minimal_struct_array
+    )
+    minimal_struct_array = dbentry.factory.new("minimal_struct_array")
+    minimal_struct_array.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    # maxoccur is 2, so this should raise an exception with the MDS+ backend
+    minimal_struct_array.struct_array.resize(3)
+
+    if backend == MDSPLUS_BACKEND:
+        with pytest.raises(RuntimeError):
+            dbentry.put(minimal_struct_array)
+    else:
+        dbentry.put(minimal_struct_array)
+
+    dbentry.close()
+
+
+def test_minimal_struct_array_io(
+    backend, ids_minimal_struct_array, worker_id, tmp_path
+):
+    """Write and then read again a number on our minimal IDS."""
+    dbentry = open_dbentry(
+        backend, "w", worker_id, tmp_path, xml_path=ids_minimal_struct_array
+    )
+    minimal_struct_array = dbentry.factory.new("minimal_struct_array")
+    a = minimal_struct_array.struct_array
+    minimal_struct_array.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    a.append(a._element_structure)
+
+    # TODO: these are nested one too deeply in my opinion.
+    # (a struct array contains an array of structures directly,
+    #  without the intermediate one?)
+    a[0].a.flt_0d = 2.0
+    a.append(a._element_structure)
+    a[1].a.flt_0d = 4.0
+
+    dbentry.put(minimal_struct_array)
+    assert a[0].a.flt_0d.value == 2.0
+    assert a[1].a.flt_0d.value == 4.0
+
+    dbentry2 = open_dbentry(
+        backend, "a", worker_id, tmp_path, xml_path=ids_minimal_struct_array
+    )
+    minimal_struct_array2 = dbentry2.get("minimal_struct_array")
+    assert minimal_struct_array2.struct_array[0].a.flt_0d.value == 2.0
+    assert minimal_struct_array2.struct_array[1].a.flt_0d.value == 4.0
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()