tecio-python 0.1.1__tar.gz → 0.2.0__tar.gz

{tecio_python-0.1.1/tecio_python.egg-info → tecio_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tecio-python
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python interface for reading and writing Tecplot data files
 Project-URL: Homepage, https://github.com/meersman/tecio
 Project-URL: Documentation, https://meersman.github.io/tecio/
@@ -97,7 +97,7 @@ Reading a file:
 
 ```python
 with tecio.open("sine.szplt", "r") as tec:
-    print(tec.variables)   # ['x', 'y']
+    print(tec.variables)  # ['x', 'y']
     x = tec.zone[0].variable[0].values
     y = tec.zone[0].variable[1].values
     # or

{tecio_python-0.1.1 → tecio_python-0.2.0}/README.md

@@ -53,7 +53,7 @@ Reading a file:
 
 ```python
 with tecio.open("sine.szplt", "r") as tec:
-    print(tec.variables)   # ['x', 'y']
+    print(tec.variables)  # ['x', 'y']
     x = tec.zone[0].variable[0].values
     y = tec.zone[0].variable[1].values
     # or

{tecio_python-0.1.1 → tecio_python-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tecio-python"
-version = "0.1.1"
+version = "0.2.0"
 description = "Python interface for reading and writing Tecplot data files"
 
 readme = "README.md"

{tecio_python-0.1.1 → tecio_python-0.2.0}/tecio/__init__.py

@@ -11,7 +11,7 @@ try:
 except metadata.PackageNotFoundError:
     __version__ = "0.0.0"
 
-from . import cli, dat, libtecio, plt, szl, utils
+from . import cli, dat, libtecio, plt, szl
 from ._containers import VariableList, ZoneList
 from ._io import AppendReadWrite, AppendWrite, open
 
@@ -28,7 +28,6 @@ __all__ = [
     "dat",
     "plt",
     "szl",
-    "utils",
     "cli",
     "AppendWrite",
     "AppendReadWrite",

tecio_python-0.2.0/tecio/_meta.py

@@ -0,0 +1,168 @@
+r"""Structural metadata records shared by the Tecplot file writers.
+
+The writer for each output format -- SZL (``.szplt``), PLT (``.plt``), and ASCII DAT
+(``.dat``) -- keeps a running, in-memory description of what it has committed to disk:
+the dataset header, auxiliary-data counts, and one record per zone.  Defining that
+description once here lets all three writers share a single representation instead of
+each maintaining ad-hoc bookkeeping.
+
+The records mirror the file- and zone-level fields of the Tecplot data format
+(``TECINI142`` for the file header and ``TECZNE142`` for each zone): dataset title, file
+type, variable names, and the per-variable passive, value-location, and share-from
+arrays, together with per-zone dimensions and aux-item counts.
+
+Design notes:
+    * Only lightweight descriptors are stored -- shapes, enums, and small integers --
+      never the variable data arrays, so the record stays cheap in memory even for files
+      with many zones.
+    * ``slots=True`` removes the per-instance ``__dict__``, and immutable tuple fields
+      keep the per-variable lists compact.  A :class:`ZoneMeta` is a write-once snapshot
+      and is therefore ``frozen``; :class:`WriterMeta` is mutable because it grows as
+      zones are written.
+    * Enum types are imported only under :data:`typing.TYPE_CHECKING`.  With ``from
+      __future__ import annotations`` the annotations are never evaluated at runtime,
+      which keeps this module free of any import cycle with :mod:`tecio.libtecio`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .libtecio import DataType, FileType, ValueLocation, ZoneType
+
+
+# =====================================================================================
+# Zone-level record
+# =====================================================================================
+
+
+@dataclass(slots=True, frozen=True)
+class ZoneMeta:
+    """Lightweight, write-once description of a single written zone.
+
+    Per-variable fields (:attr:`value_locations`, :attr:`passive_vars`,
+    :attr:`shared_vars`, :attr:`data_types`) span every dataset variable and correspond
+    to the ``ValueLocation``, ``PassiveVarList``, ``ShareVarFromZone``, and
+    variable-type arrays of a ``TECZNE142`` zone header.
+
+    Attributes:
+        index:           1-based zone index returned by the C library.
+        title:           Zone title.
+        zone_type:       The zone's :class:`~tecio.libtecio.ZoneType`.
+        solution_time:   Solution time (``0.0`` for static zones).
+        strand_id:       Strand ID (``0`` for static zones).
+        num_aux_items:   Number of zone-level auxiliary items written.
+        dimensions:      Nodal ``(imax, jmax, kmax)`` for ORDERED zones, else ``None``.
+        num_nodes:       Node count for FE zones, else ``None``.
+        num_elements:    Element count for FE zones, else ``None``.
+        value_locations: Per-variable value location, full dataset length.
+        passive_vars:    Per-variable passive flags, full dataset length.
+        shared_vars:     Per-variable share-from zone index (1-based; ``0`` for not
+                         shared), full dataset length.
+        data_types:      Per-variable data type, full dataset length.
+
+    """
+
+    index: int
+    title: str
+    zone_type: ZoneType
+    solution_time: float = 0.0
+    strand_id: int = 0
+    num_aux_items: int = 0
+    # Ordered zones carry IJK dimensions; FE zones carry node/element counts.
+    dimensions: tuple[int, int, int] | None = None
+    num_nodes: int | None = None
+    num_elements: int | None = None
+    # Per-variable descriptors (length == dataset variable count).
+    value_locations: tuple[ValueLocation, ...] = ()
+    passive_vars: tuple[bool, ...] = ()
+    shared_vars: tuple[int, ...] = ()
+    data_types: tuple[DataType, ...] = ()
+
+    @property
+    def nodal_shape(self) -> tuple[int, int, int] | None:
+        """Nodal ``(imax, jmax, kmax)`` for ORDERED zones, else ``None``."""
+        return self.dimensions
+
+    @property
+    def cell_shape(self) -> tuple[int, ...] | None:
+        """Cell-centred ``(imax-1, jmax-1, kmax-1)`` (floored at 1) or ``None``."""
+        if self.dimensions is None:
+            return None
+        return tuple(max(n - 1, 1) for n in self.dimensions)
+
+
+# =====================================================================================
+# Dataset-level record
+# =====================================================================================
+
+
+@dataclass(slots=True)
+class WriterMeta:
+    """Running record of everything a writer has committed to a file.
+
+    Populated incrementally as the file header, auxiliary data, and zones are
+    written, so it always reflects the current on-disk state.  It is the single
+    source of truth for cross-zone validation (for example, resolving the shape
+    of a shared variable) and is suitable for summarising the writer state.
+
+    Attributes:
+        path:                  Output file path.
+        title:                 Dataset title.
+        file_type:             :class:`~tecio.libtecio.FileType` of the output.
+        file_format:           Format tag, e.g. ``"szplt"``, ``"plt"``, or
+                               ``"dat"``.
+        variables:             Variable name list, or ``None`` before the file
+                               header has been written (lazy-open).
+        num_dataset_aux_items: Count of dataset-level aux items written.
+        num_var_aux_items:     Total variable-level aux items written.
+        zones:                 Mapping of 1-based zone index to :class:`ZoneMeta`,
+                               in write order.
+    """
+
+    path: str
+    title: str
+    file_type: FileType
+    file_format: str
+    variables: list[str] | None = None
+    num_dataset_aux_items: int = 0
+    num_var_aux_items: int = 0
+    zones: dict[int, ZoneMeta] = field(default_factory=dict)
+
+    # -- Derived quantities -----------------------------------------------------------
+
+    @property
+    def num_vars(self) -> int:
+        """Number of dataset variables, or ``0`` before the header is written."""
+        return len(self.variables) if self.variables is not None else 0
+
+    @property
+    def num_zones(self) -> int:
+        """Number of zones written so far."""
+        return len(self.zones)
+
+    # -- Update methods (called by the writer as it commits data) ---------------------
+
+    def set_variables(self, names: list[str]) -> None:
+        """Record the dataset variable names once the header is written."""
+        self.variables = names
+
+    def note_dataset_aux(self, count: int) -> None:
+        """Accumulate the number of dataset-level aux items written."""
+        self.num_dataset_aux_items += count
+
+    def note_var_aux(self, count: int) -> None:
+        """Accumulate the number of variable-level aux items written."""
+        self.num_var_aux_items += count
+
+    def record_zone(self, zone: ZoneMeta) -> None:
+        """Register a fully written zone by its 1-based index."""
+        self.zones[zone.index] = zone
+
+    # -- Retrieval helpers ------------------------------------------------------------
+
+    def zone(self, index: int) -> ZoneMeta | None:
+        """Return the :class:`ZoneMeta` for *index*, or ``None`` if unknown."""
+        return self.zones.get(index)

{tecio_python-0.1.1 → tecio_python-0.2.0}/tecio/cli/tec2mat.py

@@ -69,7 +69,10 @@ Output structure:
           .var_locations          cell    'NODAL' | 'CELL_CENTERED' | ''
           .var_dtypes             cell    'FLOAT' | 'DOUBLE' | 'INT32' | ...
           .var_shared_from        array   1-based source zone, or 0 if not shared
-          .node_map               array   (num_elements x nodes_per_cell), FE only
+          .node_map               array   (num_elements x nodes_per_cell), FE only,
+                                          omitted if connectivity is shared
+          .node_map_shared_from   double  1-based source zone, FE only, present only
+                                          if this zone shares its connectivity
 
     Variable arrays are stored at their on-disk NumPy dtype, so single/double/integer
     precision is preserved.  The real variable names are kept only in ``info.var_names``
@@ -79,7 +82,9 @@ Output structure:
     Passive and shared variables carry no data: their ``var_<k>`` field is an empty
     matrix ``[]``.  A shared variable is therefore never duplicated on disk -- the data
     lives in its source zone and ``var_shared_from`` records where, so the MATLAB user
-    can dereference it (see the examples below).
+    can dereference it (see the examples below).  Shared FE connectivity follows the
+    same convention: a zone sharing its node map has no ``node_map`` field at all, only
+    ``node_map_shared_from``.
 
 Examples:
     Convert an SZL file to ``flow.mat``::
@@ -119,6 +124,17 @@ Examples:
             end
         end
 
+    Shared FE connectivity resolves the same way, via ``node_map_shared_from``::
+
+        function m = tecnodemap(d, zoneIdx)
+            z = d.(sprintf('zone_%d', zoneIdx));
+            if isfield(z, 'node_map')
+                m = z.node_map;
+            else
+                m = d.(sprintf('zone_%d', z.node_map_shared_from)).node_map;
+            end
+        end
+
 See Also:
     * :mod:`tecio.cli.teconvert`: Convert between Tecplot file formats (``.szplt``,
       ``.plt``, ``.dat``) without leaving the Tecplot ecosystem.
@@ -153,9 +169,9 @@ import numpy as np
 from .. import open as tecio_open
 from ..libtecio import ZoneType
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 # Constants
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 
 #: Zone types whose connectivity is face-based and cannot be read; their
 #: node map is omitted from the output.
@@ -165,17 +181,18 @@ _FE_POLY: frozenset[ZoneType] = frozenset({
 })
 
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 # Argument parsing
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 
 
 def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         prog="tec2mat",
         description=(
-            "Convert a Tecplot file to a MATLAB .mat file.  Each input file maps to "
-            "one output file, with every zone stored as a named struct."
+            # -|-------------------|---------------------------------------------|
+            "Convert a Tecplot file to a MATLAB .mat file.  Each input file maps\n"
+            "to one output file, with every zone stored as a named struct."
         ),
         epilog=(
             "Example usage:\n"
@@ -236,9 +253,9 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     return parser.parse_args(argv)
 
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 # Conversion helpers
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 
 
 def _build_info_dict(reader: Any) -> dict[str, Any]:
@@ -360,19 +377,28 @@ def _zone_to_dict(zone: Any, num_vars: int) -> dict[str, Any]:
     d["var_dtypes"] = np.array(dtypes, dtype=object)
     d["var_shared_from"] = shared_from
 
-    # Connectivity for simple FE zones only.  Ordered zones have no node map,
-    # and poly zones expose none through the readers.
+    # Connectivity for simple FE zones only.  Ordered zones have no node map, and poly
+    # zones expose none through the readers.
+    #
+    # A zone that shares connectivity is handled the same way as a shared variable
+    # above: rather than duplicating the (potentially large) node map into every zone's
+    # struct, store the 1-based source zone number so the MATLAB user can dereference
+    # zone_<src>.node_map themselves.
     if zone.zone_type != ZoneType.ORDERED and zone.zone_type not in _FE_POLY:
-        node_map = zone.node_map
-        if node_map is not None:
-            d["node_map"] = node_map
+        con_src = zone.shared_connectivity
+        if con_src is not None:
+            d["node_map_shared_from"] = np.int32(con_src)
+        else:
+            node_map = zone.node_map
+            if node_map is not None:
+                d["node_map"] = node_map
 
     return d
 
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 # Main entry point
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 
 
 def main(argv: Sequence[str] | None = None) -> int:
@@ -384,9 +410,9 @@ def main(argv: Sequence[str] | None = None) -> int:
     """
     args = _parse_args(argv)
 
-    # SciPy is an optional dependency, imported lazily so that merely importing
-    # this module (e.g. to call main() from a script) does not require SciPy
-    # unless the tool is actually run.
+    # SciPy is an optional dependency, imported lazily so that merely importing this
+    # module (e.g. to call main() from a script) does not require SciPy unless the tool
+    # is actually run.
     try:
         from scipy import io as scipy_io
     except ImportError:

{tecio_python-0.1.1 → tecio_python-0.2.0}/tecio/cli/tecdump.py

@@ -87,10 +87,12 @@ def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description="Dump all contents of a Tecplot file.",
         epilog=(
+            # -|-------------------|---------------------------------------------|
             "Example usage:\n"
             "  Print all contents of file\n"
             "    $ tecdump <input file>\n"
-            "  Print all values from zone 1 variable 3 (set maxval to large number)\n"
+            "  Print all values from zone 1 variable 3 (set maxval to large\n"
+            "  number)\n"
             "    $ tecdump -zone 1 -variable 3 -maxvals 1e6 <input file>\n"
         ),
         formatter_class=lambda prog: argparse.RawDescriptionHelpFormatter(
@@ -158,67 +160,68 @@ def main(argv: Sequence[str] | None = None) -> int:
     # Create tec reader object
     with tecio_open(args.filename, "r") as tec:
         print("\nFile Record")
-        print("=" * 70)
-        print(f"File Type         : {tec.file_type}")
-        print(f"Dataset Title     : {tec.title}")
-        print(f"Num Vars          : {tec.num_vars}")
-        print(f"Variables         : {tec.variables}")
-        print(f"Num Zones         : {tec.num_zones}")
-        print(f"Dataset Aux Items : {tec.num_auxdata_items}")
+        print("=" * 78)
+        print(f"File Type              : {tec.file_type}")
+        print(f"Dataset Title          : {tec.title}")
+        print(f"Num Vars               : {tec.num_vars}")
+        print(f"Variables              : {tec.variables}")
+        print(f"Num Zones              : {tec.num_zones}")
+        print(f"Dataset Aux Items      : {tec.num_auxdata_items}")
 
         # Print dataset-level auxiliary data if available
         print("\n\nDataset Auxiliary Data")
-        print("-" * 70)
+        print("-" * 78)
         if len(tec.auxdata) > 0:
             for name, value in tec.auxdata.items():
-                print(f"  {name:>15} : {value}")
+                print(f"  {name:>20} : {value}")
 
         # Print variable-level auxiliary data if available
         print("\n\nVariable Auxiliary Data")
-        print("-" * 70)
+        print("-" * 78)
         for i in range(tec.num_vars):
             var_aux = tec.get_var_auxdata(i + 1)
             if len(var_aux) > 0:
-                print(f"Var {i + 1:3} Aux Data  : {dict(var_aux)}")
+                print(f"Var {i + 1:3} Aux Data       : {dict(var_aux)}")
                 for name, value in var_aux.items():
-                    print(f"  {name:>15} : {value}")
+                    print(f"  {name:>20} : {value}")
 
         # Print zone record
         if args.print_zones:
             print("\n\nZone Record")
-            print("-" * 70)
+            print("-" * 78)
             for i in range(tec.num_zones):
                 if (args.zone is None) or (i + 1 == args.zone):
                     zone = tec.zone[i]
                     print(f"\nZone {i + 1:3}")
-                    print(f"  Title           : {zone.title}")
-                    print(f"  Zone Type       : {zone.zone_type}")
+                    print(f"  Title                : {zone.title}")
+                    print(f"  Zone Type            : {zone.zone_type}")
                     if zone.zone_type == ZoneType.ORDERED:
-                        print(f"  I,J,K           : {zone.dimensions}")
+                        print(f"  I,J,K                : {zone.dimensions}")
                     else:
-                        print(f"  Num Nodes       : {zone.num_nodes}")
-                        print(f"  Num Elements    : {zone.num_elements}")
-                    print(f"  Is Enabled      : {zone.is_enabled()}")
-                    print(f"  Solution Time   : {zone.solution_time}")
-                    print(f"  Strand ID       : {zone.strand_id}")
+                        print(f"  Num Nodes            : {zone.num_nodes}")
+                        print(f"  Num Elements         : {zone.num_elements}")
+                    print(f"  Is Enabled           : {zone.is_enabled()}")
+                    print(f"  Solution Time        : {zone.solution_time}")
+                    print(f"  Strand ID            : {zone.strand_id}")
 
                     # Print zone-level auxiliary data
                     if len(zone.auxdata) > 0:
-                        print(f"  Zone Aux Data   : {dict(zone.auxdata)}")
+                        print(f"  Zone Aux Data        : {dict(zone.auxdata)}")
                         for name, value in zone.auxdata.items():
-                            print(f"  {name:>15} : {value}")
+                            print(f"  {name:>20} : {value}")
 
                     # Show node map for FE zones
                     if zone.zone_type != ZoneType.ORDERED:
-                        print(f"  Nodes Per Cell  : {zone.nodes_per_cell}")
+                        print(f"  Shared Connectivity  : {zone.shared_connectivity}")
+                        print(f"  Nodes Per Cell       : {zone.nodes_per_cell}")
                         if zone.node_map is not None:
-                            print(f"  Node Map Shape  : {zone.node_map.shape}")
+                            print(f"  Node Map Shape       : {zone.node_map.shape}")
                             value_str = np.array2string(
                                 zone.node_map,
-                                prefix="  Connectivity    : ",
+                                prefix="  Node Map             : ",
                                 separator=", ",
                             )
-                            print(f"  Connectivity    : {value_str}")
+                            print(f"  Node Map             : {value_str}")
 
                     # Print variable record
                     if args.print_vars:
@@ -226,28 +229,32 @@ def main(argv: Sequence[str] | None = None) -> int:
                             if (args.variable is None) or (j + 1 == args.variable):
                                 var = zone.variable[j]
                                 print(f"  Variable {j + 1:3}")
-                                print(f"    Name          : {var.name}")
-                                print(f"    Data Type     : {var.data_type}")
-                                print(f"    Location      : {var.value_location}")
-                                print(f"    Is Enabled    : {var.is_enabled()}")
-                                print(f"    Is Passive    : {var.is_passive()}")
-                                print(f"    Shared Zone   : {var.shared_zone}")
-                                print(f"    Num Values    : {var.num_values}")
+                                print(f"    Name               : {var.name}")
+                                print(f"    Is Enabled         : {var.is_enabled()}")
+                                print(f"    Is Passive         : {var.is_passive()}")
 
                                 # Check if variable is shared or passive (no data)
-                                if (
-                                    var.shared_zone is None
-                                    and not var.is_passive()
-                                    and var.values is not None
-                                ):
-                                    print(f"    Array shape   : {var.values.shape}")
+                                if (not var.is_passive()) and (var.values is not None):
+                                    print(
+                                        f"    Location           : {var.value_location}"
+                                    )  # noqa: E501
+                                    print(f"    Shared Zone        : {var.shared_zone}")
+                                    print(f"    Num Values         : {var.num_values}")
+                                    print(f"    Data Type          : {var.data_type}")
+                                    print(
+                                        f"    NumPy Data Type    : {var.values.dtype}"
+                                    )  # noqa: E501
+                                    print(
+                                        f"    Array Shape        : {var.values.shape}"
+                                    )  # noqa: E501
+
                                     # Get first 100 values or all if fewer than 100
                                     value_str = np.array2string(
                                         var.values,
-                                        prefix="    Values        : ",
+                                        prefix="    Values             : ",
                                         separator=", ",
                                     )
-                                    print(f"    Values        : {value_str}")
+                                    print(f"    Values             : {value_str}")
 
     return 0
 

{tecio_python-0.1.1 → tecio_python-0.2.0}/tecio/cli/tecextract.py

@@ -93,9 +93,9 @@ import numpy as np
 from .. import open as tecio_open
 from ..libtecio import ZoneType
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 # Helpers
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 
 
 def _parse_index_list(value: str) -> list[int]:
@@ -119,19 +119,21 @@ def _parse_index_list(value: str) -> list[int]:
         ) from exc
 
 
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 # Argument parsing
-# ---------------------------------------------------------------------------
+# --------------------------------------------------------------------------------------
 
 
 def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         prog="tecextract",
         description=(
-            "Extract a subset of zones and/or variables from a Tecplot file. "
+            # -|--------------------|---------------------------------------------|
+            "Extract a subset of zones and/or variables from a Tecplot file.\n"
             "Output format is determined by the -o extension."
         ),
         epilog=(
+            # -|--------------------|---------------------------------------------|
             "Example usage:\n"
             "  Extract zones 1 and 3\n"
             "    $ tecextract -zones 1,3 <file>\n"
@@ -284,6 +286,15 @@ def main(argv: Sequence[str] | None = None) -> int:
                 if auxvar:
                     writer.add_auxvar_dict(auxvar)
 
+                # Maps a source zone's 1-based index to its 1-based index in the output
+                # file, populated as zones are actually written:
+                # - A variable/connectivity shared from a zone that's also in this map
+                #   can have its sharing preserved (just pointing at the new, compacted
+                #   index) instead of being materialized as independent data
+                # - Only a share whose source zone was excluded from the extraction
+                #   genuinely has nowhere to point and must fall back to real data.
+                zone_index_map: dict[int, int] = {}
+
                 for i, zone in enumerate(reader.zone):
                     zone_num = i + 1
                     if zone_num not in zone_set:
@@ -306,18 +317,26 @@ def main(argv: Sequence[str] | None = None) -> int:
 
                     for orig_idx in out_var_indices:
                         var = zone.variable[orig_idx - 1]
-                        passive_vars.append(var.is_passive())
-                        sv = var.shared_zone
-                        # Sharing refers to zones by their index in the
-                        # *output* file, which may differ from the source.
-                        # We cannot safely remap shares to a reduced zone
-                        # set, so drop sharing — write as independent data.
-                        var_sharing.append(0)
+                        is_passive = var.is_passive()
+                        passive_vars.append(is_passive)
                         active_locs.append(var.value_location)
 
-                        if var.is_passive() or sv is not None:
+                        sv = var.shared_zone
+                        remapped = zone_index_map.get(sv) if sv is not None else None
+
+                        if is_passive:
+                            var_sharing.append(0)
+                            active_data.append(np.array([], dtype=np.float32))
+                        elif remapped is not None:
+                            # Source zone was also extracted -> preserve the data
+                            # sharing relationship
+                            var_sharing.append(remapped)
                             active_data.append(np.array([], dtype=np.float32))
                         else:
+                            # Variables not shared at all, or shared from a zone that is
+                            # not output, in which case branch sharing -> write the
+                            # actual values as independent data
+                            var_sharing.append(0)
                             arr = var.values
                             if arr is None or arr.size == 0:
                                 passive_vars[-1] = True
@@ -327,13 +346,17 @@ def main(argv: Sequence[str] | None = None) -> int:
 
                     writer_data = [
                         arr
-                        for arr, is_p in zip(active_data, passive_vars, strict=False)
-                        if not is_p
+                        for arr, is_p, sv in zip(
+                            active_data, passive_vars, var_sharing, strict=False
+                        )
+                        if not is_p and sv == 0
                     ]
                     writer_locs = [
                         loc
-                        for loc, is_p in zip(active_locs, passive_vars, strict=False)
-                        if not is_p
+                        for loc, is_p, sv in zip(
+                            active_locs, passive_vars, var_sharing, strict=False
+                        )
+                        if not is_p and sv == 0
                     ]
 
                     zone_aux: dict[str, str] | None = None
@@ -353,13 +376,23 @@ def main(argv: Sequence[str] | None = None) -> int:
                     if zt == ZoneType.ORDERED:
                         writer.write_ijk_zone(data=writer_data, **common_kw)
                     else:
+                        con_src = zone.shared_connectivity
+                        con_remapped = (
+                            zone_index_map.get(con_src) if con_src is not None else None
+                        )
                         writer.write_fe_zone(
                             zone_type=zt,
                             data=writer_data,
-                            node_map=zone.node_map,
+                            node_map=None if con_remapped else zone.node_map,
+                            con_sharing=con_remapped,
                             **common_kw,
                         )
 
+                    # Record where this source zone landed in the output, so a later
+                    # zone sharing from it can point at the real (compacted) index
+                    # instead of falling back to independent data.
+                    zone_index_map[zone_num] = writer.current_zone
+
     except Exception as exc:  # noqa: BLE001
         print(f"Error: {exc}", file=sys.stderr)
         dst.unlink(missing_ok=True)