tecio-python 0.3.1__tar.gz → 0.3.2__tar.gz

{tecio_python-0.3.1/tecio_python.egg-info → tecio_python-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tecio-python
-Version: 0.3.1
+Version: 0.3.2
 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/
@@ -82,6 +82,8 @@ export TECIO_LIB=/path/to/libtecio.dylib  # macOS
 
 ## Quick start
 
+Writing a file:
+
 ```python
 import tecio
 import numpy as np
@@ -90,7 +92,7 @@ x = np.linspace(0, 2 * np.pi, 100)
 y = np.sin(x)
 
 with tecio.open("sine.szplt", "w") as tec:
-    tec.write_ijk_zone(data=[x, y], variables=["x", "y"])
+    tec.write_ordered_zone(data=[x, y], variables=["x", "y"])
 ```
 
 Reading a file:
@@ -98,10 +100,10 @@ Reading a file:
 ```python
 with tecio.open("sine.szplt", "r") as tec:
     print(tec.variables)  # ['x', 'y']
-    x = tec.zone[0].variable[0].values
-    y = tec.zone[0].variable[1].values
+    x = tec.zones[0].variables[0].values
+    y = tec.zones[0].variables[1].values
     # or
-    x, y = tec.zone[0].get_array(["x", "y"])
+    x, y = tec.zones[0].get_array(["x", "y"])
 ```
 
 ## API
@@ -129,7 +131,7 @@ Supported formats:
 
 ## Contributing
 
-Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+Contributions are welcome (see [CONTRIBUTING.md](CONTRIBUTING.md) for details).
 
 ---
 

{tecio_python-0.3.1 → tecio_python-0.3.2}/README.md

@@ -38,6 +38,8 @@ export TECIO_LIB=/path/to/libtecio.dylib  # macOS
 
 ## Quick start
 
+Writing a file:
+
 ```python
 import tecio
 import numpy as np
@@ -46,7 +48,7 @@ x = np.linspace(0, 2 * np.pi, 100)
 y = np.sin(x)
 
 with tecio.open("sine.szplt", "w") as tec:
-    tec.write_ijk_zone(data=[x, y], variables=["x", "y"])
+    tec.write_ordered_zone(data=[x, y], variables=["x", "y"])
 ```
 
 Reading a file:
@@ -54,10 +56,10 @@ Reading a file:
 ```python
 with tecio.open("sine.szplt", "r") as tec:
     print(tec.variables)  # ['x', 'y']
-    x = tec.zone[0].variable[0].values
-    y = tec.zone[0].variable[1].values
+    x = tec.zones[0].variables[0].values
+    y = tec.zones[0].variables[1].values
     # or
-    x, y = tec.zone[0].get_array(["x", "y"])
+    x, y = tec.zones[0].get_array(["x", "y"])
 ```
 
 ## API
@@ -85,7 +87,7 @@ Supported formats:
 
 ## Contributing
 
-Contributions are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+Contributions are welcome (see [CONTRIBUTING.md](CONTRIBUTING.md) for details).
 
 ---
 

{tecio_python-0.3.1/tecio → tecio_python-0.3.2}/plugins/paraview/TecplotTecioReader.py

@@ -449,7 +449,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
 
         self._zone_selection.RemoveAllArrays()
         self._zone_keys.clear()
-        for zone in reader.zone:
+        for zone in reader.zones:
             title = zone.title or f"Zone {zone.zone_index}"
             key = f"{zone.zone_index}: {title}"
             self._zone_keys[zone.zone_index] = key
@@ -677,7 +677,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
         static/always-present geometry, so they're excluded from the time axis and
         instead included at every requested time (see :meth:`RequestData`).
         """
-        times = {zone.solution_time for zone in reader.zone if zone.strand_id != 0}
+        times = {zone.solution_time for zone in reader.zones if zone.strand_id != 0}
         return sorted(times)
 
     @smproperty.doublevector(
@@ -760,7 +760,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
         self._add_variable_aux_field_data(output.GetFieldData(), reader)
 
         block_index = 0
-        for zone in reader.zone:
+        for zone in reader.zones:
             key = self._zone_keys.get(zone.zone_index)
             if key is not None and not self._zone_selection.ArrayIsEnabled(key):
                 continue
@@ -990,7 +990,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
         n_points = dataset.GetNumberOfPoints()
         n_cells = dataset.GetNumberOfCells()
 
-        for var in zone.variable:
+        for var in zone.variables:
             if not self._array_selection.ArrayIsEnabled(var.name):
                 continue
             values = var.values
@@ -1039,7 +1039,7 @@ class TecplotReader(VTKPythonAlgorithmBase):
             if name is None:
                 flat_components.append(None)
                 continue
-            var = zone.variable[name]
+            var = zone.variables[name]
             values = var.values
             if values is None:  # passive, or absent in this specific zone
                 flat_components.append(None)

{tecio_python-0.3.1 → tecio_python-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tecio-python"
-version = "0.3.1"
+version = "0.3.2"
 description = "Python interface for reading and writing Tecplot data files"
 
 readme = "README.md"
@@ -69,6 +69,9 @@ mat = ["scipy"]
 include = ["tecio*"]
 exclude = ["archive*", "test*"]
 
+[tool.setuptools.data-files]
+"share/tecio/plugins/paraview" = ["plugins/paraview/TecplotTecioReader.py"]
+
 [tool.ruff]
 line-length = 88
 target-version = "py310"
@@ -109,7 +112,7 @@ python-version = "3.11"
 output-format = "concise"
 
 [[tool.ty.overrides]]
-include = ["tecio/plugins/**"]
+include = ["plugins/**"]
 
 [tool.ty.overrides.rules]
 unresolved-import = "ignore"

{tecio_python-0.3.1 → tecio_python-0.3.2}/tecio/__init__.py

@@ -9,7 +9,7 @@ from importlib import metadata
 try:
     __version__ = metadata.version("tecio")
 except metadata.PackageNotFoundError:
-    __version__ = "0.3.1"
+    __version__ = "0.3.2"
 
 from . import cli, libtecio
 from ._constants import (

{tecio_python-0.3.1 → tecio_python-0.3.2}/tecio/_containers.py

@@ -1,35 +1,35 @@
 """Index- and name-based container types for Tecplot data collections.
 
-These containers are shared by the ``tecio`` readers: ``Read.zone`` returns a
-:class:`ZoneList` of ``ReadZone`` and ``ReadZone.variable`` returns a
+These containers are shared by the ``tecio`` readers: ``Read.zones`` returns a
+:class:`ZoneList` of ``ReadZone`` and ``ReadZone.variables`` returns a
 :class:`VariableList` of ``ReadVariable`` for every supported format (SZL, PLT, DAT).
-They depend only on small structural protocols (``.name`` for variables, ``.variable``
+They depend only on small structural protocols (``.name`` for variables, ``.variables``
 for zones) so they import nothing from either hierarchy and cannot introduce a circular
 dependency.
 
 Access model:
 
-    reader.zone                  # ZoneList
-    reader.zone[0]               # ReadZone            (element)
-    reader.zone[1:4]             # ZoneList            (sub-collection, same kind)
-    reader.zone[0].variable      # VariableList
-    reader.zone[0].variable["x"] # ReadVariable        (object: .values, .is_passive)
-    reader.zone[0].variable[2]   # ReadVariable        (0-based index)
+    reader.zones                  # ZoneList
+    reader.zones[0]               # ReadZone            (element)
+    reader.zones[1:4]             # ZoneList            (sub-collection, same kind)
+    reader.zones[0].variables      # VariableList
+    reader.zones[0].variables["x"] # ReadVariable        (object: .values, .is_passive)
+    reader.zones[0].variables[2]   # ReadVariable        (0-based index)
 
 Subscripting always returns an element or a sub-collection *of the same kind* (never a
 raw array). The underlying NumPy data is pulled with ``get_array`` on a single zone,
 which mirrors the pandas ``df[...]`` split: a scalar key returns one array, a list of
 names returns a tuple of arrays (for unpacking)::
 
-    p = reader.zone[0].get_array("p")  # ndarray | None
-    p = reader.zone[0].get_array(2)  # ndarray | None  (0-based index)
-    x, y, z = reader.zone[0].get_array(["x", "y", "z"])  # tuple, one per name
+    p = reader.zones[0].get_array("p")  # ndarray | None
+    p = reader.zones[0].get_array(2)  # ndarray | None  (0-based index)
+    x, y, z = reader.zones[0].get_array(["x", "y", "z"])  # tuple, one per name
 
 There is deliberately **no** cross-zone array accessor. To pull one variable across
 many zones (e.g. a transient sequence), iterate explicitly so the outer axis is owned by
 your code, and stack only when you know the result is rectangular::
 
-    seq = [z.get_array("p") for z in reader.zone]  # list[ndarray | None]
+    seq = [z.get_array("p") for z in reader.zones]  # list[ndarray | None]
     stack = np.stack(seq)  # only if shapes all match
 
 Name lookup is exact and case-sensitive throughout, so distinct variables such
@@ -78,7 +78,7 @@ class _HasVariableList(Protocol):
     """A zone element exposing a name/index-addressable variable container."""
 
     @property
-    def variable(self) -> VariableList[Any]: ...
+    def variables(self) -> VariableList[Any]: ...
 
 
 _VarT = TypeVar("_VarT", bound=_HasName)
@@ -137,7 +137,7 @@ def select_variable_arrays(
 class VariableList(Generic[_VarT]):
     """Read-only sequence of variables with positional *and* named access.
 
-    Drop-in for the ``list`` previously returned by ``ReadZone.variable``:
+    Drop-in for the ``list`` previously returned by ``ReadZone.variables``:
     iteration, ``len()``, and integer indexing are unchanged. A string key
     resolves a variable by its exact, case-sensitive name.
 
@@ -208,7 +208,7 @@ class VariableList(Generic[_VarT]):
         """Return the variable names in dataset order."""
         return [var.name for var in self._items]
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # pragma: no cover
         n = len(self._items)
         if n == 0:
             return "VariableList([])"
@@ -229,16 +229,16 @@ class VariableList(Generic[_VarT]):
 class ZoneList(Generic[_ZoneT]):
     """Read-only sequence of zones: positional access and slicing only.
 
-    Drop-in for the ``list`` previously returned by ``Read.zone``: iteration, ``len()``,
-    and integer indexing are unchanged. Slicing returns another :class:`ZoneList` (not a
-    plain ``list``) so navigation composes.
+    Drop-in for the ``list`` previously returned by ``Read.zones``: iteration,
+    ``len()``, and integer indexing are unchanged. Slicing returns another
+    :class:`ZoneList` (not a plain ``list``) so navigation composes.
 
     This container deliberately exposes **no** data-extraction method. Pulling one
     variable across many zones is an explicit loop over the zones, keeping the outer
     (zone) axis owned by the caller (see the module docs).
 
     Args:
-        zones: Ordered list of zone elements (each exposing ``.variable``).
+        zones: Ordered list of zone elements (each exposing ``.variables``).
     """
 
     __slots__ = ("_items",)
@@ -277,7 +277,7 @@ class ZoneList(Generic[_ZoneT]):
             return ZoneList(self._items[key])
         return self._items[key]
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # pragma: no cover
         n = len(self._items)
         if n == 0:
             return "ZoneList([])"

{tecio_python-0.3.1 → tecio_python-0.3.2}/tecio/_dat_read.py

@@ -23,6 +23,7 @@ import numpy.typing as npt
 from ._constants import (
     DataPacking,
     DataType,
+    FaceNeighborMode,
     FileType,
     ValueLocation,
     ZoneType,
@@ -90,6 +91,14 @@ _STR_TO_DATAPACKING: dict[str, DataPacking] = {
     "block": DataPacking.BLOCK,
 }
 
+# ASCII keyword to FaceNeighborMode
+_STR_TO_FACENEIGHBORMODE: dict[str, FaceNeighborMode] = {
+    "localonetoone": FaceNeighborMode.LOCAL_ONE_TO_ONE,
+    "localonetomany": FaceNeighborMode.LOCAL_ONE_TO_MANY,
+    "globalonetoone": FaceNeighborMode.GLOBAL_ONE_TO_ONE,
+    "globalonetomany": FaceNeighborMode.GLOBAL_ONE_TO_MANY,
+}
+
 # Legacy F= (format) keyword to (is_fe, DataPacking)
 _STR_TO_LEGACY_FORMAT: dict[str, tuple[bool, DataPacking]] = {
     "POINT": (False, DataPacking.POINT),
@@ -933,10 +942,22 @@ class TecplotDatFEZoneReader(TecplotFEZoneReader):
     ASCII reader.
     """
 
-    __slots__ = ("_variables", "_node_map", "_aux_raw")
+    __slots__ = (
+        "_variables",
+        "_node_map",
+        "_aux_raw",
+        "_face_neighbor_mode",
+        "_num_face_connections",
+        "_face_connections",
+        "_face_neighbors_complete",
+    )
     _variables: list[TecplotVariableReader]
     _node_map: npt.NDArray[Any] | None
     _aux_raw: dict[str, str]
+    _face_neighbor_mode: FaceNeighborMode | None
+    _num_face_connections: int | None
+    _face_connections: npt.NDArray[np.int64] | None
+    _face_neighbors_complete: bool | None
 
     def __init__(
         self,
@@ -952,6 +973,10 @@ class TecplotDatFEZoneReader(TecplotFEZoneReader):
         node_map: npt.NDArray[Any] | None = None,
         datapacking: DataPacking = DataPacking.BLOCK,
         shared_connectivity: int | None = None,
+        face_neighbor_mode: FaceNeighborMode | None = None,
+        num_face_connections: int | None = None,
+        face_connections: npt.NDArray[np.int64] | None = None,
+        face_neighbors_complete: bool | None = None,
     ) -> None:
         super().__init__(
             zone_index=zone_index,
@@ -967,6 +992,10 @@ class TecplotDatFEZoneReader(TecplotFEZoneReader):
         object.__setattr__(self, "_variables", variables)
         object.__setattr__(self, "_node_map", node_map)
         object.__setattr__(self, "_aux_raw", auxdata)
+        object.__setattr__(self, "_face_neighbor_mode", face_neighbor_mode)
+        object.__setattr__(self, "_num_face_connections", num_face_connections)
+        object.__setattr__(self, "_face_connections", face_connections)
+        object.__setattr__(self, "_face_neighbors_complete", face_neighbors_complete)
 
     def _load_variables(self) -> list[TecplotVariableReader]:
         return self._variables
@@ -974,6 +1003,21 @@ class TecplotDatFEZoneReader(TecplotFEZoneReader):
     def _load_node_map(self) -> npt.NDArray[Any] | None:
         return self._node_map
 
+    def _load_face_neighbor_meta(
+        self,
+    ) -> tuple[FaceNeighborMode, int, bool | None] | None:
+        if self._face_neighbor_mode is None or self._num_face_connections is None:
+            return None
+        return (
+            self._face_neighbor_mode,
+            self._num_face_connections,
+            self._face_neighbors_complete,
+        )
+
+    def _load_face_connections(self) -> npt.NDArray[np.int64]:
+        assert self._face_connections is not None  # narrowed: meta already confirmed
+        return self._face_connections
+
     def _load_auxdata(self) -> TecplotAuxDataReader:
         return TecplotDatAuxDataReader(self._aux_raw)
 
@@ -1058,7 +1102,7 @@ class TecplotDatReader(TecplotReader):
         return len(self._zones)
 
     @property
-    def zone(self) -> ZoneList[TecplotZoneReader]:
+    def zones(self) -> ZoneList[TecplotZoneReader]:
         """Zones in this file, by index or slice."""
         if self._zone_list is None:
             self._zone_list = ZoneList(self._zones)
@@ -1184,6 +1228,53 @@ class TecplotDatReader(TecplotReader):
                 # _parse() applies these once _var_auxdata is allocated.
                 self._deferred_var_aux_lines.append(line)
 
+    @staticmethod
+    def _infer_ordered_point_count(tokens: _LineBuffer, active_count: int) -> int:
+        """Infer an ordered zone's point count when I/J/K are all omitted.
+
+        Peeks ahead counting numeric tokens up to the next zone/keyword boundary or end
+        of file, using the same boundary rule :meth:`_parse_zone` already uses to know
+        where a header ends and data begins, then restores the original position so the
+        real read (later, driven by the now-known count) starts from the same place.
+
+        Args:
+            tokens: Positioned at the first data line.
+            active_count: Number of active (non-passive, non-shared) variables in
+                dataset order; each data row has exactly this many values.
+
+        Returns:
+            The inferred point count.
+
+        Raises:
+            ValueError: If the total token count isn't evenly divisible by
+                *active_count*, a malformed or truncated data block.
+
+        Example:
+            >>> n = TecplotDatReader._infer_ordered_point_count(tokens, 3)
+        """
+        marker = tokens.position()
+        total = 0
+        while tokens.has_more():
+            line = tokens.peek_stripped()
+            if not line:
+                tokens.next_stripped()
+                continue
+            upper = line.lstrip().upper()
+            if upper.split("=")[0].split()[0] == "ZONE":
+                break
+            if upper.startswith(("DATASETAUXDATA", "VARAUXDATA")):
+                break
+            total += len(tokens.next_stripped().split())
+        tokens.seek(marker)
+
+        if active_count <= 0 or total % active_count != 0:
+            raise ValueError(
+                "Could not infer point count for an ordered zone with no "
+                f"I/J/K: found {total} values, not evenly divisible by "
+                f"{active_count} active variables."
+            )
+        return total // active_count
+
     def _parse_zone(self, tokens: _LineBuffer) -> None:
         """Parse one ZONE block (header + data blocks + connectivity).
 
@@ -1268,11 +1359,29 @@ class TecplotDatReader(TecplotReader):
                 "ASCII reader."
             )
 
+        # Passive/shared variables are parsed here (ahead of var_locs/var_types below,
+        # which don't need this ordering) because the point-count inference just below
+        # needs active_count first.
+        passive_set: set[int] = set()
+        if "PASSIVEVARLIST" in kv:
+            passive_set = set(_parse_index_list(kv["PASSIVEVARLIST"]))
+
+        share_map: dict[int, int] = {}
+        if "VARSHARELIST" in kv:
+            share_map = _parse_varsharelist(kv["VARSHARELIST"])
+
         if zone_type == ZoneType.ORDERED:
-            I = int(kv.get("I", "1") or "1")  # noqa E741
-            J = int(kv.get("J", "1") or "1")
-            K = int(kv.get("K", "1") or "1")
-            num_nodes = I * J * K
+            if "I" not in kv and "J" not in kv and "K" not in kv:
+                # Infer the point count from the data that follows
+                active_count = self.num_vars - len(passive_set) - len(share_map)
+                num_nodes = self._infer_ordered_point_count(tokens, active_count)
+                I = num_nodes  # noqa E741
+                J = K = 1
+            else:
+                I = int(kv.get("I", "1") or "1")  # noqa E741
+                J = int(kv.get("J", "1") or "1")
+                K = int(kv.get("K", "1") or "1")
+                num_nodes = I * J * K
             num_cells = max(I - 1, 1) * max(J - 1, 1) * max(K - 1, 1)
         else:
             # FE zones accept both the modern (NODES/ELEMENTS) and legacy (N/E)
@@ -1295,6 +1404,26 @@ class TecplotDatReader(TecplotReader):
         else:
             packing = DataPacking.BLOCK
 
+        # Face-neighbor connections (finite-element zones only; ordered zones
+        # don't need them, adjacency is already implicit in the I/J/K
+        # structure). FACENEIGHBORCONNECTIONS is authoritative for how many
+        # values to expect; FEFACENEIGHBORSCOMPLETE says whether that's the
+        # entire adjacency picture or a supplement to Tecplot's own
+        # auto-detection, read below for face_neighbors_complete.
+        declared_face_connections = 0
+        face_neighbor_mode: FaceNeighborMode | None = None
+        face_neighbors_complete: bool | None = None
+        if zone_type != ZoneType.ORDERED and "FACENEIGHBORCONNECTIONS" in kv:
+            declared_face_connections = int(kv["FACENEIGHBORCONNECTIONS"] or "0")
+            if declared_face_connections > 0:
+                mode_raw = kv.get("FACENEIGHBORMODE", "LOCALONETOONE").strip().lower()
+                face_neighbor_mode = _STR_TO_FACENEIGHBORMODE.get(
+                    mode_raw, FaceNeighborMode.LOCAL_ONE_TO_ONE
+                )
+                if "FEFACENEIGHBORSCOMPLETE" in kv:
+                    complete_raw = kv["FEFACENEIGHBORSCOMPLETE"].strip().upper()
+                    face_neighbors_complete = complete_raw == "YES"
+
         # Variable locations (0-based index → ValueLocation)
         var_locs: dict[int, ValueLocation] = {}
         if "VARLOCATION" in kv:
@@ -1312,16 +1441,6 @@ class TecplotDatReader(TecplotReader):
         else:
             var_types = [DataType.FLOAT] * len(self._variable_names)
 
-        # Passive variables (0-based)
-        passive_set: set[int] = set()
-        if "PASSIVEVARLIST" in kv:
-            passive_set = set(_parse_index_list(kv["PASSIVEVARLIST"]))
-
-        # Shared variables {0-based → 1-based source zone}
-        share_map: dict[int, int] = {}
-        if "VARSHARELIST" in kv:
-            share_map = _parse_varsharelist(kv["VARSHARELIST"])
-
         # Connectivity sharing
         con_share_zone = int(kv.get("CONNECTIVITYSHAREZONE", "0") or "0")
 
@@ -1374,6 +1493,39 @@ class TecplotDatReader(TecplotReader):
                 flat = self._read_int_block(tokens, num_cells * nodes_per_cell)
                 node_map = flat.reshape(num_cells, nodes_per_cell)
 
+        # -- Read face-neighbor connections (FE zones only, if declared) ---------------
+        #
+        # Immediately follows connectivity in the file. Values are already
+        # 1-based in ASCII (unlike PLT's binary layout, no +1 needed here).
+
+        face_connections: npt.NDArray[np.int64] | None = None
+        one_to_one = (
+            FaceNeighborMode.LOCAL_ONE_TO_ONE,
+            FaceNeighborMode.GLOBAL_ONE_TO_ONE,
+        )
+        if face_neighbor_mode in one_to_one:
+            values_per = (
+                3 if face_neighbor_mode is FaceNeighborMode.LOCAL_ONE_TO_ONE else 4
+            )
+            face_connections = self._read_int_block(
+                tokens, declared_face_connections * values_per
+            )
+        elif face_neighbor_mode is not None:
+            # "Many" modes: ragged, each record's own 4th value (nz) gives the
+            # count of additional neighbor references that follow it.
+            is_global = face_neighbor_mode is FaceNeighborMode.GLOBAL_ONE_TO_MANY
+            pieces: list[npt.NDArray] = []
+            for _ in range(declared_face_connections):
+                header = self._read_int_block(tokens, 4)
+                nz = int(header[3])
+                rest_count = 2 * nz if is_global else nz
+                rest = self._read_int_block(tokens, rest_count)
+                pieces.append(header)
+                pieces.append(rest)
+            face_connections = (
+                np.concatenate(pieces) if pieces else np.empty(0, dtype=np.int64)
+            )
+
         # -- Build ReadVariable and ReadZone objects -----------------------------------
 
         # For ordered zones, reshape each variable array from flat 1-D to (I, J, K) for
@@ -1398,7 +1550,7 @@ class TecplotDatReader(TecplotReader):
         for var_idx, src_zone_1based in share_map.items():
             if 1 <= src_zone_1based <= len(self._zones):
                 var_arrays[var_idx] = (
-                    self._zones[src_zone_1based - 1].variable[var_idx].values
+                    self._zones[src_zone_1based - 1].variables[var_idx].values
                 )
 
         # This zone's own 1-based index
@@ -1435,6 +1587,10 @@ class TecplotDatReader(TecplotReader):
                 node_map=node_map,
                 datapacking=packing,
                 shared_connectivity=con_share_zone if con_share_zone else None,
+                face_neighbor_mode=face_neighbor_mode,
+                num_face_connections=declared_face_connections or None,
+                face_connections=face_connections,
+                face_neighbors_complete=face_neighbors_complete,
             )
         )
 
@@ -1453,6 +1609,10 @@ class TecplotDatReader(TecplotReader):
         node_map: npt.NDArray[Any] | None,
         datapacking: DataPacking,
         shared_connectivity: int | None,
+        face_neighbor_mode: FaceNeighborMode | None = None,
+        num_face_connections: int | None = None,
+        face_connections: npt.NDArray[np.int64] | None = None,
+        face_neighbors_complete: bool | None = None,
     ) -> TecplotZoneReader:
         """Construct the right concrete zone reader for one parsed zone."""
         if zone_type == ZoneType.ORDERED:
@@ -1481,6 +1641,10 @@ class TecplotDatReader(TecplotReader):
             node_map=node_map,
             datapacking=datapacking,
             shared_connectivity=shared_connectivity,
+            face_neighbor_mode=face_neighbor_mode,
+            num_face_connections=num_face_connections,
+            face_connections=face_connections,
+            face_neighbors_complete=face_neighbors_complete,
         )
 
     # -- Block readers -----------------------------------------------------------------