fdsreader 1.2.0rc2__tar.gz → 1.3.7__tar.gz

{fdsreader-1.2.0rc2/fdsreader.egg-info → fdsreader-1.3.7}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: fdsreader
-Version: 1.2.0rc2
+Version: 1.3.7
 Summary: Python reader for data generated by FDS.
-Home-page: https://github.com/JanVogelsang/fdsreader
+Home-page: https://github.com/FireDynamics/fdsreader
 Author: FZJ IAS-7 (Prof. Dr. Lukas Arnold, Jan Vogelsang)
 Author-email: j.vogelsang@fz-juelich.de
 License: UNKNOWN

{fdsreader-1.2.0rc2 → fdsreader-1.3.7}/fdsreader/_version.py

@@ -7,5 +7,5 @@ Provides fdsreader version information.
 
 from incremental import Version
 
-__version__ = Version('fdsreader', 1, 2, 0, release_candidate=2)
+__version__ = Version('fdsreader', 1, 3, 7)
 __all__ = ["__version__"]

{fdsreader-1.2.0rc2 → fdsreader-1.3.7}/fdsreader/bndf/obstruction.py

@@ -3,7 +3,7 @@ from typing import List, Dict, Tuple, Union, Sequence
 from typing_extensions import Literal
 import numpy as np
 
-from fdsreader.utils import Surface, Extent, Quantity, Dimension
+from fdsreader.utils import Extent, Quantity, Dimension
 import fdsreader.utils.fortran_data as fdtype
 from fdsreader import settings
 
@@ -149,12 +149,12 @@ class SubObstruction:
 
     :ivar extent: :class:`Extent` object containing 3-dimensional extent information.
     :ivar bound_indices: Indices used to define obstruction bounds in terms of mesh locations.
-    :ivar side_surfaces: Tuple of six surfaces for each side of the cuboid.
+    :ivar side_surfaces: Tuple of six :class:`Surface` s for each side of the cuboid.
     :ivar hide_times: List with points in time from when on the SubObstruction will be hidden.
     :ivar show_times: List with points in time from when on the SubObstruction will be shown.
     """
 
-    def __init__(self, side_surfaces: Tuple[Surface, ...], bound_indices: Tuple[int, int, int, int, int, int],
+    def __init__(self, side_surfaces: Tuple, bound_indices: Tuple[int, int, int, int, int, int],
                  extent: Extent):
         self.extent = extent
         self.side_surfaces = side_surfaces
@@ -167,15 +167,20 @@ class SubObstruction:
         self.hide_times = list()
         self.show_times = list()
 
-    def _add_patches(self, bid: int, cell_centered: bool, quantity: str, short_name: str, unit: str, patches: List[Patch],
-                     times: np.ndarray, n_t: int, lower_bounds: np.ndarray, upper_bounds: np.ndarray):
+    def _add_patches(self, bid: int, cell_centered: bool, quantity: str, short_name: str, unit: str,
+                     patches: List[Patch], times: np.ndarray, n_t: int, lower_bounds: np.ndarray,
+                     upper_bounds: np.ndarray):
         if bid not in self._boundary_data:
-            self._boundary_data[bid] = Boundary(Quantity(quantity, short_name, unit), cell_centered, times, n_t, patches,
-                                                lower_bounds, upper_bounds)
+            self._boundary_data[bid] = Boundary(Quantity(quantity, short_name, unit), cell_centered, times, n_t,
+                                                patches, lower_bounds, upper_bounds)
 
         if not settings.LAZY_LOAD:
             _ = self._boundary_data[bid].data
 
+    @property
+    def has_boundary_data(self):
+        return len(self._boundary_data) != 0
+
     def get_data(self, quantity: Union[str, Quantity]):
         if type(quantity) == Quantity:
             quantity = quantity.name
@@ -303,7 +308,7 @@ class Obstruction:
         if type(quantity) == Quantity:
             quantity = quantity.name
 
-        ret = [subobst.get_data(quantity) for subobst in self._subobstructions]
+        ret = [subobst.get_data(quantity) for subobst in self._subobstructions if subobst.has_boundary_data]
         if orientation == 0:
             return ret
         return [bndf for bndf in ret if orientation in bndf.data.keys()]
@@ -312,7 +317,7 @@ class Obstruction:
     def has_boundary_data(self):
         """Whether boundary data has been output in the simulation.
         """
-        return len(self._subobstructions[0]._boundary_data) != 0
+        return any(subobst.has_boundary_data for subobst in self._subobstructions)
 
     def clear_cache(self):
         """Remove all data from the internal cache that has been loaded so far to free memory.

{fdsreader-1.2.0rc2 → fdsreader-1.3.7}/fdsreader/evac/EvacCollection.py

@@ -4,15 +4,15 @@ from typing import Iterable, Dict, List, Union
 import numpy as np
 
 from fdsreader.evac import Evacuation
-from fdsreader.utils import Mesh
+from fdsreader.fds_classes import Mesh
 from fdsreader.utils.data import FDSDataCollection, Quantity
 import fdsreader.utils.fortran_data as fdtype
 from fdsreader import settings
 
 
 class EvacCollection(FDSDataCollection):
-    """Collection of :class:`Plot3D` objects. Offers extensive functionality for filtering and
-        using plot3Ds as well as its subclasses such as :class:`SubPlot3D`.
+    """Collection of :class:`Evacuation` objects. Next to agent-class specific data (such as trajectories) lots of
+        other data such as FED-data is provided via this class.
 
         :ivar times: List of all time steps of the simulation.
         :ivar z_offsets: The offset in z-direction for each mesh where the evac plane lays.
@@ -92,8 +92,8 @@ class EvacCollection(FDSDataCollection):
                                          units[i] == "TargetDoorCounter"}
 
     @property
-    def xyz(self) -> np.ndarray:
-        """
+    def xyz(self) -> List[np.ndarray]:
+        """List of xyz-data for each mesh.
         """
         if not hasattr(self, "_xyz"):
             self._load_xyz_data()
@@ -121,18 +121,26 @@ class EvacCollection(FDSDataCollection):
             n_corrs = meta[2]
             n_devc = fdtype.read(infile, fdtype.INT, 1)[0][0][0]
 
-            n_i, n_j, n_k, n = fdtype.read(infile, dtype_grid_meta, 1)[0][0]  # n_k will always be 1
+            n_i = list()
+            n_j = list()
+            for g in range(n_grids):
+                n_i_g, n_j_g, _, _ = fdtype.read(infile, dtype_grid_meta, 1)[0][0]
+                n_i.append(n_i_g)
+                n_j.append(n_j_g)
+                for i in range(n_i_g):
+                    for j in range(n_j_g):
+                        _ = fdtype.read(infile, dtype_grid_data, 1)
 
             # Reset pointer (after file header)
             infile.seek(fdtype.INT.itemsize * 2 + dtype_meta.itemsize)
 
-            self._xyz = np.empty((n_grids, n_i, n_j, 3))
+            self._xyz = [np.empty((n_i[g], n_j[g], 3)) for g in range(n_grids)]
 
             for g in range(n_grids):
                 infile.seek(dtype_grid_meta.itemsize, 1)
-                for i in range(n_i):
-                    for j in range(n_j):
-                        self._xyz[g, i, j] = fdtype.read(infile, dtype_grid_data, 1)[0][0]
+                for i in range(n_i[g]):
+                    for j in range(n_j[g]):
+                        self._xyz[g][i, j] = fdtype.read(infile, dtype_grid_data, 1)[0][0]
 
         if os.path.exists(self._base_path + ".fed"):
             self._load_fed_data(n_corrs)
@@ -183,6 +191,9 @@ class EvacCollection(FDSDataCollection):
             dtype_meta = fdtype.new((('i', 6),))
             dtype_time = fdtype.new((('f', 2),))
             dtype_grid_meta = fdtype.new((('i', 4),))
+            dtype_corr = fdtype.new((('f', 8),))
+            dtype_devs_meta = fdtype.new((('i', 2),))
+            dtype_devs_data = fdtype.new((('i', 1), ('f', 1), ('i', 2), ('f', 1)))
 
             # File header
             file_format = fdtype.read(infile, fdtype.INT, 1)[0][0][0]
@@ -195,26 +206,35 @@ class EvacCollection(FDSDataCollection):
 
             # Read gridsize from first timestep header
             infile.seek(dtype_time.itemsize, 1)
-            n_i, n_j, n_k, n = fdtype.read(infile, dtype_grid_meta, 1)[0][0]  # n_k will always be 1
+
+            n_i = list()
+            n_j = list()
+            n = list()
+            dtype_grid_data = list()
+            for g in range(n_grids):
+                n_i_g, n_j_g, _, n_g = fdtype.read(infile, dtype_grid_meta, 1)[0][0]
+                n_i.append(n_i_g)
+                n_j.append(n_j_g)
+                n.append(n_g)
+                dtype_grid_data.append(fdtype.new((('f', n_g),)))
+                for i in range(n_i_g):
+                    for j in range(n_j_g):
+                        _ = fdtype.read(infile, dtype_grid_data[-1], 1)
 
             # Reset pointer (after file header)
             infile.seek(dtype_meta.itemsize + fdtype.INT.itemsize * 2)
 
-            dtype_grid_data = fdtype.new((('f', n),))
-            dtype_corr = fdtype.new((('f', 8),))
-            dtype_devs_meta = fdtype.new((('i', 2),))
-            dtype_devs_data = fdtype.new((('i', 1), ('f', 1), ('i', 2), ('f', 1)))
-
-            n_t = (os.stat(file_path).st_size - (fdtype.INT.itemsize * 2 + dtype_meta.itemsize)) // \
-                  (dtype_time.itemsize + n_grids * (dtype_grid_meta.itemsize + n_i * n_j * dtype_grid_data.itemsize) +
-                   n_corrs * dtype_corr.itemsize + fdtype.FLOAT.itemsize + n_devc * (
-                           dtype_devs_meta.itemsize + dtype_devs_data.itemsize))
+            n_t = (os.stat(file_path).st_size - (fdtype.INT.itemsize * 2 + dtype_meta.itemsize)) // (
+                        dtype_time.itemsize + sum(
+                    (dtype_grid_meta.itemsize + n_i[g] * n_j[g] * dtype_grid_data[g].itemsize) for g in
+                    range(n_grids)) + n_corrs * dtype_corr.itemsize + fdtype.FLOAT.itemsize + n_devc * (
+                                    dtype_devs_meta.itemsize + dtype_devs_data.itemsize))
 
             times = list()
-            self._fed_grid = dict(co_co2_o2=[np.empty((n_t, n_i, n_j)) for _ in range(n_grids)],
-                                  soot_dens=[np.empty((n_t, n_i, n_j)) for _ in range(n_grids)],
-                                  tmp_g=[np.empty((n_t, n_i, n_j)) for _ in range(n_grids)],
-                                  radflux=[np.empty((n_t, n_i, n_j)) for _ in range(n_grids)])
+            self._fed_grid = dict(co_co2_o2=[np.empty((n_t, n_i[g], n_j[g])) for g in range(n_grids)],
+                                  soot_dens=[np.empty((n_t, n_i[g], n_j[g])) for g in range(n_grids)],
+                                  tmp_g=[np.empty((n_t, n_i[g], n_j[g])) for g in range(n_grids)],
+                                  radflux=[np.empty((n_t, n_i[g], n_j[g])) for g in range(n_grids)])
             self._fed_corr = dict(co_co2_o2=[np.empty((n_t, 2)) for _ in range(n_corrs)],
                                   soot_dens=[np.empty((n_t, 2)) for _ in range(n_corrs)],
                                   tmp_g=[np.empty((n_t, 2)) for _ in range(n_corrs)],
@@ -229,9 +249,9 @@ class EvacCollection(FDSDataCollection):
 
                 for g in range(n_grids):
                     infile.seek(dtype_grid_meta.itemsize, 1)
-                    for i in range(n_i):
-                        for j in range(n_j):
-                            co_co2_o2, soot_dens, tmp_g, radflux = fdtype.read(infile, dtype_grid_data, 1)[0][0][:4]
+                    for i in range(n_i[g]):
+                        for j in range(n_j[g]):
+                            co_co2_o2, soot_dens, tmp_g, radflux = fdtype.read(infile, dtype_grid_data[g], 1)[0][0][:4]
                             self._fed_grid["co_co2_o2"][g][t, i, j] = co_co2_o2
                             self._fed_grid["soot_dens"][g][t, i, j] = soot_dens
                             self._fed_grid["tmp_g"][g][t, i, j] = tmp_g
@@ -267,29 +287,34 @@ class EvacCollection(FDSDataCollection):
     def _load_eff_data(self):
         file_path = self._base_path + ".eff"
         if not os.path.exists(file_path):
+            self._eff = None
             return
 
         with open(file_path, 'rb') as infile:
             dtype_grid_meta = fdtype.new((('i', 3),))
-            dtype_grid_data = fdtype.new((('f', 2),))
+            dtype_grid_data = fdtype.new((('f', 2),))  # u, v
 
             n_grids = fdtype.read(infile, fdtype.INT, 1)[0][0][0]
 
-            n_i, n_j, n_k = fdtype.read(infile, dtype_grid_meta, 1)[0][0]  # n_k will always be 1
-
-            # Reset pointer (after file header)
-            infile.seek(fdtype.INT.itemsize)
-
-            n_fields = (os.stat(file_path).st_size - fdtype.INT.itemsize) // (
-                    n_grids * (dtype_grid_meta.itemsize + n_i * n_j * dtype_grid_data.itemsize))
-
-            self._eff = np.empty((n_grids, n_fields, n_i, n_j, 2))
-            for g in range(n_grids):
-                for f in range(n_fields):
-                    infile.seek(dtype_grid_meta.itemsize, 1)
-                    for i in range(n_i):
-                        for j in range(n_j):
-                            self._eff[g, f, i, j] = fdtype.read(infile, dtype_grid_data, 1)[0][0]
+            # n_fields = (os.stat(file_path).st_size - fdtype.INT.itemsize) // (
+            #         sum(dtype_grid_meta.itemsize + n_i[g] * n_j[g] * dtype_grid_data.itemsize for g in range(n_grids)))
+            #
+            # self._eff = np.empty((n_grids, n_fields, n_i, n_j, 2))
+            # for g in range(n_grids):
+            #     for f in range(n_fields):
+            #         infile.seek(dtype_grid_meta.itemsize, 1)
+            #         for i in range(n_i[g]):
+            #             for j in range(n_j[g]):
+            #                 self._eff[g, f, i, j] = fdtype.read(infile, dtype_grid_data, 1)[0][0]
+
+            self._eff = list()
+            meta = fdtype.read(infile, dtype_grid_meta, 1)
+            while len(meta) > 0:
+                n_i, n_j, _ = meta[0][0]
+                for i in range(n_i + 2):
+                    for j in range(n_j + 2):
+                        self._eff.append(fdtype.read(infile, dtype_grid_data, 1)[0][0])
+                meta = fdtype.read(infile, dtype_grid_meta, 1)
 
     def get_unfiltered_positions(self, quantity: Union[Quantity, str] = None):
         """Convenience function that combines all trajectories into a single array.
@@ -357,7 +382,10 @@ class EvacCollection(FDSDataCollection):
                     for quantity in evac.quantities:
                         evac._data[quantity.name].append(np.empty((size,), dtype=np.float32))
                     evac._positions.append(np.empty((size, 3), dtype=np.float32))
-                    evac._ap.append(np.empty((size, 4), dtype=np.float32))
+                    evac._body_angles.append(np.empty((size,), dtype=np.float32))
+                    evac._semi_major_axis.append(np.empty((size,), dtype=np.float32))
+                    evac._semi_minor_axis.append(np.empty((size,), dtype=np.float32))
+                    evac._agent_heights.append(np.empty((size,), dtype=np.float32))
                     evac._tags.append(np.empty((size,), dtype=int))
 
         for mesh, file_path in self._file_paths.items():
@@ -385,8 +413,10 @@ class EvacCollection(FDSDataCollection):
                         pos = fdtype.read(infile, dtype_positions, 1)[0][0].reshape((n_humans, 7),
                                                                                     order='F').astype(float)
                         evac._positions[t][offset: offset + n_humans] = pos[:, :3]
-                        # Todo: What might this be for?
-                        evac._ap[t][offset: offset + n_humans] = pos[:, 3:]
+                        evac._body_angles[t][offset: offset + n_humans] = pos[:, 3]
+                        evac._semi_major_axis[t][offset: offset + n_humans] = pos[:, 4]
+                        evac._semi_minor_axis[t][offset: offset + n_humans] = pos[:, 5]
+                        evac._agent_heights[t][offset: offset + n_humans] = pos[:, 6]
                         # Read tags
                         dtype_tags = fdtype.new((('i', n_humans),))
                         evac._tags[t][offset: offset + n_humans] = fdtype.read(infile, dtype_tags, 1)[0][0]

{fdsreader-1.2.0rc2 → fdsreader-1.3.7}/fdsreader/evac/evacuation.py

@@ -2,7 +2,8 @@ from typing import List, Tuple, Dict, Sequence, Union
 
 import numpy as np
 
-from fdsreader.utils import Quantity, Mesh, Extent
+from fdsreader.fds_classes import Mesh
+from fdsreader.utils import Quantity
 
 
 # class Entrance:
@@ -54,7 +55,10 @@ class Evacuation:
         self.n_humans: Dict[Mesh, List[int]] = dict()
 
         self._positions: List[np.ndarray] = list()
-        self._ap: List[np.ndarray] = list()
+        self._body_angles: List[np.ndarray] = list()
+        self._semi_major_axis: List[np.ndarray] = list()
+        self._semi_minor_axis: List[np.ndarray] = list()
+        self._agent_heights: List[np.ndarray] = list()
         self._tags: List[np.ndarray] = list()
         self._data: Dict[str, List[np.ndarray]] = {q.name: [] for q in self.quantities}
         self.times: Sequence[float] = list()
@@ -62,7 +66,7 @@ class Evacuation:
         self.lower_bounds = {q.name: [] for q in self.quantities}
         self.upper_bounds = {q.name: [] for q in self.quantities}
 
-        self._init_callback = None
+        self._init_callback = lambda: None
 
     @property
     def id(self):
@@ -146,12 +150,36 @@ class Evacuation:
         return self._positions
 
     @property
-    def ap(self) -> List[np.ndarray]:
+    def body_angles(self) -> List[np.ndarray]:
         """
         """
         if len(self._positions) == 0 and len(self._tags) == 0:
             self._init_callback()
-        return self._ap
+        return self._body_angles
+
+    @property
+    def semi_major_axis(self) -> List[np.ndarray]:
+        """
+        """
+        if len(self._positions) == 0 and len(self._tags) == 0:
+            self._init_callback()
+        return self._semi_major_axis
+
+    @property
+    def semi_minor_axis(self) -> List[np.ndarray]:
+        """
+        """
+        if len(self._positions) == 0 and len(self._tags) == 0:
+            self._init_callback()
+        return self._semi_minor_axis
+
+    @property
+    def agent_heights(self) -> List[np.ndarray]:
+        """
+        """
+        if len(self._positions) == 0 and len(self._tags) == 0:
+            self._init_callback()
+        return self._agent_heights
 
     def clear_cache(self):
         """Remove all data from the internal cache that has been loaded so far to free memory.

fdsreader-1.3.7/fdsreader/export/__init__.py

@@ -0,0 +1,3 @@
+from .smoke3d_exporter import export_smoke_raw
+from .slcf_exporter import export_slcf_raw
+from .obst_exporter import export_obst_raw

fdsreader-1.3.7/fdsreader/export/obst_exporter.py

@@ -0,0 +1,116 @@
+import os
+from pathlib import Path
+import numpy as np
+from typing_extensions import Literal
+from ..bndf import Obstruction
+from ..bndf.utils import sort_patches_cartesian
+
+
+def export_obst_raw(obst: Obstruction, output_dir: str, ordering: Literal['C', 'F'] = 'C'):
+    """Exports the 3d arrays to raw binary files with corresponding .yaml meta files.
+
+    :param smoke3d: The :class:`Smoke3D` object to export.
+    :param output_dir: The directory in which to save all files.
+    :param ordering: Whether to write the data in C or Fortran ordering.
+    """
+    from pathos.pools import ProcessPool as Pool
+    from multiprocess import Lock, Manager
+    filename_base = "obst-" + str(obst.id)
+    # Create all requested directories if they don't exist yet
+    Path(os.path.join(output_dir, filename_base + "-data")).mkdir(parents=True, exist_ok=True)
+
+    meta = {"BoundingBox": obst.bounding_box.as_list(), "QuantityNum": len(obst.quantities)}
+    m = Manager()
+    lock = m.Lock()
+    meta["Quantities"] = m.list()
+
+    def worker(quantity, bndf_data):
+        quantity_name = quantity.name.replace(" ", "_").replace(".", "-")
+        filename = filename_base + "_quantity-" + quantity_name + ".dat"
+
+        out = {"Quantity": quantity.name.replace(" ", "_").replace(".", "-"), "DataValMax": -100000.,
+               "DataValMin": 100000., "ScaleFactor": 1, "DataFile": os.path.join(filename_base + "-data", filename),
+               "Orientations": list()}
+        for bndf in bndf_data:
+            out["DataValMax"] = max(out["DataValMax"], np.max(bndf.upper_bounds))
+            out["DataValMin"] = min(out["DataValMin"], np.min(bndf.lower_bounds))
+        out["DataValMax"] = float(out["DataValMax"])
+        out["DataValMin"] = float(out["DataValMin"])
+        out["ScaleFactor"] = 255.0 / out["DataValMax"]
+
+        # Abort if no useful data is available
+        if meta[quantity]["DataValMax"] <= 0:
+            return
+
+        with open(os.path.join(output_dir, quantity_name, filename_base + "-data", filename), 'wb') as rawfile:
+            orientations = set()
+            for orientation in (-3, -2, -1, 1, 2, 3):
+                patches = list()
+                for bndf in bndf_data:
+                    if orientation in bndf.data:
+                        orientations.add(orientation)
+                        patches.append(bndf.data[orientation])
+
+                if len(patches) == 0:
+                    continue
+
+                # Combine patches to a single face for plotting
+                patches = sort_patches_cartesian(patches)
+
+                shape_dim1 = sum([patch_row[0].shape[0] for patch_row in patches])
+                shape_dim2 = sum([patch.shape[1] for patch in patches[0]])
+                n_t = patches[0][0].n_t  # Number of timesteps
+
+                face = np.empty(shape=(n_t, shape_dim1, shape_dim2))
+                dim1_pos = 0
+                dim2_pos = 0
+                for patch_row in patches:
+                    d1 = patch_row[0].shape[0]
+                    for patch in patch_row:
+                        d2 = patch.shape[1]
+                        face[:, dim1_pos:dim1_pos + d1, dim2_pos:dim2_pos + d2] = patch.data
+                        dim2_pos += d2
+                    dim1_pos += d1
+                    dim2_pos = 0
+
+                face = (face * meta["ScaleFactor"]).astype(np.uint8)
+
+                if abs(orientation) == 1:
+                    spacing1 = (meta["BoundingBox"][3] - meta["BoundingBox"][2]) / face.shape[1]
+                    spacing2 = (meta["BoundingBox"][5] - meta["BoundingBox"][4]) / face.shape[2]
+                elif abs(orientation) == 2:
+                    spacing1 = (meta["BoundingBox"][1] - meta["BoundingBox"][0]) / face.shape[0]
+                    spacing2 = (meta["BoundingBox"][5] - meta["BoundingBox"][4]) / face.shape[2]
+                else:
+                    spacing1 = (meta["BoundingBox"][1] - meta["BoundingBox"][0]) / face.shape[0]
+                    spacing2 = (meta["BoundingBox"][3] - meta["BoundingBox"][2]) / face.shape[1]
+
+
+                out["Orientations"].append({
+                    "Orientation": orientation,
+                    "MeshPos": f"{meta['BoundingBox'][0]:.6} {meta['BoundingBox'][2]:.6} {meta['BoundingBox'][4]:.6}",
+                    "Spacing": f"{bndf_data[0].times[1] - bndf_data[0].times[0]:.6} {spacing1:.6} {spacing2:.6}",
+                    "DimSize": f"{face.shape[2]} {face.shape[1]} {face.shape[2]}"
+                })
+
+                for d in face[:, [2, 0, 1]]:  # Make time the first dimension so we can easily iterate over it
+                    if ordering == 'F':
+                        d = d.T
+                    d.tofile(rawfile)
+
+            out["NumOrientations"] = len(orientations)
+
+        with lock:
+            meta["Quantities"].append(out)
+
+    worker_args = list()
+    for i, quantity in enumerate(obst.quantities):
+        bndf_data = obst.get_boundary_data(quantity)
+        worker_args.append((quantity, bndf_data))
+    Pool(8).map(lambda args: worker(*args), worker_args)
+
+    meta["Quantities"] = list(meta["Quantities"])
+
+    with open(os.path.join(output_dir, filename_base + ".yaml"), 'w') as metafile:
+        import yaml
+    yaml.dump(meta, metafile)

fdsreader-1.3.7/fdsreader/export/slcf_exporter.py

@@ -0,0 +1,63 @@
+import os
+from pathlib import Path
+import numpy as np
+from typing_extensions import Literal
+from ..slcf import Slice
+
+
+def export_slcf_raw(slc: Slice, output_dir: str, ordering: Literal['C', 'F'] = 'C'):
+    """Exports the 3d arrays to raw binary files with corresponding .yaml meta files.
+
+    :param slc: The :class:`Slice` object to export.
+    :param output_dir: The directory in which to save all files.
+    :param ordering: Whether to write the data in C or Fortran ordering.
+    """
+    from pathos.pools import ProcessPool as Pool
+    from multiprocess import Lock, Manager
+    slc2d = slc.type == '2D'
+    meta = {"DataValMax": float(slc.vmax), "DataValMin": float(slc.vmin), "ScaleFactor": 255. / (float(slc.vmax) - float(slc.vmin)),
+            "MeshNum": len(slc.subslices), "Quantity": slc.quantity.name}
+
+    filename_base = ("slice" + ("2D-" if slc2d else "3D-") + slc.id.lower()).replace(" ", "_").replace(".", "-")
+    # Create all requested directories if they don't exist yet
+    Path(os.path.join(output_dir, filename_base + "-data")).mkdir(parents=True, exist_ok=True)
+
+    m = Manager()
+    meta["Meshes"] = m.list()
+    lock = m.Lock()
+
+    def worker(mesh, subslice):
+        mesh_id = mesh.id.replace(" ", "_").replace(".", "-")
+        filename = filename_base + "_mesh-" + mesh_id + ".dat"
+
+        data = ((subslice.data - meta["DataValMin"]) * meta["ScaleFactor"]).astype(np.uint8)
+        shape = data.shape
+        if slc2d:
+            shape = shape[:subslice.orientation] + (1,) + shape[subslice.orientation:]
+
+        with open(os.path.join(output_dir, filename_base + "-data", filename), 'wb') as rawfile:
+            for d in data:
+                if ordering == 'F':
+                    d = d.T
+                d.tofile(rawfile)
+
+        spacing = [slc.times[1] - slc.times[0],
+                   mesh.coordinates['x'][1] - mesh.coordinates['x'][0],
+                   mesh.coordinates['y'][1] - mesh.coordinates['y'][0],
+                   mesh.coordinates['z'][1] - mesh.coordinates['z'][0]]
+        with lock:
+            meta["Meshes"].append({
+                "Mesh": mesh_id,
+                "DataFile": os.path.join(filename_base + "-data", filename),
+                "MeshPos": f"{mesh.coordinates['x'][0]:.6} {mesh.coordinates['y'][0]:.6} {mesh.coordinates['z'][0]:.6}",
+                "Spacing": f"{spacing[0]:.6} {spacing[1]:.6} {spacing[2]:.6} {spacing[3]:.6}",
+                "DimSize": f"{shape[0]} {shape[1]} {shape[2]} {shape[3]}"
+            })
+
+    Pool(8).map(lambda args: worker(*args), list(slc._subslices.items()))
+
+    meta["Meshes"] = list(meta["Meshes"])
+
+    with open(os.path.join(output_dir, filename_base + ".yaml"), 'w') as metafile:
+        import yaml
+        yaml.dump(meta, metafile)

fdsreader-1.3.7/fdsreader/export/smoke3d_exporter.py

@@ -0,0 +1,70 @@
+import os
+from pathlib import Path
+import numpy as np
+from typing_extensions import Literal
+from ..smoke3d import Smoke3D
+
+
+def export_smoke_raw(smoke3d: Smoke3D, output_dir: str, ordering: Literal['C', 'F'] = 'C'):
+    """Exports the 3d arrays to raw binary files with corresponding .yaml meta files.
+
+    :param smoke3d: The :class:`Smoke3D` object to export.
+    :param output_dir: The directory in which to save all files.
+    :param ordering: Whether to write the data in C or Fortran ordering.
+    """
+    from pathos.pools import ProcessPool as Pool
+    from multiprocess import Lock, Manager
+    filename_base = ("smoke-" + smoke3d.quantity.name.lower()).replace(" ", "_").replace(".", "-")
+    # Create all requested directories if they don't exist yet
+    Path(os.path.join(output_dir, filename_base + "-data")).mkdir(parents=True, exist_ok=True)
+
+    meta = {"DataValMax": -100000., "DataValMin": 100000., "ScaleFactor": 1, "MeshNum": len(smoke3d.subsmokes),
+            "Quantity": smoke3d.quantity.name}
+
+    for subsmoke in smoke3d._subsmokes.values():
+        meta["DataValMax"] = max(meta["DataValMax"], np.max(subsmoke.data))
+        meta["DataValMin"] = min(meta["DataValMin"], np.min(subsmoke.data))
+    meta["DataValMax"] = float(meta["DataValMax"])
+    meta["DataValMin"] = float(meta["DataValMin"])
+    meta["ScaleFactor"] = 255.0 / meta["DataValMax"]
+
+    # Abort if no useful data is available
+    if meta["DataValMax"] <= 0:
+        return
+
+    m = Manager()
+    meta["Meshes"] = m.list()
+    lock = m.Lock()
+
+    def worker(mesh, subsmoke):
+        mesh_id = mesh.id.replace(" ", "_").replace(".", "-")
+        filename = filename_base + "_mesh-" + mesh_id + ".dat"
+
+        data = (subsmoke.data * meta["ScaleFactor"]).astype(np.uint8)
+
+        with open(os.path.join(output_dir, filename_base + "-data", filename), 'wb') as rawfile:
+            for d in data:
+                if ordering == 'F':
+                    d = d.T
+                d.tofile(rawfile)
+
+        spacing = [smoke3d.times[1] - smoke3d.times[0],
+                   mesh.coordinates['x'][1] - mesh.coordinates['x'][0],
+                   mesh.coordinates['y'][1] - mesh.coordinates['y'][0],
+                   mesh.coordinates['z'][1] - mesh.coordinates['z'][0]]
+        with lock:
+            meta["Meshes"].append({
+                "Mesh": mesh_id,
+                "DataFile": os.path.join(filename_base + "-data", filename),
+                "MeshPos": f"{mesh.coordinates['x'][0]:.6} {mesh.coordinates['y'][0]:.6} {mesh.coordinates['z'][0]:.6}",
+                "Spacing": f"{spacing[0]:.6} {spacing[1]:.6} {spacing[2]:.6} {spacing[3]:.6}",
+                "DimSize": f"{data.shape[0]} {data.shape[1]} {data.shape[2]} {data.shape[3]}"
+            })
+
+    Pool(8).map(lambda args: worker(*args), list(smoke3d._subsmokes.items()))
+
+    meta["Meshes"] = list(meta["Meshes"])
+
+    with open(os.path.join(output_dir, filename_base + ".yaml"), 'w') as metafile:
+        import yaml
+        yaml.dump(meta, metafile)

{fdsreader-1.2.0rc2/fdsreader/utils → fdsreader-1.3.7/fdsreader}/fds_classes/MeshCollection.py

@@ -1,6 +1,6 @@
 from typing import Iterable
 
-from fdsreader.utils import Mesh
+from fdsreader.fds_classes import Mesh
 from fdsreader.utils.data import FDSDataCollection