fdsreader 1.9.13__tar.gz → 1.10.0__tar.gz

{fdsreader-1.9.13 → fdsreader-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdsreader
-Version: 1.9.13
+Version: 1.10.0
 Summary: Python reader for data generated by FDS.
 Home-page: https://github.com/FireDynamics/fdsreader
 Author: FZJ IAS-7 (Jan Vogelsang, Prof. Dr. Lukas Arnold, Tristan Hehnen)

{fdsreader-1.9.13 → fdsreader-1.10.0}/RELEASE.md

@@ -1,4 +1,9 @@
 ## Release History
+* 1.10.0
+    * Restructured Plot3D data to now be represented by a single Plot3D instance for all timesteps instead of one individual object per timestep
+    * Added a to_global function for Plot3D data
+    * Added a to_global function for Smoke3D data
+    * Fixed bugs and typos in documentation
 * 1.9.13
     * Fixed slice.to_global for 3D slices
 * 1.9.12

fdsreader-1.10.0/examples/pl3d/pl3d_example.py

@@ -0,0 +1,37 @@
+import pyvista as pv
+import numpy as np
+import fdsreader as fds
+
+
+def main():
+    sim = fds.Simulation("./fds_data")
+
+    # Load temperature 3D data
+    quantity = "Temperature"
+    pl_t1 = sim.data_3d.get_by_quantity(quantity)
+    data, coordinates = pl_t1.to_global(masked=True, return_coordinates=True, fill=np.nan)
+
+    # Select the last available timestep
+    t = -1
+
+    # Create 3D grid
+    x_ = np.linspace(coordinates['x'][0], coordinates['x'][-1], len(coordinates['x']))
+    y_ = np.linspace(coordinates['y'][0], coordinates['y'][-1], len(coordinates['y']))  # y_ = np.array([29])  # when using a slice
+    z_ = np.linspace(coordinates['z'][0], coordinates['z'][-1], len(coordinates['z']))
+    x, y, z = np.meshgrid(x_, y_, z_, indexing='ij')
+    points = np.stack((x.flatten(), y.flatten(), z.flatten()), axis=1)
+
+    color_data = data[t, :, :, :]
+    # It is also possible to just plot a slice
+    # color_data = pl_t1[mesh].data[t, :, 29:30, :]
+
+    # Plot 3D data
+    plotter = pv.Plotter()
+    plotter.add_mesh(pv.PolyData(points), scalars=color_data.flatten(),
+                     opacity=0.3, render_points_as_spheres=False, point_size=25)
+    plotter.add_scalar_bar(title=quantity)
+    plotter.show()
+
+
+if __name__ == "__main__":
+    main()

{fdsreader-1.9.13 → fdsreader-1.10.0}/examples/smoke3d/fds_steckler/input_steckler.fds

@@ -3,7 +3,7 @@
 &MESH IJK=36,28,22, XB=0.00,3.60,-1.40,1.40,0.00,2.13 /
 
 &TIME T_END=100.0, TIME_SHRINK_FACTOR=10. /
-&DUMP NFRAMES=100, DT_DEVC=10., DT_DEVC_LINE=10., DT_HRR=10., SIG_FIGS=4, SIG_FIGS_EXP=2 /
+&DUMP NFRAMES=100 /
 
 &MISC TMPA=22. /
 

fdsreader-1.10.0/examples/smoke3d/smoke3d_example.py

@@ -0,0 +1,43 @@
+import pyvista as pv
+import numpy as np
+
+import fdsreader as fds
+
+
+def main():
+    sim = fds.Simulation("./fds_steckler/")
+
+    # Get 3D smoke data for a specific quantity in one of the meshes
+    quantity = "Temperature"  # "SOOT MASS FRACTION"
+    smoke = sim.smoke_3d.get_by_quantity(quantity)
+
+    data, coordinates = smoke.to_global(masked=True, return_coordinates=True, fill=np.nan)
+
+    # Create 3D grid
+    x_ = np.linspace(coordinates['x'][0], coordinates['x'][-1], len(coordinates['x']))
+    y_ = np.linspace(coordinates['y'][0], coordinates['y'][-1], len(coordinates['y']))
+    z_ = np.linspace(coordinates['z'][0], coordinates['z'][-1], len(coordinates['z']))
+    x, y, z = np.meshgrid(x_, y_, z_, indexing='ij')
+    points = np.stack((x.flatten(), y.flatten(), z.flatten()), axis=1)
+
+    # Initialize data grid
+    grid = pv.PolyData(points)
+
+    # Plot 3D data
+    plotter = pv.Plotter(notebook=False, off_screen=True)
+    plotter.add_mesh(grid, scalars=data[0].flatten(), opacity=0.3, render_points_as_spheres=False, point_size=25)
+    plotter.add_scalar_bar(title=quantity)
+
+    # Open a gif
+    plotter.open_gif("smoke.gif")
+
+    for d in data:
+        plotter.update_scalars(d.flatten(), render=False)
+        plotter.write_frame()
+
+    # Closes and finalizes movie
+    plotter.close()
+
+
+if __name__ == "__main__":
+    main()

{fdsreader-1.9.13 → fdsreader-1.10.0}/fdsreader/_version.py

@@ -7,5 +7,5 @@ Provides fdsreader version information.
 
 from incremental import Version
 
-__version__ = Version("fdsreader", 1, 9, 13)
+__version__ = Version("fdsreader", 1, 10, 0)
 __all__ = ["__version__"]

{fdsreader-1.9.13 → fdsreader-1.10.0}/fdsreader/bndf/obstruction.py

@@ -40,7 +40,7 @@ class Patch:
         self.mesh = mesh
         self._boundary_parent: 'Boundary' = None
 
-    def n_t(self, count_duplicates=True):
+    def n_t(self, count_duplicates=True) -> int:
         """Get the number of timesteps for which data was output.
         :param count_duplicates: If true, return the total number of data points, even if there is
             duplicate data for a timestep. Duplicate data might be output when restarting the
@@ -146,7 +146,7 @@ class Boundary:
         self.upper_bounds = upper_bounds
 
 
-    def n_t(self, count_duplicates=True):
+    def n_t(self, count_duplicates=True) -> int:
         """Get the number of timesteps for which data was output.
         :param count_duplicates: If true, return the total number of data points, even if there is
             duplicate data for a timestep. Duplicate data might be output when restarting the
@@ -305,7 +305,7 @@ class SubObstruction:
         self.show_times.append(time)
         self.show_times.sort()
 
-    def n_t(self, count_duplicates=True):
+    def n_t(self, count_duplicates=True) -> int:
         """Returns the number of timesteps for which boundary data is available.
         :param count_duplicates: If true, return the total number of data points, even if there is
             duplicate data for a timestep. Duplicate data might be output when restarting the
@@ -417,7 +417,7 @@ class Obstruction:
             return sorted(list(orientations))
         return []
 
-    def n_t(self, count_duplicates=True):
+    def n_t(self, count_duplicates=True) -> int:
         """Returns the number of timesteps for which boundary data is available.
         :param count_duplicates: If true, return the total number of data points, even if there is
             duplicate data for a timestep. Duplicate data might be output when restarting the

fdsreader-1.10.0/fdsreader/pl3d/pl3d.py

@@ -0,0 +1,295 @@
+import logging
+import os
+from copy import deepcopy
+from typing import Dict, Sequence, Tuple, Literal, Union, List
+import numpy as np
+import math
+import bisect
+
+from fdsreader.fds_classes import Mesh
+from fdsreader.utils import Quantity
+from fdsreader import settings
+import fdsreader.utils.fortran_data as fdtype
+
+_HANDLED_FUNCTIONS = {np.mean: (lambda pl: pl.mean)}
+
+
+def implements(np_function):
+    """Decorator to register an __array_function__ implementation for Plot3Ds.
+    """
+
+    def decorator(func):
+        _HANDLED_FUNCTIONS[np_function] = func
+        return func
+
+    return decorator
+
+
+class SubPlot3D:
+    """Subplot of a pl3d output for a single mesh.
+
+    :ivar mesh: The mesh containing the data.
+    """
+    # Offset of the binary file to the end of the file header.
+    _offset = fdtype.new((('i', 3),)).itemsize + fdtype.new((('i', 4),)).itemsize
+
+    def __init__(self, mesh: Mesh, quantity_idx: int):
+        self.file_paths: List[str] = list()  # Path to the binary data file for each time step
+        self.mesh = mesh
+        self._quantity_idx = quantity_idx
+
+    def _add_timestep(self, time_idx: int, file_path: str):
+        self.file_paths.insert(time_idx, file_path)
+
+    @property
+    def data(self) -> np.ndarray:
+        """Method to lazy load the 3D data for each quantity of a single mesh.
+
+        :returns: 4D numpy array with (t,x,y,z) as dimensions.
+        """
+        if not hasattr(self, "_data"):
+            self._data = np.empty(shape=(len(self.file_paths),) + self.mesh.dimension.shape())
+            dtype_data = fdtype.new((('f', self.mesh.dimension.size() * 5),))
+            for t, file_path in enumerate(self.file_paths):
+                with open(file_path, 'rb') as infile:
+                    infile.seek(self._offset)
+                    self._data[t, :, :, :] = fdtype.read(infile, dtype_data, 1)[0][0].reshape(
+                        self.mesh.dimension.shape() + (5,), order='F')[:, :, :, self._quantity_idx]
+        return self._data
+
+    def clear_cache(self):
+        """Remove all data from the internal cache that has been loaded so far to free memory.
+        """
+        if hasattr(self, "_data"):
+            del self._data
+
+
+class Plot3D(np.lib.mixins.NDArrayOperatorsMixin):
+    """Plot3d file data container including metadata. Consists of multiple subplots, one for each
+        mesh.
+
+    :ivar times: All times for which data has been recorded.
+    :ivar quantities: List with quantity objects containing information about recorded quantities
+     calculated for this Plot3D with the corresponding short_name and unit.
+    """
+
+    def __init__(self, root_path: str):
+        self._root_path = root_path
+        self.times: List[float] = list()
+
+        # List of all subplots this Plot3D consists of (one per mesh).
+        self._subplots: Dict[str, SubPlot3D] = dict()
+
+    def _add_subplot(self, filename: str, time: float, quantity: Quantity, quantity_idx: int, mesh: Mesh):
+        self.quantity: Quantity = quantity
+        if mesh.id not in self._subplots.keys():
+            self._subplots[mesh.id] = SubPlot3D(mesh, quantity_idx)
+        if not any(np.isclose(time, t) for t in self.times):
+            time_idx = bisect.bisect(self.times, time)
+            self.times.insert(time_idx, time)
+        else:
+            time_idx = next(idx for idx, t in enumerate(self.times) if np.isclose(time, t))
+        self._subplots[mesh.id]._add_timestep(time_idx, os.path.join(self._root_path, filename))
+
+        # If lazy loading has been disabled by the user, load the data instantaneously instead
+        if not settings.LAZY_LOAD:
+            _ = self._subplots[mesh.id].data
+
+    def __getitem__(self, mesh: Mesh):
+        """Returns the :class:`SubPlot` that contains data for the given mesh.
+        """
+        return self._subplots[mesh.id]
+
+    @implements(np.mean)
+    def mean(self) -> float:
+        """Calculates the mean value of the whole Plot3D.
+
+        :returns: The calculated mean value.
+        """
+        mean_sum = 0
+        for subplot in self._subplots.values():
+            mean_sum += np.mean(subplot.data)
+        return mean_sum / len(self._subplots)
+
+    @implements(np.std)
+    def std(self) -> float:
+        """Calculates the standard deviation for each quantity individually of the whole Plot3D.
+
+        :returns: The calculated standard deviation.
+        """
+        mean = self.mean
+        sum = np.sum([np.sum(np.power(subplot.data - mean, 2)) for subplot in self._subplots.values()])
+        N = np.sum([subplot.data.size for subplot in self._subplots.values()])
+        return np.sqrt(sum / N)
+
+    def clear_cache(self):
+        """Remove all data from the internal cache that has been loaded so far to free memory.
+        """
+        for subplot in self._subplots.values():
+            subplot.clear_cache()
+
+    def to_global(self, masked: bool = False, fill: float = 0, return_coordinates: bool = False) -> \
+            Union[np.ndarray, Tuple[np.ndarray, Dict[Literal['x', 'y', 'z'], np.ndarray]]]:
+        """Creates a global numpy ndarray from all subplots.
+
+            :param masked: Whether to apply the obstruction mask to the data or not.
+            :param fill: The fill value to use for masked entries. Only used when masked=True.
+            :param return_coordinates: If true, return the matching coordinate for each value on the generated grid.
+        """
+        coord_min = {'x': math.inf, 'y': math.inf, 'z': math.inf}
+        coord_max = {'x': -math.inf, 'y': -math.inf, 'z': -math.inf}
+        for dim in ('x', 'y', 'z'):
+            for subplot in self._subplots.values():
+                co = subplot.mesh.coordinates[dim]
+                coord_min[dim] = min(co[0], coord_min[dim])
+                coord_max[dim] = max(co[-1], coord_max[dim])
+
+        # The global grid will use the finest mesh as base and duplicate values of the coarser
+        # meshes. Therefore, we first find the finest mesh and calculate the step size in each
+        # dimension.
+        step_sizes_min = {'x': coord_max['x'] - coord_min['x'],
+                          'y': coord_max['y'] - coord_min['y'],
+                          'z': coord_max['z'] - coord_min['z']}
+        step_sizes_max = {'x': 0, 'y': 0, 'z': 0}
+        steps = dict()
+        global_max = {'x': -math.inf, 'y': -math.inf, 'z': -math.inf}
+
+        for dim in ('x', 'y', 'z'):
+            for subplot in self._subplots.values():
+                step_size = subplot.mesh.coordinates[dim][1] - subplot.mesh.coordinates[dim][0]
+                step_sizes_min[dim] = min(step_size, step_sizes_min[dim])
+                step_sizes_max[dim] = max(step_size, step_sizes_max[dim])
+                global_max[dim] = max(subplot.mesh.coordinates[dim][-1], global_max[dim])
+
+        for dim in ('x', 'y', 'z'):
+            if step_sizes_min[dim] == 0:
+                step_sizes_min[dim] = math.inf
+                steps[dim] = 1
+            else:
+                steps[dim] = max(int(round((coord_max[dim] - coord_min[dim]) / step_sizes_min[dim])),
+                                 1) + 1  # + step_sizes_max[dim] / step_sizes_min[dim]
+
+        grid = np.full((self.n_t, steps['x'], steps['y'], steps['z']), np.nan)
+
+        start_idx = dict()
+        end_idx = dict()
+        for subplot in self._subplots.values():
+            subplot_data = subplot.data.copy()
+            if masked:
+                mask = subplot.mesh.get_obstruction_mask(self.times)
+
+            for axis in range(3):
+                dim = ('x', 'y', 'z')[axis]
+                n_repeat = max(int(round(
+                    (subplot.mesh.coordinates[dim][1] - subplot.mesh.coordinates[dim][0]) /
+                    step_sizes_min[dim])), 1)
+
+                start_idx[dim] = int(round(
+                    (subplot.mesh.coordinates[dim][0] - coord_min[dim]) / step_sizes_min[dim]))
+                end_idx[dim] = int(round(
+                    (subplot.mesh.coordinates[dim][-1] - coord_min[dim]) / step_sizes_min[dim]))
+
+            # We ignore border points unless they are actually on the border of the simulation space as all
+            # other border points actually appear twice, as the subslices overlap. This only
+            # applies for face_centered slices, as cell_centered slices will not overlap.
+            reduced_shape_slices = (slice(subplot.data.shape[0]),) + tuple(slice(s - 1) for s in subplot.data.shape[1:])
+            subplot_data = subplot_data[reduced_shape_slices]
+            if masked:
+                mask = mask[reduced_shape_slices]
+
+            for axis in range(3):
+                dim = ('x', 'y', 'z')[axis]
+                # Temporarily save border points to add them back to the array again later
+                if subplot.mesh.coordinates[dim][-1] == global_max[dim]:
+                    end_idx[dim] += 1
+                    temp_data_slices = [slice(s) for s in subplot_data.shape]
+                    temp_data_slices[axis + 1] = slice(subplot_data.shape[axis + 1] - 1, None)
+                    temp_data = subplot_data[tuple(temp_data_slices)]
+                    if masked:
+                        temp_mask = mask[tuple(temp_data_slices)]
+
+                if n_repeat > 1:
+                    subplot_data = np.repeat(subplot_data, n_repeat, axis=axis + 1)
+                    if masked:
+                        mask = np.repeat(mask, n_repeat, axis=axis + 1)
+
+                # Add border points back again if needed
+                if subplot.mesh.coordinates[dim][-1] == global_max[dim]:
+                    subplot_data = np.concatenate((subplot_data, temp_data), axis=axis + 1)
+                    if masked:
+                        mask = np.concatenate((mask, temp_mask), axis=axis + 1)
+
+            # If the slice should be masked, we set all cells at which an obstruction is in the
+            # simulation space to the fill value set by the user
+            if masked:
+                subplot_data = np.where(mask, subplot_data, fill)
+
+            grid[:, start_idx['x']: end_idx['x'], start_idx['y']: end_idx['y'],
+            start_idx['z']: end_idx['z']] = subplot_data.reshape(
+                (self.n_t, end_idx['x'] - start_idx['x'], end_idx['y'] - start_idx['y'],
+                 end_idx['z'] - start_idx['z']))
+
+        if return_coordinates:
+            coordinates = dict()
+            for dim_index, dim in enumerate(('x', 'y', 'z')):
+                coordinates[dim] = np.linspace(coord_min[dim], coord_max[dim], grid.shape[dim_index + 1])
+
+        if return_coordinates:
+            return grid, coordinates
+        else:
+            return grid
+
+    @property
+    def n_t(self) -> int:
+        """Get the number of timesteps for which data was output.
+        """
+        return len(self.times)
+
+    @property
+    def subplots(self):
+        """Returns a list with one SubPlot3D object per mesh.
+        """
+        return list(self._subplots.values())
+
+    def __array__(self):
+        """Method that will be called by numpy when trying to convert the object to a numpy ndarray.
+        """
+        raise UserWarning(
+            "Plot3Ds can not be converted to numpy arrays, but they support all typical numpy"
+            " operations such as np.multiply. If a 'global' array containing all subplots is"
+            " required, please use the 'to_global' method and use the returned numpy-array explicitly.")
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        """Method that will be called by numpy when using a ufunction with a Plot3D as input.
+
+        :returns: A new pl3d on which the ufunc has been applied.
+        """
+        if method != "__call__":
+            logging.warning(
+                "The %s method has been used which is not explicitly implemented. Correctness of"
+                " results is not guaranteed. If you require this feature to be implemented please"
+                " submit an issue on Github where you explain your use case.", method)
+        input_list = list(inputs)
+        for i, inp in enumerate(inputs):
+            if isinstance(inp, self.__class__):
+                del input_list[i]
+
+        new_pl3d = deepcopy(self)
+        for subplot in self._subplots.values():
+            subplot._data = ufunc(subplot.data, input_list[0], **kwargs)
+        return new_pl3d
+
+    def __array_function__(self, func, types, args, kwargs):
+        """Method that will be called by numpy when using an array function with a Slice as input.
+
+        :returns: The output of the array function.
+        """
+        if func not in _HANDLED_FUNCTIONS:
+            return NotImplemented
+            # Note: this allows subclasses that don't override __array_function__ to handle Plot3Ds.
+        if not all(issubclass(t, self.__class__) for t in types):
+            return NotImplemented
+        return _HANDLED_FUNCTIONS[func](*args, **kwargs)
+
+# __array_function__ implementations
+# ...

{fdsreader-1.9.13 → fdsreader-1.10.0}/fdsreader/pl3d/plot3D_collection.py

@@ -1,4 +1,5 @@
 from typing import Iterable, Union, List
+import numpy as np
 
 from fdsreader.pl3d import Plot3D
 from fdsreader.utils.data import FDSDataCollection, Quantity
@@ -9,26 +10,24 @@ class Plot3DCollection(FDSDataCollection):
         using plot3Ds as well as its subclasses such as :class:`SubPlot3D`.
     """
 
-    def __init__(self, times: Iterable[float], *plot3ds: Iterable[Plot3D]):
+    def __init__(self, *plot3ds: Iterable[Plot3D]):
         super().__init__(*plot3ds)
-        self.times = list(times)
+
+    @property
+    def times(self) -> np.ndarray:
+        return np.array(self._elements[0].times)
 
     @property
     def quantities(self) -> List[Quantity]:
-        qs = set()
-        for pl3d in self._elements:
-            for q in pl3d.quantities:
-                qs.add(q)
-        return list(qs)
+        return [pl.quantity for pl in self._elements]
 
-    def filter_by_quantity(self, quantity: Union[str, Quantity]):
+    def get_by_quantity(self, quantity: Union[str, Quantity]):
         """Filters all plot3d data by a specific quantity.
         """
         if type(quantity) == Quantity:
             quantity = quantity.name
-        return Plot3DCollection(x for x in self._elements if any(
-            q.name.lower() == quantity.lower() or q.short_name.lower() == quantity.lower() for q in
-            x.quantities))
+        return next(x for x in self._elements if
+                    x.quantity.name.lower() == quantity.lower() or x.quantity.short_name.lower() == quantity.lower())
 
     def __repr__(self):
         return "Plot3DCollection(" + super(Plot3DCollection, self).__repr__() + ")"

{fdsreader-1.9.13 → fdsreader-1.10.0}/fdsreader/simulation.py

@@ -144,7 +144,7 @@ class Simulation:
             self._obstructions = list()
             self._slices = dict()
             self._geomslices = dict()
-            self._data_3d = dict()
+            self.data_3d = Plot3DCollection([Plot3D(self.root_path) for _ in range(5)])
             self._smoke_3d = dict()
             self._isosurfaces = dict()
             self._particles = list()
@@ -179,7 +179,6 @@ class Simulation:
             self.geomslices = GeomSliceCollection(
                 GeomSlice(self.root_path, slice_data[0]["id"],
                           slice_data[0]["times"], slice_data[1:]) for slice_data in self._geomslices.values())
-            self.data_3d = Plot3DCollection(self._data_3d.keys(), self._data_3d.values())
             self.smoke_3d = Smoke3DCollection(self._smoke_3d.values())
             self.isosurfaces = IsosurfaceCollection(self._isosurfaces.values())
             self.devices = DeviceCollection(self._devices.values())
@@ -194,7 +193,7 @@ class Simulation:
             if len(self._evacs) == 0:
                 self.evacs = EvacCollection((), "", ())
             self.meshes = MeshCollection(self._meshes)
-            del self._geom_data, self._geomslices, self._slices, self._obstructions, self._data_3d, self._smoke_3d, self._isosurfaces, self._devices, self._particles, self._evacs, self._meshes, self._subobstructions
+            del self._geom_data, self._geomslices, self._slices, self._obstructions, self._smoke_3d, self._isosurfaces, self._devices, self._particles, self._evacs, self._meshes, self._subobstructions
 
             if settings.ENABLE_CACHING:
                 # Hash will be saved to simulation pickle file and compared to new hash when loading
@@ -748,16 +747,12 @@ class Simulation:
         mesh_index = int(line[2]) - 1
 
         filename = smv_file.readline().strip()
-        quantities = list()
-        for _ in range(5):
+        for i in range(5):
             quantity = smv_file.readline().strip()
             short_name = smv_file.readline().strip()
             unit = smv_file.readline().strip()
-            quantities.append(Quantity(quantity, short_name, unit))
 
-        if time not in self._data_3d:
-            self._data_3d[time] = Plot3D(self.root_path, time, quantities)
-        self._data_3d[time]._add_subplot(filename, self._meshes[mesh_index])
+            self.data_3d[i]._add_subplot(filename, time, Quantity(quantity, short_name, unit), i, self._meshes[mesh_index])
 
     @log_error("smoke3d")
     def _load_smoke_3d(self, smv_file: TextIO, line: str):

{fdsreader-1.9.13 → fdsreader-1.10.0}/fdsreader/slcf/geomslice.py

@@ -52,8 +52,11 @@ class SubGeomSlice:
     def times(self):
         return self._parent_slice.times
 
+
     @property
-    def n_t(self):
+    def n_t(self) -> int:
+        """Get the number of timesteps for which data was output.
+        """
         return self._parent_slice.n_t
 
     def _load_geom_data(self):
@@ -409,7 +412,7 @@ class GeomSlice(np.lib.mixins.NDArrayOperatorsMixin):
         """
         raise UserWarning(
             "Slices can not be converted to numpy arrays, but they support all typical numpy"
-            " operations such as np.multiply. If a 'global' array containg all subgeomslices is"
+            " operations such as np.multiply. If a 'global' array containing all subgeomslices is"
             " required, use the 'to_global' method and use the returned numpy-array explicitly.")
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):

{fdsreader-1.9.13 → fdsreader-1.10.0}/fdsreader/slcf/slice.py

@@ -100,7 +100,9 @@ class SubSlice:
         return self._parent_slice.times
 
     @property
-    def n_t(self):
+    def n_t(self) -> int:
+        """Get the number of timesteps for which data was output.
+        """
         return self._parent_slice.n_t
 
     def _load_data(self, file_path: str, data_out: np.ndarray):
@@ -507,8 +509,7 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
 
             :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.
-            :param return_coordinates: If true, return the matching coordinate for each value on the
-                generated grid.
+            :param return_coordinates: If true, return the matching coordinate for each value on the generated grid.
         """
         subslice_sets = [dict(), dict()]
 
@@ -567,7 +568,7 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
             start_idx = dict()
             end_idx = dict()
             for slc in subslices.values():
-                slc_data = slc.data if slc.orientation == 0 else np.expand_dims(slc.data,
+                slc_data = slc.data.copy() if slc.orientation == 0 else np.expand_dims(slc.data.copy(),
                                                                                 axis=slc.orientation)
                 if masked:
                     mask = slc.mesh.get_obstruction_mask_slice(slc)
@@ -694,7 +695,7 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
         """
         raise UserWarning(
             "Slices can not be converted to numpy arrays, but they support all typical numpy"
-            " operations such as np.multiply. If a 'global' array containg all subslices is"
+            " operations such as np.multiply. If a 'global' array containing all subslices is"
             " required, use the 'to_global' method and use the returned numpy-array explicitly.")
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):