fdsreader 0.9.16__tar.gz → 0.9.20__tar.gz

{fdsreader-0.9.16/fdsreader.egg-info → fdsreader-0.9.20}/PKG-INFO

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

{fdsreader-0.9.16 → fdsreader-0.9.20}/fdsreader/_version.py

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

{fdsreader-0.9.16 → fdsreader-0.9.20}/fdsreader/simulation.py

@@ -70,15 +70,16 @@ class Simulation:
         return super(Simulation, cls).__new__(cls)
 
     def __repr__(self):
-        return f"Simulation(chid={self.chid},\n" + \
+        r = f"Simulation(chid={self.chid},\n" + \
                f"           meshes={len(self.meshes)},\n" + \
-               f"           obstructions={len(self.obstructions)},\n" if len(self.obstructions) > 0 else "" + \
-               f"           geometries={len(self.geoms)},\n" if len(self.geoms) > 0 else "" + \
-               f"           slices={len(self.slices)},\n" if len(self.slices) > 0 else "" + \
-               f"           plot3d={len(self.data_3d)},\n" if len(self.data_3d) > 0 else "" + \
-               f"           isosurfaces={len(self.isosurfaces)},\n" if len(self.isosurfaces) > 0 else "" + \
-               f"           particles={len(self.particles)},\n" if len(self.particles) > 0 else "" + \
-               f"           devices={len(self.devices)})" if len(self.devices) > 0 else ""
+               (f"           obstructions={len(self.obstructions)},\n" if len(self.obstructions) > 0 else "") + \
+               (f"           geometries={len(self.geoms)},\n" if len(self.geoms) > 0 else "") + \
+               (f"           slices={len(self.slices)},\n" if len(self.slices) > 0 else "") + \
+               (f"           plot3d={len(self.data_3d)},\n" if len(self.data_3d) > 0 else "") + \
+               (f"           isosurfaces={len(self.isosurfaces)},\n" if len(self.isosurfaces) > 0 else "") + \
+               (f"           particles={len(self.particles)},\n" if len(self.particles) > 0 else "") + \
+               (f"           devices={len(self.devices)},\n" if len(self.devices) > 0 else "")
+        return r[:-2] + ')'
 
     def __init__(self, path: str):
         """

{fdsreader-0.9.16 → fdsreader-0.9.20}/fdsreader/slcf/SliceCollection.py

@@ -29,19 +29,30 @@ class SliceCollection(FDSDataCollection):
 
     def get_nearest(self, x: float = None, y: float = None, z: float = None) -> Slice:
         """Filters the slice with the shortest distance to the given point.
+            If there are multiple slices with the same distance, a random one will be selected.
         """
         d_min = np.finfo(float).max
-        slc_min = None
+        slices_min = list()
 
         for slc in self:
             dx = max(slc.extent.x_start - x, 0, x - slc.extent.x_end) if x is not None else 0
             dy = max(slc.extent.y_start - y, 0, y - slc.extent.y_end) if y is not None else 0
             dz = max(slc.extent.z_start - z, 0, z - slc.extent.z_end) if z is not None else 0
             d = np.sqrt(dx * dx + dy * dy + dz * dz)
-            if d < d_min:
+            if d <= d_min:
                 d_min = d
-                slc_min = slc
-        return slc_min
+                slices_min.append(slc)
+
+        if x is not None:
+            slices_min.sort(key=lambda slc: (slc.extent.x_end - slc.extent.x_start))
+        if y is not None:
+            slices_min.sort(key=lambda slc: (slc.extent.y_end - slc.extent.y_start))
+        if z is not None:
+            slices_min.sort(key=lambda slc: (slc.extent.z_end - slc.extent.z_start))
+
+        if len(slices_min) > 0:
+            return slices_min[0]
+        return None
 
     def __repr__(self):
         return "SliceCollection(" + super(SliceCollection, self).__repr__() + ")"

{fdsreader-0.9.16 → fdsreader-0.9.20}/fdsreader/slcf/slice.py

@@ -211,8 +211,15 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
             for _, subslice in self._subslices.items():
                 _ = subslice.data
 
-    def __getitem__(self, key: Union[int, Mesh]):
-        """Returns the :class:`SubSlice` that cuts through the given mesh.
+    def get_subslice(self, key: Union[int, Mesh]) -> SubSlice:
+        """Returns the :class:`SubSlice` that cuts through the given mesh. When an int is provided
+            the nth SubSlice will be returned.
+        """
+        return self[key]
+
+    def __getitem__(self, key: Union[int, Mesh]) -> SubSlice:
+        """Returns the :class:`SubSlice` that cuts through the given mesh. When an int is provided
+            the nth SubSlice will be returned.
         """
         if type(key) == int:
             return tuple(self._subslices.values())[key]
@@ -221,6 +228,12 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
     def __len__(self):
         return len(self._subslices)
 
+    @property
+    def subslices(self) -> List[SubSlice]:
+        """Get a list with all SubSlices.
+        """
+        return list(self._subslices.values())
+
     @property
     def extent_dirs(self) -> Tuple[
         Literal['x', 'y', 'z'], Literal['x', 'y', 'z'], Literal['x', 'y', 'z']]:
@@ -247,6 +260,8 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
             return idx
 
     def get_nearest_index(self, dimension: Literal['x', 'y', 'z'], value: float) -> int:
+        """Get the nearest mesh coordinate index in a specific dimension.
+        """
         coords = self.coordinates[dimension]
         idx = np.searchsorted(coords, value, side="left")
         if idx > 0 and (idx == coords.size or np.math.fabs(value - coords[idx - 1]) < np.math.fabs(
@@ -263,11 +278,21 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
 
     @property
     def coordinates(self) -> Dict[Literal['x', 'y', 'z'], np.ndarray]:
+        """Returns a dictionary containing a numpy ndarray with coordinates for each dimension.
+            For cell-centered slices, the coordinates are adjusted to represent cell-centered coordinates.
+        """
         coords = {'x': set(), 'y': set(), 'z': set()}
         for dim in ('x', 'y', 'z'):
             for mesh in self._subslices.keys():
-                coords[dim].update(mesh.coordinates[dim])
+                co = mesh.coordinates[dim]
+                # In case the slice is cell-centered, we will shift the coordinates by half a cell
+                # and remove the last coordinate
+                if self.cell_centered:
+                    co = co[:-1]
+                    co += (co[1] - co[0]) / 2
+                coords[dim].update(co)
             coords[dim] = np.array(sorted(list(coords[dim])))
+
         return coords
 
     def clear_cache(self):
@@ -397,8 +422,8 @@ class Slice(np.lib.mixins.NDArrayOperatorsMixin):
 
     def __repr__(self):
         if self.type == '3D':  # 3D-Slice
-            return f"Slice([3D] cell_centered={self.cell_centered}, extent={self.extent}, times=[{self.times[0]:.2f},{self.times[1]:.2f},...,{self.times[-1]:.2f}])"
+            return f"Slice([3D] cell_centered={self.cell_centered}, extent={self.extent})"
         else:  # 2D-Slice
-            return f"Slice([2D] cell_centered={self.cell_centered}, extent={self.extent}, extent_dirs={self.extent_dirs}, orientation={self.orientation}, times=[{self.times[0]:.2f},{self.times[1]:.2f},...,{self.times[-1]:.2f}])"
+            return f"Slice([2D] cell_centered={self.cell_centered}, extent={self.extent}, extent_dirs={self.extent_dirs}, orientation={self.orientation}, times=[{self.times[0]:.2f})"
 
 # __array_function__ implementations

{fdsreader-0.9.16 → fdsreader-0.9.20}/fdsreader/utils/data.py

@@ -108,7 +108,7 @@ class FDSDataCollection:
         return value in self._elements
 
     def __repr__(self):
-        return "[" + str(self._elements) + "]"
+        return "[" + ",\n".join(str(e) for e in self._elements) + "]"
 
     def clear_cache(self):
         """Remove all data from the internal cache that has been loaded so far to free memory.

{fdsreader-0.9.16 → fdsreader-0.9.20/fdsreader.egg-info}/PKG-INFO

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