Increment version number

Author: Jan Vogelsang

RELEASE.md

@@ -1,4 +1,6 @@
 ## Release History
+* 1.8.2
+    * Added option to mask global slice and fixed csv and slice mask bugs
 * 1.8.1
     * Lots of improvements and convenience methods for obstructions
 * 1.8.0

fdsreader/_version.py

@@ -7,5 +7,5 @@
 
 from incremental import Version
 
-__version__ = Version("fdsreader", 1, 8, 1)
+__version__ = Version("fdsreader", 1, 8, 2)
 __all__ = ["__version__"]

fdsreader/bndf/obstruction.py

@@ -1,6 +1,6 @@
 import math
 import os
-from typing import List, Dict, Tuple, Union
+from typing import List, Dict, Tuple, Union, Sequence
 from typing_extensions import Literal
 import numpy as np
 
@@ -122,7 +122,7 @@ class Boundary:
     :ivar n_t: Total number of time steps for which output data has been written.
     """
 
-    def __init__(self, quantity: Quantity, cell_centered: bool, times: np.ndarray, n_t: int, patches: List[Patch],
+    def __init__(self, quantity: Quantity, cell_centered: bool, times: Sequence[float], n_t: int, patches: List[Patch],
                  lower_bounds: np.ndarray, upper_bounds: np.ndarray):
         self.quantity = quantity
         self.cell_centered = cell_centered
@@ -215,7 +215,7 @@ def __init__(self, side_surfaces: Tuple, bound_indices: Tuple[int, int, int, int
         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,
+                     patches: List[Patch], times: Sequence[float], 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,
@@ -276,20 +276,28 @@ def _show(self, time: float):
 
     @property
     def n_t(self):
-        return next(iter(self._boundary_data.values())).n_t
+        """Returns the number of timesteps for which boundary data is available.
+        """
+        if self.has_boundary_data:
+            return next(iter(self._boundary_data.values())).n_t
+        else:
+            return 0
 
     @property
     def times(self):
-        return next(iter(self._boundary_data.values())).times
+        """Return all timesteps for which boundary data is available, if any.
+        """
+        if self.has_boundary_data:
+            return next(iter(self._boundary_data.values())).times
+        else:
+            return np.array([])
 
-    @property
-    def visible_times(self) -> np.ndarray:
-        """Returns an ndarray containing all time steps when there is data available for the SubObstruction. Will return an
-            empty list when no data is output at all.
+    def get_visible_times(self, times: Sequence[float]) -> np.ndarray:
+        """Returns an ndarray filtering all time steps when theSubObstruction is visible/not hidden.
         """
         ret = list()
         hidden = False
-        for time in self.times:
+        for time in times:
             if time in self.show_times:
                 hidden = False
             if time in self.hide_times:
@@ -375,15 +383,20 @@ def orientations(self):
 
     @property
     def n_t(self):
+        """Returns the number of timesteps for which boundary data is available.
+        """
         return next(iter(self._subobstructions.values())).n_t
 
     @property
     def times(self):
+        """Return all timesteps for which boundary data is available, if any.
+        """
         return next(iter(self._subobstructions.values())).times
 
-    @property
-    def visible_times(self):
-        return next(iter(self._subobstructions.values())).visible_times
+    def get_visible_times(self, times: Sequence[float]):
+        """Returns an ndarray filtering all time steps when theSubObstruction is visible/not hidden.
+        """
+        return next(iter(self._subobstructions.values())).get_visible_times(times)
 
     def get_coordinates(self, ignore_cell_centered: bool = False) -> Dict[
         int, Dict[Literal['x', 'y', 'z'], np.ndarray]]:
@@ -489,7 +502,7 @@ def get_boundary_data(self, quantity: Union[Quantity, str],
     def get_nearest_timestep(self, time: float, visible_only: bool = False) -> int:
         """Calculates the nearest timestep for which data has been output for this obstruction.
         """
-        times = self.visible_times if visible_only else self.times
+        times = self.get_visible_times(self.times) if visible_only else self.times
         idx = np.searchsorted(times, time, side="left")
         if time > 0 and (idx == len(times) or np.math.fabs(
                 time - times[idx - 1]) < np.math.fabs(time - times[idx])):

fdsreader/fds_classes/mesh.py

@@ -57,12 +57,12 @@ def get_obstruction_mask(self, times: Sequence[float], cell_centered=False) -> n
                 x1, x2 = subobst.bound_indices['x']
                 y1, y2 = subobst.bound_indices['y']
                 z1, z2 = subobst.bound_indices['z']
-                for t, _ in enumerate(subobst.visible_times(times)):
+                for t, _ in enumerate(subobst.get_visible_times(times)):
                     mask[t, x1:max(x2 + c, x1 + 1), y1:max(y2 + c, y1 + 1), z1:max(z2 + c, z1 + 1)] = False
         return mask
 
     def get_obstruction_mask_slice(self, subslice):
-        """Marks all cells of a single slice which are blocked by an obstruction.
+        """Marks all cells of a single subslice which are blocked by an obstruction.
 
         :returns: A 4-dimensional array with time as first and x,y,z as last dimensions. The array depends on time as
             obstructions may be hidden as specific points in time.
@@ -77,7 +77,7 @@ def get_obstruction_mask_slice(self, subslice):
         mask_indices[orientation] = slice(slc_index, slc_index + 1, 1)
         mask_indices = tuple(mask_indices)
 
-        return np.squeeze(self.get_obstruction_mask(subslice.times, cell_centered=cell_centered)[mask_indices])
+        return self.get_obstruction_mask(subslice.times, cell_centered=cell_centered)[mask_indices]
 
     def coordinate_to_index(self, coordinate: Tuple[float, ...],
                             dimension: Tuple[Literal[1, 2, 3, 'x', 'y', 'z'], ...] = ('x', 'y', 'z'),

fdsreader/simulation.py

@@ -995,6 +995,8 @@ def _load_CPU_data(self) -> Dict[str, np.ndarray]:
             with open(file_path, 'r') as infile:
                 keys = [name.replace('"', '').replace('\n', '').strip() for name in infile.readline().split(',')]
             values = np.loadtxt(file_path, delimiter=',', ndmin=2, skiprows=1)
+        else:
+            return dict()
         data = self._transform_csv_data(keys, values)
         data["Rank"] = data["Rank"].astype(int)
         return data

fdsreader/slcf/slice.py

@@ -471,9 +471,14 @@ def sort_subslices_cartesian(self):
                     slices_cart.append([slc])
         return slices_cart
 
-    def to_global(self) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
+    def to_global(self, masked: bool = False, fill: float = 0) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
         """Creates a global numpy ndarray from all subslices (only tested for 2D-slices).
             Note: This method might create a sparse np-array that consumes lots of memory.
+            Will create two global slices in cases where face-centered slices cut right through one
+            or more mesh borders.
+
+            :param masked: Whether to apply the obstruction mask to the slice or not.
+            :param fill: The fill value to use for masked slice entries. Only used when masked=True.
         """
         subslice_sets = [dict(), dict()]
 
@@ -564,6 +569,10 @@ def to_global(self) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
                     if not self.cell_centered and mesh.coordinates[dim][-1] == global_max[dim]:
                         slc_data = np.concatenate((slc_data, temp_data), axis=axis + 1)
 
+                if masked:
+                    mask = mesh.get_obstruction_mask_slice(slc)
+                    slc_data = np.where(mask, slc_data, fill)
+
                 grid[:, start_idx['x']: end_idx['x'], start_idx['y']: end_idx['y'],
                 start_idx['z']: end_idx['z']] = slc_data.reshape(
                     (self.n_t, end_idx['x'] - start_idx['x'], end_idx['y'] - start_idx['y'], end_idx['z'] - start_idx['z']))