Readers#
tecio.open() (mode 'r') returns a TecplotSzlReader,
TecplotPltReader, or TecplotDatReader based on
the file extension. All three implement the same interface, this page
documents that interface once; construct a specific class directly only if you
want to bypass the extension-based dispatch.
What each format keeps in memory#
This affects how expensive different operations are, not what you can do with the reader, the interface below is identical either way.
Format |
On open |
On first zone access |
Array access |
|---|---|---|---|
SZL |
A live C file handle pointer. |
Zone headers resolved via C TecIO function calls. |
Live C TecIO function call each time. |
PLT |
Whole header/zone-metadata section parsed eagerly with no file handle kept open. |
Output directly from metadata parsed on open. |
Read from disk on demand, using offsets recorded at open. |
DAT |
The entire file, header and every array, parsed into memory. |
Output directly from in memory data parsed at open. |
Already in memory, no further disk access. |
Opening a PLT or DAT file (however large) does one pass over the file; opening SZL does none, cost is deferred to whatever you actually touch (sub-zone loaded on demand access is preserved).
Zones and Variables: ZoneList / VariableList#
reader.zones and zone.variables return one of two format-agnostic container
types:
with tecio.open("flow.szplt") as r:
r.zones[0] # -> a zone reader (Ordered or FE, see below)
r.zones[1:4] # -> ZoneList, a sub-range, same kind
r.zones[0].variables # -> VariableList
r.zones[0].variables["x"] # -> TecplotVariableReader, by exact name
r.zones[0].variables[2] # -> TecplotVariableReader, by 0-based index
Class |
Returned by |
Supports |
|---|---|---|
|
|
|
|
|
To output NumPy arrays directly at the zone level, use get_array:
p = r.zones[0].get_array("p") # ndarray | None
p = r.zones[0].get_array(2) # by 0-based index
x, y, z = r.zones[0].get_array(["x", "y", "z"]) # tuple, for unpacking
A single key (index or name) returns one array; a list of names returns a
tuple in the order given. Returns None for a passive or shared variable
(shared resolves to the source zone’s real data automatically, None only
means “no data at all”); raises KeyError for an unknown name or
IndexError for an out-of-range index. There’s deliberately no cross-zone
accessor, to pull one variable across many zones, iterate explicitly so the
outer axis stays in your code:
seq = [z.get_array("p") for z in r.zones] # list[ndarray | None]
stack = np.stack(seq) # only once you know the shapes match
|
Read-only sequence of zones: positional access and slicing only. |
|
Read-only sequence of variables with positional and named access. |
TecplotReader#
One open file. Not constructed directly, tecio.open() returns the
concrete class for you.
|
Shared interface for all Tecplot file readers (SZL, PLT, DAT). |
Zones: TecplotZoneReader, split by topology#
Only properties that mean the same thing for every zone, regardless of
topology, live on the shared base. Dimensions and connectivity don’t: an
ordered zone has no node map, an FE zone has no I/J/K. Each lives only
on its own subclass, and accessing the wrong one raises AttributeError
rather than returning None:
zone = r.zones[0]
zone.title, zone.zone_type # always available
if isinstance(zone, tecio.TecplotOrderedZoneReader):
zone.dimensions # (I, J, K)
elif isinstance(zone, tecio.TecplotFEZoneReader):
zone.node_map # ndarray | None
elif isinstance(zone, tecio.TecplotFEMixedZoneReader):
zone.node_maps # tuple of ndarray, one per section
elif isinstance(zone, tecio.TecplotPolyZoneReader):
zone.face_nodes # ndarray
TecplotFEZoneReader covers the classic finite-element types. FEMIXED zones
are returned as TecplotFEMixedZoneReader (SZL only). FEPOLYGON and FEPOLYHEDRON
zones are returned as TecplotPolyZoneReader (PLT v111 and later, and DAT; SZL
does not yet support poly zones).
FEMIXED zones#
A FEMIXED zone holds 1 to 16 sections. Every cell in a section has the same shape, and all sections share one spatial dimension (all line, all surface or all volume cells). Cells are numbered through the sections in order, so a cell-centered variable lists the cells of the first section first. Indices are 0-based.
Property |
Meaning |
|---|---|
|
Number of sections |
|
|
|
Cells in each section |
|
One |
|
As for |
zone = r.zones[0]
for shape, node_map in zip(zone.section_shapes, zone.node_maps):
print(shape.name, node_map.shape)
Only linear sections (grid order 1) are supported, and face-neighbor connections are not read for FEMIXED zones.
Poly zones#
Face arrays are returned as stored on disk, 0-based:
Property |
Meaning |
|---|---|
|
Nodes per face (all |
|
|
|
Flat 0-based node indices of every face |
|
0-based element per face; |
|
Connections per boundary face |
|
0-based elements in other zones or with several neighbors |
|
0-based zone of each connection |
The boundary arrays are empty when the zone has no boundary faces.
num_nodes, num_elements, num_faces, num_boundary_faces,
num_boundary_connections and shared_connectivity are also available. The
left and right elements cover face neighbors, so poly zones have no separate
face-neighbor connections.
|
Read-only handle to one zone's metadata in an open Tecplot file. |
|
Read-only handle to one ORDERED (IJK-structured) zone. |
|
Read-only handle to one finite-element zone. |
|
Read-only handle to one FEMIXED (mixed finite-element) zone. |
|
Read-only handle to one FEPOLYGON or FEPOLYHEDRON (face-based) zone. |
TecplotVariableReader#
One variable’s metadata and data within a zone. Not split by value location
(nodal vs. cell-centered) or by the owning zone’s topology, neither removes
a property, both only change the shape get_values()/values returns,
already computed for you from value_location and the owning zone.
Read-only handle to one variable's metadata and data within a zone. |
Every concrete variable reader also carries a real, working var_index
(0-based, same convention as zone_index), not currently promoted to this
shared base class the way zone_index was for zones, so it’s absent from
the generated page above and doesn’t type-check against code written against
this abstract interface, but it’s there and correct at runtime, since
zone.variables[i] always returns a concrete instance. See API Reference.
TecplotAuxDataReader#
A read-only, dict-like view of one auxiliary-data mapping, dataset-, zone-,
or variable-level, same class for all three and every format. Implements
collections.abc.Mapping, so get, keys, values, items, in,
and len() all work as expected, plus typed convenience accessors:
Read-only view of one Tecplot auxiliary-data mapping. |
Format-specific classes#
Constructor and a handful of format quirks; everything else is the shared interface above.
|
Reader for Tecplot |
|
Reader for Tecplot |
|
Reader for Tecplot ASCII DAT files. |
Added in version 0.4.0: Read only TecplotPltReader support for several legacy PLT binary versions
(v7.5, v10.7, v11.1). Note that v7.5 PLT files have no fields for passive
variables, strand/ solution-time, cell-centered data, or auxilary data. See
Legacy PLT Versions for the full version-by-version comparison.