Fix for reading in times of slices

Author: lu-kas

fdsreader/simulation.py

@@ -175,7 +175,7 @@ def __init__(self, path: str):
             self.geom_data = GeometryCollection(self._geom_data)
             self.slices = SliceCollection(
                 Slice(self.root_path, slice_data[0]["id"], slice_data[0]["cell_centered"],
-                      slice_data[0]["times"], slice_data[1:]) for slice_data in self._slices.values())
+                      slice_data[1:]) for slice_data in self._slices.values())
             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())
@@ -553,20 +553,9 @@ def _load_slice(self, smv_file: TextIO, line: str):
         short_name = smv_file.readline().strip()
         unit = smv_file.readline().strip()
 
-        file_path = os.path.join(self.root_path, filename)
-
-        if os.path.exists(file_path + ".bnd"):
-            times = list()
-            with open(file_path + ".bnd", 'r') as bnd_file:
-                for line in bnd_file:
-                    times.append(float(line.split()[0]))
-            times = np.array(times)
-        else:
-            times = None
-
         if slice_index not in self._slices:
             self._slices[slice_index] = [
-                {"cell_centered": cell_centered, "times": times, "id": slice_id}]
+                {"cell_centered": cell_centered, "id": slice_id}]
         self._slices[slice_index].append(
             {"dimension": dimension, "extent": extent, "mesh": mesh, "filename": filename,
              "quantity": quantity, "short_name": short_name, "unit": unit})

fdsreader/slcf/slice.py

@@ -127,6 +127,23 @@ def _load_data(self, file_path: str, data_out: np.ndarray):
                 else:
                     data_out[t, :] = data
 
+    def _load_times(self) -> np.ndarray:
+        # Read in (only) the times for which SLCF data is available
+        n = self.dimension.size(cell_centered=False)
+        dtype_data = fdtype.combine(fdtype.FLOAT, fdtype.new((('f', n),)))
+
+        file_path = os.path.join(self._parent_slice._root_path, self.filename)
+
+        n_t = (os.stat(file_path).st_size - self._offset) // dtype_data.itemsize
+        times = np.empty(n_t)
+
+        with open(file_path, 'rb') as infile:
+            infile.seek(self._offset)
+            for t, data in enumerate(fdtype.read(infile, dtype_data, n_t)):
+                times[t] = data[0][0]
+
+        return times
+
     @property
     def data(self) -> np.ndarray:
         """Method to lazy load the slice's data.
@@ -189,18 +206,11 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
     :ivar extent: :class:`Extent` object containing 3-dimensional extent information.
     """
 
-    def __init__(self, root_path: str, slice_id: str, cell_centered: bool, times: np.ndarray,
+    def __init__(self, root_path: str, slice_id: str, cell_centered: bool,
                  multimesh_data: Collection[Dict]):
         self._root_path = root_path
         self.cell_centered = cell_centered
 
-        self.times = times
-
-        if times is not None:
-            self.n_t = times.size
-        else:
-            self.n_t = -1
-
         self.id = slice_id
 
         # List of all subslices this slice consists of (one per mesh).
@@ -262,6 +272,10 @@ def __init__(self, root_path: str, slice_id: str, cell_centered: bool, times: np
                              y_start, y_start if self.orientation == 2 else y_end,
                              z_start, z_start if self.orientation == 3 else z_end)
 
+        # Read in the available time steps, using arbitrary the first sub-slice
+        self.times = self.subslices[0]._load_times()
+        self.n_t = len(self.times)
+
         # If lazy loading has been disabled by the user, load the data instantaneously instead
         if not settings.LAZY_LOAD:
             for _, subslice in self._subslices.items():