imas-python 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

imas/ids_convert.py

@@ -274,16 +274,7 @@ class DDVersionMap:
                         self.version_old,
                     )
                 elif self._check_data_type(old_item, new_item):
-                    # use class helper to register simple renames and
-                    # reciprocal mappings
                     self._add_rename(old_path, new_path)
-                    if old_item.get("data_type") in DDVersionMap.STRUCTURE_TYPES:
-                        # Add entries for common sub-elements
-                        for path in old_paths:
-                            if path.startswith(old_path):
-                                npath = path.replace(old_path, new_path, 1)
-                                if npath in new_path_set:
-                                    self._add_rename(path, npath)
             elif nbc_description == "type_changed":
                 pass  # We will handle this (if possible) in self._check_data_type
             elif nbc_description == "repeat_children_first_point":
@@ -334,28 +325,40 @@ class DDVersionMap:
         # Additional conversion rules for DDv3 to DDv4
         if self.version_old.major == 3 and new_version and new_version.major == 4:
             self._apply_3to4_conversion(old, new)
+            # 3to4 rules may have introduced additional missing items in self.old_to_new
+            self._map_missing(
+                False, old_path_set.difference(new_path_set, self.old_to_new)
+            )
 
-    def _add_rename(self, old_path: str, new_path: str) -> None:
+    def _add_rename(
+        self, old_path: str, new_path: str, reciprocal: bool = True
+    ) -> None:
         """Register a simple rename from old_path -> new_path using the
         path->Element maps stored on the instance (self.old_paths/self.new_paths).
         This will also add the reciprocal mapping when possible.
         """
         old_item = self.old_paths[old_path]
         new_item = self.new_paths[new_path]
-
-        # forward mapping
+        # Forward mapping
         self.old_to_new[old_path] = (
             new_path,
             _get_tbp(new_item, self.new_paths),
             _get_ctxpath(new_path, self.new_paths),
         )
-
-        # reciprocal mapping
-        self.new_to_old[new_path] = (
-            old_path,
-            _get_tbp(old_item, self.old_paths),
-            _get_ctxpath(old_path, self.old_paths),
-        )
+        # Reciprocal mapping
+        if reciprocal:
+            self.new_to_old[new_path] = (
+                old_path,
+                _get_tbp(old_item, self.old_paths),
+                _get_ctxpath(old_path, self.old_paths),
+            )
+        # Apply to descendent nodes as well if the item is a struct or AoS
+        for item in old_item.findall("field"):
+            path = item.get("path")
+            assert path is not None and path.startswith(old_path)
+            npath = path.replace(old_path, new_path, 1)
+            if npath in self.new_paths:
+                self._add_rename(path, npath, reciprocal)
 
     def _apply_3to4_conversion(self, old: Element, new: Element) -> None:
         # Postprocessing for COCOS definition change:
@@ -421,6 +424,13 @@ class DDVersionMap:
                                 to_update[p] = v
                 self.old_to_new.path.update(to_update)
 
+        # Migrate additional obsolescent nodes
+        # TODO: define migrations in a separate variable (as with the sign flips)?
+        if self.ids_name == "magnetics":
+            self._add_rename("bpol_probe", "b_field_pol_probe", reciprocal=False)
+            self._add_rename("method", "ip", reciprocal=False)
+            self.old_to_new.type_change["method"] = _magnetics_method_to_ip
+
         # GH#59: To improve further the conversion of DD3 to DD4, especially the
         # Machine Description part of the IDSs, we would like to add a 3to4 specific
         #  rule to convert any siblings name + identifier (that are not part of an
@@ -431,19 +441,20 @@ class DDVersionMap:
         # Only perform the mapping if the corresponding target fields exist in the
         # new DD and if we don't already have a mapping for the involved paths.
         # use self.old_paths and self.new_paths set in _build_map
-        for p in self.old_paths:
+        for name_path in self.old_paths:
             # look for name children
-            if not p.endswith("/name"):
+            if not name_path.endswith("/name"):
                 continue
-            parent = p.rsplit("/", 1)[0]
-            name_path = f"{parent}/name"
+            parent = name_path.rsplit("/", 1)[0]
             id_path = f"{parent}/identifier"
             index_path = f"{parent}/index"
-            desc_path = f"{parent}/description"
-            new_name_path = name_path
+            # Follow renames of parent structure
+            new_parent = self.old_to_new.path.get(parent) or parent
+            desc_path = f"{new_parent}/description"
+            new_name_path = f"{new_parent}/name"
 
-            # If neither 'name' nor 'identifier' existed in the old DD, skip this parent
-            if name_path not in self.old_paths or id_path not in self.old_paths:
+            # If 'identifier' doesn't exist in the old DD, skip this parent
+            if id_path not in self.old_paths:
                 continue
             # exclude identifier-structure (has index sibling)
             if index_path in self.old_paths:
@@ -454,12 +465,11 @@ class DDVersionMap:
                 continue
 
             # Map DD3 name -> DD4 description
-            if name_path not in self.old_to_new.path:
-                self._add_rename(name_path, desc_path)
-
+            self._add_rename(name_path, desc_path)
+            # GH#114: Also preserve name in DD4 name when identifier is empty
+            self.old_to_new.type_change[name_path] = _name_identifier_3to4
             # Map DD3 identifier -> DD4 name
-            if id_path in self.old_to_new.path:
-                self._add_rename(id_path, new_name_path)
+            self._add_rename(id_path, new_name_path)
 
     def _map_missing(self, is_new: bool, missing_paths: Set[str]):
         rename_map = self.new_to_old if is_new else self.old_to_new
@@ -1154,6 +1164,19 @@ def _circuit_connections_4to3(node: IDSPrimitive) -> None:
     node.value = new_value
 
 
+def _name_identifier_3to4(source_name: IDSBase, target_description: IDSBase) -> None:
+    """Preserve name when identifier is empty, see GH#114."""
+    # Always copy DD3 name -> DD4 description
+    target_description.value = source_name.value
+
+    # When DD3 identifier is empty, also preserve name in DD4 name
+    source_parent = source_name._parent
+    source_identifier = getattr(source_parent, "identifier", None)
+    if source_identifier is None or not source_identifier.value:
+        target_parent = target_description._parent
+        target_parent.name = source_name.value
+
+
 def _ids_properties_source(source: IDSString0D, provenance: IDSStructure) -> None:
     """Handle DD3to4 migration of ids_properties/source to ids_properties/provenance."""
     if len(provenance.node) > 0:
@@ -1314,3 +1337,14 @@ def _equilibrium_boundary_3to4(eq3: IDSToplevel, eq4: IDSToplevel, deepcopy: boo
             node[2].psi = -ts3.boundary_secondary_separatrix.psi  # COCOS change
             node[2].levelset.r = copy(ts3.boundary_secondary_separatrix.outline.r)
             node[2].levelset.z = copy(ts3.boundary_secondary_separatrix.outline.z)
+
+
+def _magnetics_method_to_ip(method: IDSBase, ip: IDSBase) -> None:
+    """Convert obsolescent method(:) to ip(:) in the magnetics IDS."""
+    if not len(method):
+        return
+    ip.resize(len(method))
+    for old_item, new_item in zip(method, ip, strict=True):
+        new_item.method_name.value = old_item.name.value
+        new_item.data.value = old_item.ip.data.value
+        new_item.time.value = old_item.ip.time.value

imas/ids_coordinates.py

@@ -81,7 +81,7 @@ class IDSCoordinate:
                     logger.debug(
                         f"Ignoring invalid coordinate specifier {spec}", exc_info=True
                     )
-        self.references: "tuple[IDSPath]" = tuple(refs)
+        self.references: "tuple[IDSPath, ...]" = tuple(refs)
         """A tuple paths that this coordinate refers to.
         """
 
@@ -357,7 +357,6 @@ class IDSCoordinates:
         IDSPath.goto().
         """
         did_capture = []
-        path = self._node._path
         try:
             yield did_capture
         except CoordinateLookupError as exc:
@@ -365,6 +364,7 @@ class IDSCoordinates:
         except IndexError as exc:
             # Can happen in IDSPath.goto when an invalid index is encountered.
             coordinate_refs = coordinate.format_refs(self._node)
+            path = self._node._path
             raise ValidationError(
                 f"Error while validating element `{path}`: dimension {dim + 1} has an "
                 f"invalid index for coordinate(s) {coordinate_refs}."
@@ -372,13 +372,14 @@ class IDSCoordinates:
         except Exception as exc:
             # Ignore all other exceptions and log them
             if "Unexpected index" in str(exc):
-                logger.debug(
-                    "Ignored AoS coordinate outside our tree (see IMAS-4675) of "
-                    "element `%s`, dimension %s, coordinate `%s`",
-                    path,
-                    dim,
-                    coordinate.references,
-                )
+                if logger.isEnabledFor(logging.DEBUG):
+                    logger.debug(
+                        "Ignored AoS coordinate outside our tree (see IMAS-4675) "
+                        "of element `%s`, dimension %s, coordinate `%s`",
+                        self._node._path,
+                        dim,
+                        coordinate.references,
+                    )
             else:
                 if self._node._version <= "3.38.1":
                     version_error = (
@@ -395,7 +396,7 @@ class IDSCoordinates:
                     coordinate.references,
                     dim,
                     version_error,
-                    exc_info=1,
+                    exc_info=True,
                 )
             # Flag to the caller that an error was suppressed
             did_capture.append(1)

imas/ids_identifiers.py

@@ -4,7 +4,7 @@
 
 import logging
 from enum import Enum
-from typing import Iterable, List, Type
+from typing import Iterable, List, Type, Optional
 from xml.etree.ElementTree import fromstring
 
 from imas import dd_zip
@@ -15,19 +15,29 @@ logger = logging.getLogger(__name__)
 class IDSIdentifier(Enum):
     """Base class for all identifier enums."""
 
-    def __new__(cls, value: int, description: str, aliases: list = []):
+    name: str
+    """Name of this identifier value."""
+    index: int
+    """Unique index for this identifier value."""
+    description: str
+    """Description for this identifier value."""
+    aliases: list[str]
+    """Alternative names for this identifier value."""
+    units: Optional[str]
+    """Units of the quantity/quantities altered by this identifier. May be ``None`` if
+    the Data Dictionary doesn't provide this metadata."""
+
+    def __new__(
+        cls, value: int, description: str, aliases: list[str], units: Optional[str]
+    ):
         obj = object.__new__(cls)
         obj._value_ = value
+        obj.index = value
+        obj.description = description
+        obj.aliases = aliases
+        obj.units = units
         return obj
 
-    def __init__(self, value: int, description: str, aliases: list = []) -> None:
-        self.index = value
-        """Unique index for this identifier value."""
-        self.description = description
-        """Description for this identifier value."""
-        self.aliases = aliases
-        """Alternative names for this identifier value."""
-
     def __eq__(self, other):
         if self is other:
             return True
@@ -68,19 +78,22 @@ class IDSIdentifier(Enum):
     def _from_xml(cls, identifier_name, xml) -> Type["IDSIdentifier"]:
         element = fromstring(xml)
         enum_values = {}
-        aliases = {}
         for int_element in element.iterfind("int"):
             name = int_element.get("name")
             value = int_element.text
+            assert value is not None
             description = int_element.get("description")
             # alias attribute may contain multiple comma-separated aliases
             alias_attr = int_element.get("alias", "")
             aliases = [a.strip() for a in alias_attr.split(",") if a.strip()]
-            # Canonical entry: use the canonical 'name' as key
-            enum_values[name] = (int(value), description, aliases)
-            # Also add alias names as enum *aliases* (they become enum attributes)
+            units = int_element.get("units")
+
+            # Identifier can be looked up by its name or any of its aliases:
+            enumvalue = (int(value), description, aliases, units)
+            enum_values[name] = enumvalue
             for alias in aliases:
-                enum_values[alias] = (int(value), description, aliases)
+                enum_values[alias] = enumvalue
+
         # Create the enumeration
         enum = cls(
             identifier_name,

imas/ids_primitive.py

@@ -334,7 +334,7 @@ class IDSNumeric0D(IDSPrimitive):
     __doc__ = IDSDoc(__doc__)
     __slots__ = ()
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=None):
         return np.array(self.value, dtype=dtype)
 
     def __str__(self):
@@ -437,8 +437,8 @@ class IDSNumericArray(IDSPrimitive, np.lib.mixins.NDArrayOperatorsMixin):
     # list, to support operations like np.add(array_like, list)
     _HANDLED_TYPES = (np.ndarray, Number)
 
-    def __array__(self, dtype=None):
-        return self.value.astype(dtype, copy=False)
+    def __array__(self, dtype=None, copy=None):
+        return self.value.astype(dtype, copy=bool(copy))
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         out = kwargs.get("out", ())

imas/ids_structure.py

@@ -57,7 +57,7 @@ class IDSStructure(IDSBase):
     def __getattr__(self, name):
         if name not in self._children:
             raise AttributeError(
-                f"IDS structure '{self._path}' has no attribute '{name}'"
+                f"IDS structure '{self.metadata.path_string}' has no attribute '{name}'"
             )
         # Create child node
         child_meta = self._children[name]

imas/test/test_convert_core_edge_plasma.py

@@ -12,7 +12,7 @@ def assert_equal(core_edge, plasma):
 
 
 def test_convert_training_core_profiles():
-    with imas.training.get_training_db_entry() as entry:
+    with imas.training.get_training_db_entry(convert=True) as entry:
         cp = entry.get("core_profiles")
 
     pp = imas.convert_to_plasma_profiles(cp)

imas/test/test_hash.py

@@ -27,7 +27,7 @@ def test_hash_str1d(minimal):
         "multiple entries to test!",
     ]
     minimal.str_1d = string_list
-    hashes = list(map(xxh3_64_digest, string_list))
+    hashes = [xxh3_64_digest(s.encode("utf-8")) for s in string_list]
     expected = xxh3_64_digest(struct.pack("<Q", len(string_list)) + b"".join(hashes))
     assert expected == b"\x98\x011\x9dx+\x0e\xc0"
     assert imas.util.calc_hash(minimal.str_1d) == expected

imas/test/test_identifiers.py

@@ -6,11 +6,9 @@ from imas.dd_zip import dd_identifiers
 from imas.ids_factory import IDSFactory
 from imas.ids_identifiers import IDSIdentifier, identifiers
 
-has_aliases = Version(importlib.metadata.version("imas_data_dictionaries")) >= Version(
-    "4.1.0"
-)
-requires_aliases = pytest.mark.skipif(
-    not has_aliases, reason="Requires DD 4.1.0 for identifier aliases"
+requires_dd4_1 = pytest.mark.skipif(
+    Version(importlib.metadata.version("imas_data_dictionaries")) < Version("4.1.0"),
+    reason="Test requires DD 4.1.0 for additional identifier metadata",
 )
 
 
@@ -112,7 +110,7 @@ Materials used in the device mechanical structures
     assert identifier.CxHy.aliases == ["alias1", "alias2", "3alias"]
 
 
-@requires_aliases
+@requires_dd4_1
 def test_identifier_struct_assignment_with_aliases():
     """Test identifier struct assignment with aliases using materials_identifier."""
     mid = identifiers.materials_identifier
@@ -174,7 +172,7 @@ def test_invalid_identifier_assignment():
         cs.source[0].identifier = -1
 
 
-@requires_aliases
+@requires_dd4_1
 def test_identifier_aliases():
     """Test identifier enum aliases functionality."""
     mid = identifiers.materials_identifier
@@ -197,7 +195,7 @@ def test_identifier_aliases():
         assert mid[alias] is mid.U_235
 
 
-@requires_aliases
+@requires_dd4_1
 def test_identifier_alias_equality():
     """Test that identifiers with aliases are equal when comparing names and aliases."""
     mid = identifiers.materials_identifier
@@ -276,7 +274,7 @@ def test_identifier_alias_equality():
     assert mat5.descriptions[2] == mid["U_235"].description
 
 
-@requires_aliases
+@requires_dd4_1
 def test_identifier_alias_equality_non_ggd():
     """Test identifier aliases functionality on non-ggd material"""
     mid = identifiers.materials_identifier
@@ -293,3 +291,14 @@ def test_identifier_alias_equality_non_ggd():
     summary_ids.wall.material.name = "235U"  # Use canonical name
     assert summary_ids.wall.material == mid["235U"]
     assert summary_ids.wall.material == mid["U_235"]
+
+
+@requires_dd4_1
+def test_identifier_units():
+    ppcid = identifiers.poloidal_plane_coordinates_identifier
+    assert ppcid.rectangular.units == "m,m"
+    assert ppcid.inverse.units == "m,rad"
+
+    # materials identifier doesn't have units (and I don't expect they'll ever get any)
+    mid = identifiers.materials_identifier
+    assert mid.W.units is None

imas/test/test_ids_convert.py

@@ -439,6 +439,55 @@ def test_3to4_cocos_magnetics_workaround(dd4factory):
     compare_children(mag, mag3)
 
 
+def test_3to4_deprecated_magnetics(dd4factory):
+    # Test migrating deprecated bpol_probe
+    mag = IDSFactory("3.39.0").magnetics()
+    mag.bpol_probe.resize(2)
+    mag.bpol_probe[0].name = "name1"
+    mag.bpol_probe[0].identifier = "identifier1"
+    mag.bpol_probe[0].position.r = 1
+    mag.bpol_probe[0].field.data = [0.1, 0.2, 0.3]
+    mag.bpol_probe[1].name = "name2"
+    mag.bpol_probe[1].voltage.data = [0.1, 0.2, 0.3]
+
+    mag.method.resize(2)
+    for i, method in enumerate(mag.method):
+        method.name = f"name{i}"
+        method.ip.data = [i, 1.0, 2.0]
+        method.ip.time = [i + 1, 2.0, 3.0]
+
+    mag4 = convert_ids(mag, None, factory=dd4factory)
+    assert len(mag4.b_field_pol_probe) == 2
+    assert mag4.b_field_pol_probe[0].name == "identifier1"
+    assert mag4.b_field_pol_probe[0].description == "name1"
+    assert mag4.b_field_pol_probe[0].position.r == 1
+    assert array_equal(mag4.b_field_pol_probe[0].field.data, [0.1, 0.2, 0.3])
+    assert mag4.b_field_pol_probe[1].name == "name2"
+    assert mag4.b_field_pol_probe[1].description == "name2"
+    assert array_equal(mag4.b_field_pol_probe[1].voltage.data, [0.1, 0.2, 0.3])
+
+    assert len(mag4.ip) == 2
+    assert mag4.ip[0].method_name == "name0"
+    assert array_equal(mag4.ip[0].data, [0.0, 1.0, 2.0])
+    assert array_equal(mag4.ip[0].time, [1.0, 2.0, 3.0])
+    assert mag4.ip[1].method_name == "name1"
+    assert array_equal(mag4.ip[1].data, [1.0, 1.0, 2.0])
+    assert array_equal(mag4.ip[1].time, [2.0, 2.0, 3.0])
+
+    # If both the deprecated and the "correct" quantity exist, we expect only the
+    # correct one to be converted to DD4:
+    mag.b_field_pol_probe.resize(1)
+    mag.b_field_pol_probe[0].name = "test"
+    mag.ip.resize(1)
+    mag.ip[0].method_name = "ip"
+
+    mag4 = convert_ids(mag, None, factory=dd4factory)
+    assert len(mag4.b_field_pol_probe) == 1
+    assert mag4.b_field_pol_probe[0].name == "test"
+    assert len(mag4.ip) == 1
+    assert mag4.ip[0].method_name == "ip"
+
+
 def test_3to4_pulse_schedule():
     ps = IDSFactory("3.39.0").pulse_schedule()
     ps.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
@@ -575,6 +624,29 @@ def test_4to3_name_identifier_mapping_magnetics():
     assert dst.b_field_pol_probe[0].identifier == "TEST_NAME"
 
 
+def test_3to4_name_identifier_empty_identifier():
+    """GH#114: name must be preserved when identifier is empty."""
+    factory = IDSFactory("3.40.1")
+
+    src = factory.pf_active()
+    src.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    src.coil.resize(2)
+    # Case 1: name populated, identifier empty
+    src.coil[0].name = "TEST_NAME"
+    src.coil[0].identifier = ""
+    # Case 2: name populated, identifier not set at all
+    src.coil[1].name = "TEST_NAME2"
+
+    dst = convert_ids(src, "4.0.0")
+
+    # name must be preserved in DD4 name (not overwritten by empty identifier)
+    assert dst.coil[0].name == "TEST_NAME"
+    assert dst.coil[0].description == "TEST_NAME"
+
+    assert dst.coil[1].name == "TEST_NAME2"
+    assert dst.coil[1].description == "TEST_NAME2"
+
+
 def test_3to4_cocos_hardcoded_paths():
     # Check for existence in 3.42.0
     factory = IDSFactory("3.42.0")

imas/test/test_list_filled_paths.py

@@ -0,0 +1,101 @@
+import pytest
+
+import imas
+from imas_core import _al_lowlevel
+from imas.exception import DataEntryException
+from imas.ids_defs import IDS_TIME_MODE_HOMOGENEOUS, IDS_TIME_MODE_INDEPENDENT
+
+
+if not hasattr(_al_lowlevel, "al_list_filled_paths"):
+    marker = pytest.mark.xfail(reason="list_filled_paths not available in imas_core")
+else:
+    marker = []
+
+
+@pytest.fixture(params=["netcdf", pytest.param("hdf5", marks=marker)])
+def testuri(request, tmp_path):
+    if request.param == "netcdf":
+        return str(tmp_path / "list_filled_paths.nc")
+    return f"imas:{request.param}?path={tmp_path}/list_filled_paths_{request.param}"
+
+
+def test_list_filled_paths(testuri):
+    with imas.DBEntry(testuri, "w", dd_version="4.0.0") as dbentry:
+        # No IDSs in the DBEntry yet, expect an exception
+        with pytest.raises(DataEntryException):
+            dbentry.list_filled_paths("core_profiles")
+
+        cp = dbentry.factory.core_profiles()
+        cp.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+        cp.ids_properties.comment = "comment"
+        cp.time = [0.1, 0.2]
+        cp.profiles_1d.resize(2)
+        cp.profiles_1d[0].grid.rho_tor_norm = [1.0, 2.0]
+        cp.profiles_1d[0].ion.resize(2)
+        cp.profiles_1d[0].ion[1].temperature = [1.0, 2.0]
+        cp.profiles_1d[1].grid.psi = [1.0, 2.0]
+        cp.profiles_1d[1].q = [1.0, 2.0]
+        cp.profiles_1d[1].e_field.radial = [1.0, 2.0]
+        cp.profiles_1d[1].neutral.resize(2)
+        cp.global_quantities.ip = [1.0, 2.0]
+
+        dbentry.put(cp)
+
+        filled_paths = dbentry.list_filled_paths("core_profiles")
+        assert isinstance(filled_paths, list)
+        assert set(filled_paths) == {
+            "ids_properties/version_put/access_layer",
+            "ids_properties/version_put/access_layer_language",
+            "ids_properties/version_put/data_dictionary",
+            "ids_properties/homogeneous_time",
+            "ids_properties/comment",
+            "time",
+            "profiles_1d/grid/rho_tor_norm",
+            "profiles_1d/ion/temperature",
+            "profiles_1d/grid/psi",
+            "profiles_1d/q",
+            "profiles_1d/e_field/radial",
+            "profiles_1d/e_field/radial",
+            "global_quantities/ip",
+        }
+        # Other occurrence should still raise an error:
+        with pytest.raises(DataEntryException):
+            dbentry.list_filled_paths("core_profiles", 1)
+        # Until we write data to the occurrence:
+        dbentry.put(cp, 3)
+        assert set(filled_paths) == set(dbentry.list_filled_paths("core_profiles", 3))
+
+
+def test_list_filled_paths_autoconvert(testuri):
+    with imas.DBEntry(testuri, "w", dd_version="3.25.0") as entry:
+        ps = entry.factory.pulse_schedule()
+        ps.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+        ps.ec.antenna.resize(1)
+        ps.ec.antenna[0].launching_angle_pol.reference_name = "test"
+        entry.put(ps)
+
+        filled_paths = entry.list_filled_paths("pulse_schedule")
+        assert set(filled_paths) == {
+            "ids_properties/version_put/access_layer",
+            "ids_properties/version_put/access_layer_language",
+            "ids_properties/version_put/data_dictionary",
+            "ids_properties/homogeneous_time",
+            "ec/antenna/launching_angle_pol/reference_name",
+        }
+
+    # Check autoconvert with DD 3.28.0
+    with imas.DBEntry(testuri, "r", dd_version="3.28.0") as entry:
+        assert set(entry.list_filled_paths("pulse_schedule", autoconvert=False)) == {
+            "ids_properties/version_put/access_layer",
+            "ids_properties/version_put/access_layer_language",
+            "ids_properties/version_put/data_dictionary",
+            "ids_properties/homogeneous_time",
+            "ec/antenna/launching_angle_pol/reference_name",  # original name
+        }
+        assert set(entry.list_filled_paths("pulse_schedule")) == {
+            "ids_properties/version_put/access_layer",
+            "ids_properties/version_put/access_layer_language",
+            "ids_properties/version_put/data_dictionary",
+            "ids_properties/homogeneous_time",
+            "ec/launcher/steering_angle_pol/reference_name",  # autoconverted name
+        }

imas/test/test_to_xarray.py

@@ -1,11 +1,13 @@
 import numpy as np
+import netCDF4
 import pytest
 
 import imas
 import imas.training
+from imas.test.test_helpers import compare_children
 from imas.util import to_xarray
 
-pytest.importorskip("xarray")
+xarray = pytest.importorskip("xarray")
 
 
 @pytest.fixture
@@ -87,8 +89,29 @@ def test_to_xarray():
     ids.profiles_1d[0].time = 0.0
 
     # These should all be identical:
-    ds1 = to_xarray(ids)
+    ds1 = to_xarray(ids).drop_vars(
+        ["profiles_1d", "profiles_1d.electrons", "profiles_1d.grid"]
+    )
     ds2 = to_xarray(ids, "profiles_1d.electrons.temperature")
     ds3 = to_xarray(ids, "profiles_1d/electrons/temperature")
     assert ds1.equals(ds2)
     assert ds2.equals(ds3)
+
+
+@pytest.mark.parametrize("idsname", ["core_profiles", "equilibrium"])
+def test_roundtrip_xarray_netcdf(tmp_path, entry, idsname):
+    ids = entry.get(idsname)
+    xrds = to_xarray(ids)
+    fname = f"{tmp_path}/test-{idsname}-xarray.nc"
+    # First write mandatory file-level metadata
+    with netCDF4.Dataset(fname, "x") as ds:
+        ds.data_dictionary_version = imas.util.get_data_dictionary_version(ids)
+    # Then use xarray to write the IDS
+    xrds.to_netcdf(fname, "a", format="NETCDF4", group=f"{idsname}/0")
+    # And read it back with a DBEntry
+    with imas.DBEntry(fname, "r") as entry:
+        ids2 = entry.get(idsname)
+    compare_children(ids, ids2)
+    # Reading the netCDF file with xarray should produce an identical dataset
+    ncxrds = xarray.load_dataset(fname, group=f"{idsname}/0")
+    assert xrds.equals(ncxrds)