imas-python 2.0.1__tar.gz → 2.1.0__tar.gz

{imas_python-2.0.1 → imas_python-2.1.0}/.github/workflows/test_with_pytest.yml

@@ -7,10 +7,10 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]  # Test on multiple Python versions
+        python-version: ["3.10", "3.11", "3.12", "3.13"]  # Test on multiple Python versions
     
     steps:
       - name: Checkout repository
@@ -20,8 +20,6 @@ jobs:
 
         uses: actions/setup-python@v4
         with:
-          # until saxonche is available in 3.13
-          # https://saxonica.plan.io/issues/6561
           python-version: ${{ matrix.python-version }}
       - name: Display Python version
         run: python -c "import sys; print(sys.version)"

{imas_python-2.0.1 → imas_python-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imas-python
-Version: 2.0.1
+Version: 2.1.0
 Summary: Pythonic wrappers for the IMAS Access Layer
 Author: ITER Organization
 Author-email: Karel Lucas van de Plassche <karelvandeplassche@gmail.com>, Daan van Vugt <dvanvugt@ignitioncomputing.com>, Maarten Sebregts <msebregts@ignitioncomputing.com>, imas-support@iter.org
@@ -213,6 +213,7 @@ Requires-Dist: importlib_resources; python_version < "3.9"
 Requires-Dist: packaging
 Requires-Dist: xxhash>=2
 Requires-Dist: imas_data_dictionaries
+Requires-Dist: imas_core
 Provides-Extra: all
 Requires-Dist: imas-python[docs,test]; extra == "all"
 Provides-Extra: docs

{imas_python-2.0.1 → imas_python-2.1.0}/benchmarks/core_profiles.py

@@ -10,8 +10,6 @@ from .utils import (
     available_serializers,
     available_slicing_backends,
     create_dbentry,
-    factory,
-    hlis,
 )
 
 N_SLICES = 32
@@ -26,13 +24,13 @@ def fill_slices(core_profiles, times):
         times: time values to fill a slice for
     """
     core_profiles.ids_properties.homogeneous_time = 1  # HOMOGENEOUS
-    core_profiles.ids_properties.comment = "Generated for the IMAS-Python benchmark suite"
+    core_profiles.ids_properties.comment = (
+        "Generated for the IMAS-Python benchmark suite"
+    )
     core_profiles.ids_properties.creation_date = datetime.date.today().isoformat()
     core_profiles.code.name = "IMAS-Python ASV benchmark"
     core_profiles.code.version = imas.__version__
-    core_profiles.code.repository = (
-        "https://github.com/iterorganization/IMAS-Python"
-    )
+    core_profiles.code.repository = "https://github.com/iterorganization/IMAS-Python"
 
     core_profiles.time = np.array(times)
     core_profiles.profiles_1d.resize(len(times))
@@ -50,13 +48,13 @@ def fill_slices(core_profiles, times):
         profiles_1d.ion.resize(len(ions))
         profiles_1d.neutral.resize(len(ions))
         for i, ion in enumerate(ions):
-            if hasattr(profiles_1d.ion[i], 'label'):
+            if hasattr(profiles_1d.ion[i], "label"):
                 profiles_1d.ion[i].label = ion
                 profiles_1d.neutral[i].label = ion
-            if hasattr(profiles_1d.ion[i], 'name'):
+            if hasattr(profiles_1d.ion[i], "name"):
                 profiles_1d.ion[i].name = ion
                 profiles_1d.neutral[i].name = ion
-            
+
             # profiles_1d.ion[i].label = profiles_1d.neutral[i].label = ion
             profiles_1d.ion[i].z_ion = 1.0
             profiles_1d.ion[i].neutral_index = profiles_1d.neutral[i].ion_index = i + 1
@@ -70,31 +68,31 @@ def fill_slices(core_profiles, times):
 
 
 class GetSlice:
-    params = [hlis, available_slicing_backends]
-    param_names = ["hli", "backend"]
+    params = [available_slicing_backends]
+    param_names = ["backend"]
 
-    def setup(self, hli, backend):
-        self.dbentry = create_dbentry(hli, backend)
-        core_profiles = factory[hli].core_profiles()
+    def setup(self, backend):
+        self.dbentry = create_dbentry(backend)
+        core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(core_profiles, TIME)
         self.dbentry.put(core_profiles)
 
-    def time_get_slice(self, hli, backend):
+    def time_get_slice(self, backend):
         for t in TIME:
             self.dbentry.get_slice("core_profiles", t, imas.ids_defs.CLOSEST_INTERP)
 
-    def teardown(self, hli, backend):
+    def teardown(self, backend):
         if hasattr(self, "dbentry"):  # imas + netCDF has no dbentry
             self.dbentry.close()
 
 
 class Get:
-    params = [hlis, available_backends]
-    param_names = ["hli", "backend"]
+    params = [available_backends]
+    param_names = ["backend"]
     setup = GetSlice.setup
     teardown = GetSlice.teardown
 
-    def time_get(self, hli, backend):
+    def time_get(self, backend):
         self.dbentry.get("core_profiles")
 
 
@@ -103,8 +101,8 @@ class LazyGet:
     param_names = ["lazy", "backend"]
 
     def setup(self, lazy, backend):
-        self.dbentry = create_dbentry("imas", backend)
-        core_profiles = factory["imas"].core_profiles()
+        self.dbentry = create_dbentry(backend)
+        core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(core_profiles, TIME)
         self.dbentry.put(core_profiles)
 
@@ -118,75 +116,72 @@ class LazyGet:
 
 
 class Generate:
-    params = [hlis]
-    param_names = ["hli"]
+    def setup(self):
+        self.core_profiles = imas.IDSFactory().core_profiles()
 
-    def setup(self, hli):
-        self.core_profiles = factory[hli].core_profiles()
-
-    def time_generate(self, hli):
+    def time_generate(self):
         fill_slices(self.core_profiles, TIME)
 
-    def time_generate_slices(self, hli):
+    def time_generate_slices(self):
         for t in TIME:
             fill_slices(self.core_profiles, [t])
 
-    def time_create_core_profiles(self, hli):
-        factory[hli].core_profiles()
+    def time_create_core_profiles(self):
+        imas.IDSFactory().core_profiles()
 
 
 class Put:
-    params = [["0", "1"], hlis, available_backends]
+    params = [["0", "1"], available_backends]
     param_names = ["disable_validate", "hli", "backend"]
 
-    def setup(self, disable_validate, hli, backend):
-        create_dbentry(hli, backend).close()  # catch unsupported combinations
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, disable_validate, backend):
+        create_dbentry(backend).close()  # catch unsupported combinations
+        self.core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(self.core_profiles, TIME)
         os.environ["IMAS_AL_DISABLE_VALIDATE"] = disable_validate
 
-    def time_put(self, disable_validate, hli, backend):
-        with create_dbentry(hli, backend) as dbentry:
+    def time_put(self, disable_validate, backend):
+        with create_dbentry(backend) as dbentry:
             dbentry.put(self.core_profiles)
 
 
 class PutSlice:
-    params = [["0", "1"], hlis, available_slicing_backends]
-    param_names = ["disable_validate", "hli", "backend"]
+    params = [["0", "1"], available_slicing_backends]
+    param_names = ["disable_validate", "backend"]
 
-    def setup(self, disable_validate, hli, backend):
-        create_dbentry(hli, backend).close()  # catch unsupported combinations
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, disable_validate, backend):
+        create_dbentry(backend).close()  # catch unsupported combinations
+        self.core_profiles = imas.IDSFactory().core_profiles()
         os.environ["IMAS_AL_DISABLE_VALIDATE"] = disable_validate
 
-    def time_put_slice(self, disable_validate, hli, backend):
-        with create_dbentry(hli, backend) as dbentry:
+    def time_put_slice(self, disable_validate, backend):
+        with create_dbentry(backend) as dbentry:
             for t in TIME:
                 fill_slices(self.core_profiles, [t])
                 dbentry.put_slice(self.core_profiles)
 
 
 class Serialize:
-    params = [hlis, available_serializers]
-    param_names = ["hli", "serializer"]
+    params = [available_serializers]
+    param_names = ["serializer"]
 
-    def setup(self, hli, serializer):
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, serializer):
+        self.core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(self.core_profiles, TIME)
 
-    def time_serialize(self, hli, serializer):
+    def time_serialize(self, serializer):
         self.core_profiles.serialize(serializer)
 
 
 class Deserialize:
-    params = [hlis, available_serializers]
-    param_names = ["hli", "serializer"]
+    params = [available_serializers]
+    param_names = ["serializer"]
 
-    def setup(self, hli, serializer):
-        self.core_profiles = factory[hli].core_profiles()
+    def setup(self, serializer):
+        self.core_profiles = imas.IDSFactory().core_profiles()
         fill_slices(self.core_profiles, TIME)
         self.data = self.core_profiles.serialize(serializer)
-        self.core_profiles = factory[hli].core_profiles()
+        self.core_profiles = imas.IDSFactory().core_profiles()
 
-    def time_deserialize(self, hli, serializer):
+    def time_deserialize(self, serializer):
         self.core_profiles.deserialize(self.data)

{imas_python-2.0.1 → imas_python-2.1.0}/benchmarks/edge_profiles.py

@@ -5,7 +5,7 @@ import numpy as np
 
 import imas
 
-from .utils import available_backends, create_dbentry, factory, hlis
+from .utils import available_backends, create_dbentry
 
 N_POINTS = 600  # number of random R,Z points
 N_LINES = 1200  # number of random lines in R,Z plane
@@ -27,9 +27,7 @@ def fill_ggd(edge_profiles, times):
     edge_profiles.ids_properties.creation_date = datetime.date.today().isoformat()
     edge_profiles.code.name = "IMAS-Python ASV benchmark"
     edge_profiles.code.version = imas.__version__
-    edge_profiles.code.repository = (
-        "https://github.com/iterorganization/IMAS-Python"
-    )
+    edge_profiles.code.repository = "https://github.com/iterorganization/IMAS-Python"
 
     # This GGD grid is not a valid description, but it's a good stress test for the
     # typical access patterns that exist in GGD grids
@@ -124,45 +122,42 @@ def fill_ggd(edge_profiles, times):
 
 
 class Get:
-    params = [hlis, available_backends]
-    param_names = ["hli", "backend"]
+    params = [available_backends]
+    param_names = ["backend"]
 
-    def setup(self, hli, backend):
-        self.dbentry = create_dbentry(hli, backend)
-        edge_profiles = factory[hli].edge_profiles()
+    def setup(self, backend):
+        self.dbentry = create_dbentry(backend)
+        edge_profiles = imas.IDSFactory().edge_profiles()
         fill_ggd(edge_profiles, TIME)
         self.dbentry.put(edge_profiles)
 
-    def time_get(self, hli, backend):
+    def time_get(self, backend):
         self.dbentry.get("edge_profiles")
 
-    def teardown(self, hli, backend):
+    def teardown(self, backend):
         if hasattr(self, "dbentry"):  # imas + netCDF has no dbentry
             self.dbentry.close()
 
 
 class Generate:
-    params = [hlis]
-    param_names = ["hli"]
-
-    def time_generate(self, hli):
-        edge_profiles = factory[hli].edge_profiles()
+    def time_generate(self):
+        edge_profiles = imas.IDSFactory().edge_profiles()
         fill_ggd(edge_profiles, TIME)
 
-    def time_create_edge_profiles(self, hli):
-        factory[hli].edge_profiles()
+    def time_create_edge_profiles(self):
+        imas.IDSFactory().edge_profiles()
 
 
 class Put:
-    params = [["0", "1"], hlis, available_backends]
-    param_names = ["disable_validate", "hli", "backend"]
+    params = [["0", "1"], available_backends]
+    param_names = ["disable_validate", "backend"]
 
-    def setup(self, disable_validate, hli, backend):
-        create_dbentry(hli, backend).close()  # catch unsupported combinations
-        self.edge_profiles = factory[hli].edge_profiles()
+    def setup(self, disable_validate, backend):
+        create_dbentry(backend).close()  # catch unsupported combinations
+        self.edge_profiles = imas.IDSFactory().edge_profiles()
         fill_ggd(self.edge_profiles, TIME)
         os.environ["IMAS_AL_DISABLE_VALIDATE"] = disable_validate
 
-    def time_put(self, disable_validate, hli, backend):
-        with create_dbentry(hli, backend) as dbentry:
+    def time_put(self, disable_validate, backend):
+        with create_dbentry(backend) as dbentry:
             dbentry.put(self.edge_profiles)

{imas_python-2.0.1 → imas_python-2.1.0}/benchmarks/utils.py

@@ -1,10 +1,10 @@
-import importlib
 import logging
 import uuid
 from pathlib import Path
 
 import imas
 import imas.exception
+import imas.ids_defs
 
 # Backend constants
 HDF5 = "HDF5"
@@ -56,28 +56,12 @@ available_slicing_backends = [
     backend for backend in available_backends if backend not in [ASCII, NETCDF]
 ]
 
-hlis = ["imas"]
-DBEntry = {
-    "imas": imas.DBEntry,
-}
-factory = {
-    "imas": imas.IDSFactory(),
-}
-available_serializers = [imas.ids_defs.ASCII_SERIALIZER_PROTOCOL]
-
+available_serializers = [
+    imas.ids_defs.ASCII_SERIALIZER_PROTOCOL,
+    imas.ids_defs.FLEXBUFFERS_SERIALIZER_PROTOCOL,
+]
 
-def create_dbentry(hli, backend):
-    if backend == NETCDF:
-        if hli == "imas":  # check if netcdf backend is available
-            try:
-                assert (
-                    imas.DBEntry._select_implementation("x.nc").__name__
-                    == "NCDBEntryImpl"
-                )
-            except (AttributeError, AssertionError):
-                raise NotImplementedError(
-                    "This version of IMAS-Python doesn't implement netCDF."
-                ) from None
 
-    path = Path.cwd() / f"DB-{hli}-{backend}"
-    return DBEntry[hli](create_uri(backend, path), "w")
+def create_dbentry(backend):
+    path = Path.cwd() / f"DB-{backend}"
+    return imas.DBEntry(create_uri(backend, path), "w")

{imas_python-2.0.1 → imas_python-2.1.0}/conftest.py

@@ -70,6 +70,13 @@ _BACKENDS = {
     "hdf5": HDF5_BACKEND,
     "mdsplus": MDSPLUS_BACKEND,
 }
+try:
+    from imas.db_entry import DBEntry
+    from imas_core.exception import ImasCoreBackendException
+    DBEntry("imas:mdsplus?path=dummy","r")
+except ImasCoreBackendException as iex:
+    if "not available" in str(iex.message):
+        _BACKENDS.pop("mdsplus")
 
 
 try:

{imas_python-2.0.1 → imas_python-2.1.0}/docs/source/changelog.rst

@@ -3,6 +3,44 @@
 Changelog
 =========
 
+What's new in IMAS-Python 2.1.0
+-------------------------------
+
+Build
+'''''
+
+- update Python version support (remove 3.8, add 3.13)
+- add dependency on `imas_core <https://pypi.org/project/imas-core/>`__
+
+
+Improvements
+''''''''''''
+
+- :issue:`84`: improve `imas process-db-analysis` 
+- :issue:`71`: take into account identifier aliases (introduced in DD 4.1)
+- :issue:`78`: disable *implicit* conversion when crossing a major version update
+- improve integration of UDA backend
+- cleaning old AL4 deprecated code
+- :issue:`59`: convert name+identifier (DD3) into description+name (DD4) 
+- improve type hints (following PEP-585 and PEP-604)
+- improve performance of IDS deepcopy 
+- :issue:`60`: improve `equilibrium` DD3->4 by converting `boundary_separatrix` into `contour_tree`
+- :issue:`22`: add custom conversion example in the doc for `em_coupling` IDS
+
+
+Bug fixes
+'''''''''
+
+- fix testcases with coordinate validation issues
+- :issue:`80`: fix `imas print` when using netcdf and imas_core is not present
+- :issue:`61`: special DD3->4 rule to flip sign quantities missing the `cocos_label_transform attribute` in DD
+- :merge:`58`: fix unclear provenance capture
+- :merge:`57`: fix 0D arrays from lazy loading with netcdf
+- :issue:`55`: handle missing case when converting 3.42->4 (_tor->_phi)
+  
+
+
+
 What's new in IMAS-Python 2.0.1
 -------------------------------
 
@@ -74,9 +112,9 @@ Bug fixes
     Dictionary 4.0.0 and 3.42.0. In other cases, the Data Dictionary version is
     now explicitly indicated.
 
-- :issue:`IMAS-5560`: Fix a bug where IMASPy would not correctly recognize that
+- IMAS-5560: Fix a bug where IMASPy would not correctly recognize that
   the UDA backend is used.
-- :issue:`IMAS-5541`: Fix a bug when converting a closed contour to Data
+- IMAS-5541: Fix a bug when converting a closed contour to Data
   Dictionary version 4.0.0.
 - Work around incorrect Data Dictionary 3.x metadata when converting
   ``flux_loop/flux`` in the ``magnetics`` IDS to Data Dictionary version 4.0.0.

{imas_python-2.0.1 → imas_python-2.1.0}/docs/source/cli.rst

@@ -121,8 +121,8 @@ process these files with ``imas process-db-analysis``. This will:
     variable).
 2.  These results are summarized in a table, showing per IDS:
 
-    - The number of data fields [#data_fields]_ that were filled in *any* of the
-      analyzed data entries.
+    - The number of data fields [#data_fields]_ that were filled in *any* occurrence of
+      the IDS in *any* of the analyzed data entries.
     - The total number of data fields [#data_fields]_ that the Data Dictionary
       defines for this IDS.
     - The percentage of fields filled.

{imas_python-2.0.1 → imas_python-2.1.0}/docs/source/conf.py

@@ -39,12 +39,12 @@ src_host = "https://github.com/iterorganization/"
 iter_projects = "https://github.com/iterorganization/"
 dd_url = urljoin(iter_projects, "imas-data-dictionary/")
 al_url = urljoin(iter_projects, "imas-core/")
-issue_url = jira_url = "https://github.com/iterorganization/IMAS-Python/issues"
 
 # IMAS-Python
 repository_url = f"{iter_projects}/{src_project}/"
 blob_url = repository_url
-mr_url = urljoin(repository_url, "/pulls")
+issue_url = urljoin(repository_url, "issues/")
+mr_url = urljoin(repository_url, "pull/")
 
 
 # Configuration of sphinx.ext.extlinks
@@ -52,8 +52,8 @@ mr_url = urljoin(repository_url, "/pulls")
 # unique name: (base URL, label prefix)
 extlinks = {
     "src": (blob_url + "%s", "%s"),
-    "issue": (issue_url + "%s", "%s"),
-    "merge": (mr_url + "%s", "!%s"),
+    "issue": (issue_url + "%s", "#%s"),
+    "merge": (mr_url + "%s", "#%s"),
     "dd": (dd_url + "%s", "%s"),
     "al": (al_url + "%s", "%s"),
     "pypa": ("https://packaging.python.org/%s", None),

{imas_python-2.0.1 → imas_python-2.1.0}/docs/source/courses/basic/analyze.rst

@@ -25,15 +25,10 @@ can use the data.
 .. hint::
     Use the ASCII data supplied with IMAS-Python for all exercises. It contains two
     IDSs (``equilibrium`` and ``core_profiles``) filled  with data from three
-    time slices of ITER reference data. Two convenience methods are available in the
-    :mod:`imas.training` module to open the DBEntry for this training data.
-
-    1. :meth:`imas.training.get_training_db_entry()` returns an opened
-       ``imas.DBEntry`` object. Use this method if you want to use the IMAS-Python
-       interface.
-    2. :meth:`imas.training.get_training_imas_db_entry()` returns an opened
-       ``imas.DBEntry`` object. Use this method if you want to use the Python Access
-       Layer interface.
+    time slices of ITER reference data. A convenience method is available in the
+    :mod:`imas.training` module to open the DBEntry for this training data:
+    :meth:`imas.training.get_training_db_entry()` returns an opened
+    ``imas.DBEntry`` object.
 
 Exercise 1
 ''''''''''

imas_python-2.1.0/docs/source/examples/custom_conversion_em_coupling.py

@@ -0,0 +1,168 @@
+"""IMAS-Python example for custom conversion logic.
+
+This example script loads a Data Entry (in Data Dictionary 3.38.1) created by
+DINA and converts the em_coupling IDS to DD 4.0.0.
+"""
+
+import imas
+from imas.ids_defs import IDS_TIME_MODE_INDEPENDENT
+
+input_uri = "imas:hdf5?path=/work/imas/shared/imasdb/ITER_SCENARIOS/3/105013/1"
+# An error is reported when there's already data at the output_uri!
+output_uri = "imas:hdf5?path=105013-1-converted"
+target_dd_version = "4.0.0"
+
+
+# Mapping of DD 3.38.1 em_coupling data to DD 4.0.0
+# Map the name of the matrix in DD 3.38.1 to the identifier and coordinate URIs
+COUPLING_MAPS = {
+    "field_probes_active": dict(
+        coupling_quantity=2,
+        rows_uri="#magnetics/b_field_pol_probe",
+        columns_uri="#pf_active/coil",
+    ),
+    "field_probes_grid": dict(
+        coupling_quantity=2,
+        rows_uri="#magnetics/b_field_pol_probe",
+        columns_uri="#pf_plasma/element",
+    ),
+    "field_probes_passive": dict(
+        coupling_quantity=2,
+        rows_uri="#magnetics/b_field_pol_probe",
+        columns_uri="#pf_passive/loop",
+    ),
+    "mutual_active_active": dict(
+        coupling_quantity=1,
+        rows_uri="#pf_active/coil",
+        columns_uri="#pf_active/coil",
+    ),
+    "mutual_grid_active": dict(
+        coupling_quantity=1,
+        rows_uri="#pf_plasma/element",
+        columns_uri="#pf_active/coil",
+    ),
+    "mutual_grid_grid": dict(
+        coupling_quantity=1,
+        rows_uri="#pf_plasma/element",
+        columns_uri="#pf_plasma/element",
+    ),
+    "mutual_grid_passive": dict(
+        coupling_quantity=1,
+        rows_uri="#pf_plasma/element",
+        columns_uri="#pf_passive/loop",
+    ),
+    "mutual_loops_active": dict(
+        coupling_quantity=1,
+        rows_uri="#magnetics/flux_loop",
+        columns_uri="#pf_active/coil",
+    ),
+    "mutual_loops_passive": dict(
+        coupling_quantity=1,
+        rows_uri="#magnetics/flux_loop",
+        columns_uri="#pf_passive/loop",
+    ),
+    "mutual_loops_grid": dict(
+        coupling_quantity=1,
+        rows_uri="#magnetics/flux_loop",
+        columns_uri="#pf_plasma/element",
+    ),
+    "mutual_passive_active": dict(
+        coupling_quantity=1,
+        rows_uri="#pf_passive/loop",
+        columns_uri="#pf_active/coil",
+    ),
+    "mutual_passive_passive": dict(
+        coupling_quantity=1,
+        rows_uri="#pf_passive/loop",
+        columns_uri="#pf_passive/loop",
+    ),
+}
+
+
+with (
+    imas.DBEntry(input_uri, "r") as entry,
+    imas.DBEntry(output_uri, "x", dd_version=target_dd_version) as out,
+):
+    print("Loaded IMAS Data Entry:", input_uri)
+
+    print("This data entry contains the following IDSs:")
+    filled_idss = []
+    for idsname in entry.factory.ids_names():
+        occurrences = entry.list_all_occurrences(idsname)
+        if occurrences:
+            filled_idss.append(idsname)
+            print(f"- {idsname}, occurrences: {occurrences}")
+    print("")
+
+    # Load and convert all IDSs (except em_coupling) with imas.convert_ids()
+    # N.B. we know that the input URI doesn't have multiple occurrences, so
+    # we do not need to worry about them:
+    for idsname in filled_idss:
+        if idsname == "em_coupling":
+            continue
+
+        print(f"Loading IDS: {idsname}...")
+        ids = entry.get(idsname, autoconvert=False)
+        print(f"Converting IDS {idsname} to DD {target_dd_version}...")
+        ids4 = imas.convert_ids(
+            ids,
+            target_dd_version,
+            provenance_origin_uri=input_uri,
+        )
+        print(f"Storing IDS {idsname} to output data entry...")
+        out.put(ids4)
+
+    print("Conversion for em_coupling:")
+    emc = entry.get("em_coupling", autoconvert=False)
+    print("Using standard convert, this may log warnings about discarding data")
+    emc4 = imas.convert_ids(
+        emc,
+        target_dd_version,
+        provenance_origin_uri=input_uri,
+    )
+
+    print("Starting custom conversion of the coupling matrices")
+    for matrix_name, mapping in COUPLING_MAPS.items():
+        # Skip empty matrices
+        if not emc[matrix_name].has_value:
+            continue
+
+        # Allocate a new coupling_matrix AoS element
+        emc4.coupling_matrix.resize(len(emc4.coupling_matrix) + 1, keep=True)
+        # And fill it
+
+        emc4.coupling_matrix[-1].name = matrix_name
+        # Assigning an integer to the identifier will automatically fill the
+        # index/name/description. See documentation:
+        # https://imas-python.readthedocs.io/en/latest/identifiers.html
+        emc4.coupling_matrix[-1].quantity = mapping["coupling_quantity"]
+        emc4.coupling_matrix[-1].rows_uri = [mapping["rows_uri"]]
+        emc4.coupling_matrix[-1].columns_uri = [mapping["columns_uri"]]
+        emc4.coupling_matrix[-1].data = emc[matrix_name].value
+        # N.B. the original data has no error_upper/error_lower so we skip these
+    # Store em_coupling IDS
+    out.put(emc4)
+
+    print("Generating pf_plasma IDS...")
+    # N.B. This logic is specific to DINA
+    # Create a new pf_plasma IDS and set basic properties
+    pf_plasma = out.factory.pf_plasma()
+    pf_plasma.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    pf_plasma.ids_properties.comment = "PF Plasma generated from equilibrium"
+
+    equilibrium = entry.get("equilibrium", lazy=True, autoconvert=False)
+    r = equilibrium.time_slice[0].profiles_2d[0].grid.dim1
+    z = equilibrium.time_slice[0].profiles_2d[0].grid.dim2
+    nr, nz = len(r), len(z)
+    # Generate a pf_plasma element for each grid point:
+    pf_plasma.element.resize(nr * nz)
+    for ir, rval in enumerate(r):
+        for iz, zval in enumerate(z):
+            element = pf_plasma.element[ir * nr + iz]
+            element.geometry.geometry_type = 2  # rectangle
+            element.geometry.rectangle.r = rval
+            element.geometry.rectangle.z = zval
+    # Store pf_plasma IDS
+    out.put(pf_plasma)
+
+print("Conversion finished")