wolfhece 2.2.17__py3-none-any.whl → 2.2.20__py3-none-any.whl

wolfhece/Results2DGPU.py

@@ -186,6 +186,7 @@ class wolfres2DGPU(Wolfresults_2D):
         self._cache = None
 
     def __getstate__(self):
+        """ Get state for pickle """
         dct= super().__getstate__()
 
         to_pop = ['_result_store', '_cache']
@@ -193,17 +194,25 @@ class wolfres2DGPU(Wolfresults_2D):
             if key in dct:
                 dct.pop(key)
 
-        dct['isGPU'] = True
+        dct['isGPU'] = True # Indicate that this is a GPU result --> to avoid confusion with CPU results and loading phase "_loader", "_post_loader"
 
         return dct
 
     def __setstate__(self, dct):
-
+        """ Set state from a dictionary from pickle """
         super().__setstate__(dct)
 
         self._loader(self.filename)
         self._post_loader()
 
+        if len(dct['myblocks']) > 0:
+            self.myblocks = dct['myblocks']
+            self.head_blocks = dct['head_blocks']
+            self.loaded_rough = dct['loaded_rough']
+            self.current_result = dct['current_result']
+            self.loaded = dct['loaded']
+            self._nap = dct['_nap']
+
         self._result_store = None
         self._cache = None
         self.setup_store(self._result_store)
@@ -412,6 +421,9 @@ class wolfres2DGPU(Wolfresults_2D):
         """
 
         which = self._sanitize_result_step(which)
+        if which is None:
+            self.loaded = False
+            return
 
         # stored result files are 1-based -> which+1
         if self._cache is not None:

wolfhece/__init__.py

@@ -11,5 +11,18 @@ except ImportError as e:
     raise Exception(_('Error importing GDAL library\nPlease ensure GDAL is installed and the Python bindings are available\n\ngdal wheels can be found at https://github.com/cgohlke/geospatial-wheels'))
 
 from .apps.version import WolfVersion
+from packaging.version import Version
 
-__version__ = WolfVersion().get_version()
+__version__ = WolfVersion().get_version()
+
+def is_enough(version: str) -> bool:
+    """
+    Compare the current version of WolfHece to a given version string.
+
+    Args:
+        version (str): The version string to compare against.
+
+    Returns:
+        bool: True if the current version is greater than or equal to the given version, False otherwise.
+    """
+    return Version(__version__) >= Version(version)

wolfhece/analyze_poly.py

@@ -0,0 +1,335 @@
+import logging
+
+import numpy as np
+from shapely.geometry import Point, LineString
+from typing import Literal
+import pandas as pd
+
+from .PyTranslate import _
+from .drawing_obj import Element_To_Draw
+from .PyVertexvectors import Triangulation, vector,Zones, zone
+from .wolf_array import WolfArray, header_wolf
+
+class Array_analysis_onepolygon():
+    """ Class for values analysis of an array based on a polygon.
+
+    This class select values insides a polygon and plot statistics of the values.
+
+    The class is designed to be used with the WolfArray class and the vector class from the PyVertexvectors module.
+
+    Plots of the values distribution can be generated using seaborn or plotly.
+    """
+
+    def __init__(self, wa:WolfArray, polygon:vector):
+
+        self._wa = wa
+        self._polygon = polygon
+
+        self._selected_cells = None
+        self._values = None
+
+    def values(self, which:Literal['Mean', 'Std', 'Median', 'Sum', 'Volume', 'Values']) -> pd.DataFrame | float:
+        """ Get the values as a pandas DataFrame
+
+        :param which: Mean, Std, Median, Sum, Volume, Values
+        """
+
+        authrorized = ['Mean', 'Std', 'Median', 'Sum', 'Volume', 'Values']
+        if which not in authrorized:
+            raise ValueError(f"Invalid value for 'which'. Must be one of {authrorized}.")
+
+        if self._values is None:
+            self.compute_values()
+
+        if self._values is None:
+            raise ValueError("No values computed. Please call compute_values() first.")
+
+        if which == 'Values':
+            return pd.DataFrame(self._values[_(which)], columns=[which])
+        else:
+            return self._values[which]
+
+    def select_cells(self, mode:Literal['polygon', 'buffer'] = 'polygon', **kwargs):
+        """ Select the cells inside the polygon """
+
+        if mode == 'polygon':
+            if 'polygon' in kwargs:
+                self._polygon = kwargs['polygon']
+                self._select_cells_polygon(self._polygon)
+            else:
+                raise ValueError("No polygon provided. Please provide a polygon to select cells.")
+        elif mode == 'buffer':
+            if 'buffer' in kwargs:
+                self._select_cells_buffer(kwargs['buffer'])
+            else:
+                raise ValueError("No buffer size provided. Please provide a buffer size to select cells.")
+        else:
+            raise ValueError("Invalid mode. Please use 'polygon' or 'buffer'.")
+
+    def _select_cells_polygon(self, selection_poly:vector):
+        """ Select the cells inside the polygon """
+
+        self._polygon = selection_poly
+        self._selected_cells = self._wa.get_xy_inside_polygon(self._polygon)
+
+    def _select_cells_buffer(self, buffer_size:float = 0.0):
+        """ Select the cells inside the buffer of the polygon """
+
+        self._polygon = self._polygon.buffer(buffer_size, inplace=False)
+        self._selected_cells = self._wa.get_xy_inside_polygon(self._polygon)
+
+    def compute_values(self):
+        """ Get the values of the array inside the polygon """
+
+        if self._selected_cells is None:
+            if self._polygon is None:
+                raise ValueError("No polygon provided. Please provide a polygon to select cells.")
+
+        self._values = self._wa.statistics(self._polygon)
+
+    def plot_values(self, show:bool = True, bins:int = 100,
+                    engine:Literal['seaborn', 'plotly'] = 'seaborn'):
+        """ Plot a histogram of the values """
+
+        if engine == 'seaborn':
+            return self.plot_values_seaborn(show=show, bins=bins)
+        elif engine == 'plotly':
+            return self.plot_values_plotly(show=show, bins=bins)
+
+    def plot_values_seaborn(self, bins:int = 100, show:bool = True):
+        """ Plot a histogram of the values """
+
+        import seaborn as sns
+        import matplotlib.pyplot as plt
+
+        fig, ax = plt.subplots()
+        sns.histplot(self.values('Values'), bins=bins,
+                     kde=True, ax=ax,
+                     stat="density")
+
+        # Add mean, std, median values on plot
+        mean = self.values('Mean')
+        # std = self.values('Std').values[0]
+        median = self.values('Median')
+
+        # test noen and masked value
+        if mean is not None and mean is not np.ma.masked:
+            ax.axvline(mean, color='r', linestyle='--', label=f'Mean: {mean:.2f}')
+        if median is not None and median is not np.ma.masked:
+            ax.axvline(median, color='b', linestyle='--', label=f'Median: {median:.2f}')
+
+        ax.legend()
+        ax.set_xlabel('Values')
+        ax.set_ylabel('Frequency')
+        ax.set_title('Values distribution')
+
+        if show:
+            plt.show()
+
+        return (fig, ax)
+
+    def plot_values_plotly(self, bins:int = 100, show:bool = True):
+        """ Plot a histogram of the values """
+
+        import plotly.express as px
+
+        fig = px.histogram(self.values('Values'), x='Values',
+                           nbins=bins, title='Values distribution',
+                           histnorm='probability density')
+
+        # Add mean, std, median values on plot
+        mean = self.values('Mean')
+        median = self.values('Median')
+
+        if mean is not None and mean is not np.ma.masked:
+            fig.add_vline(x=mean, line_color='red', line_dash='dash', annotation_text=f'Mean: {mean:.2f}')
+        if median is not None and median is not np.ma.masked:
+            fig.add_vline(x=median, line_color='blue', line_dash='dash', annotation_text=f'Median: {median:.2f}')
+
+        fig.update_layout(xaxis_title='Values', yaxis_title='Frequency')
+
+        if show:
+            fig.show(renderer='browser')
+
+        return fig
+
+
+class Array_analysis_polygons():
+    """ Class for values analysis of an array based on a polygon.
+
+    This class select values insides a polygon and plot statistics of the values.
+
+    The class is designed to be used with the WolfArray class and the vector class from the PyVertexvectors module.
+
+    Plots of the values distribution can be generated using seaborn or plotly.
+    """
+
+    def __init__(self, wa:WolfArray, polygons:zone):
+        """ Initialize the class with a WolfArray and a zone of polygons """
+
+        self._wa = wa
+        self._polygons = polygons
+
+        self._zone = {polygon.myname: Array_analysis_onepolygon(self._wa, polygon) for polygon in self._polygons.myvectors}
+
+    def __getitem__(self, key):
+        """ Get the polygon by name """
+        if key in self._zone:
+            return self._zone[key]
+        else:
+            raise KeyError(f"Polygon {key} not found in zone.")
+
+    def plot_values(self, show:bool = True, bins:int = 100,
+                    engine:Literal['seaborn', 'plotly'] = 'seaborn'):
+        """ Plot a histogram of the values """
+
+        if engine == 'seaborn':
+            return self.plot_values_seaborn(show=show, bins=bins)
+        elif engine == 'plotly':
+            return self.plot_values_plotly(show=show, bins=bins)
+
+    def plot_values_seaborn(self, bins:int = 100, show:bool = True):
+        """ Plot a histogram of the values """
+        return {key: pol.plot_values_seaborn(bins=bins, show=show) for key, pol in self._zone.items()}
+
+    def plot_values_plotly(self, bins:int = 100, show:bool = True):
+        """ Plot a histogram of the values """
+
+        return {key: pol.plot_values_plotly(bins=bins, show=show) for key, pol in self._zone.items()}
+
+class Slope_analysis:
+    """ Class for slope analysis of in an array based on a trace vector.
+
+    This class allows to select cells inside a polygon or a buffer around a trace vector
+    and compute the slope of the dike. The slope is computed as the difference in elevation
+    between the trace and the cell divided by the distance to the trace.
+
+    The slope is computed for each cell inside the polygon or buffer and accessed in a Pandas Dataframe.
+
+    Plots of the slope distribution can be generated using seaborn or plotly.
+
+    The class is designed to be used with the WolfArray class and the vector class from the PyVertexvectors module.
+    """
+
+    def __init__(self, wa:WolfArray, trace:vector):
+
+        self._wa = wa
+        self._trace = trace
+
+        self._selection_poly = None
+        self._buffer_size = 0.0
+
+        self._selected_cells = None
+        self._slopes = None
+
+    @property
+    def slopes(self) -> pd.DataFrame:
+        """ Get the slopes as a pandas DataFrame """
+
+        if self._slopes is None:
+            self.compute_slopes()
+
+        if self._slopes is None:
+            raise ValueError("No slopes computed. Please call compute_slopes() first.")
+
+        return pd.DataFrame(self._slopes, columns=['Slope [m/m]'])
+
+    def select_cells(self, mode:Literal['polygon', 'buffer'] = 'polygon', **kwargs):
+        """ Select the cells inside the trace """
+
+        if mode == 'polygon':
+            if 'polygon' in kwargs:
+                self._selection_poly = kwargs['polygon']
+                self._select_cells_polygon(self._selection_poly)
+            else:
+                raise ValueError("No polygon provided. Please provide a polygon to select cells.")
+        elif mode == 'buffer':
+            if 'buffer' in kwargs:
+                self._buffer_size = kwargs['buffer']
+                self._select_cells_buffer(self._buffer_size)
+            else:
+                raise ValueError("No buffer size provided. Please provide a buffer size to select cells.")
+        else:
+            raise ValueError("Invalid mode. Please use 'polygon' or 'buffer'.")
+
+    def _select_cells_buffer(self, buffer_size:float = 0.0):
+        """ Select the cells inside the buffer of the trace """
+
+        self._buffer_size = buffer_size
+        self._selection_poly = self._trace.buffer(self._buffer_size, inplace=False)
+        self._select_cells_polygon(self._selection_poly)
+
+    def _select_cells_polygon(self, selection_poly:vector):
+        """ Select the cells inside the polygon """
+
+        self._selection_poly = selection_poly
+        self._selected_cells = self._wa.get_xy_inside_polygon(self._selection_poly)
+
+    def compute_slopes(self):
+        """ Get the slope of the dike """
+
+        if self._selected_cells is None:
+            self.select_cells()
+        if self._selected_cells is None:
+            raise ValueError("No cells selected. Please call select_cells() first.")
+
+        trace_ls = self._trace.linestring
+
+        def compute_cell_slope(curxy):
+            i, j = self._wa.get_ij_from_xy(curxy[0], curxy[1])
+            pt = Point(curxy[0], curxy[1])
+            distance_to_trace = trace_ls.distance(pt)
+            elevation_on_trace = trace_ls.interpolate(trace_ls.project(pt, normalized=True), normalized=True).z
+            if distance_to_trace == 0.0:
+                return 0.0
+            if elevation_on_trace == -99999.0:
+                return 0.0
+
+            return (elevation_on_trace - self._wa.array[i, j]) / distance_to_trace
+
+        self._slopes = [compute_cell_slope(curxy) for curxy in self._selected_cells]
+
+    def plot_slopes(self, show:bool = True, bins:int = 100,
+                    engine:Literal['seaborn', 'plotly'] = 'seaborn'):
+        """ Plot a histogram of the slopes """
+
+        if engine == 'seaborn':
+            return self.plot_slopes_seaborn(show=show, bins=bins)
+        elif engine == 'plotly':
+            return self.plot_slopes_plotly(show=show, bins=bins)
+
+    def plot_slopes_seaborn(self, bins:int = 100, show:bool = True):
+        """ Plot a histogram of the slopes """
+
+        import seaborn as sns
+        import matplotlib.pyplot as plt
+
+        fig, ax = plt.subplots()
+        sns.histplot(self.slopes, bins=bins,
+                     kde=True, ax=ax,
+                     stat="density")
+
+        ax.set_xlabel('Slope [m/m]')
+        ax.set_ylabel('Frequency')
+        ax.set_title('Slope distribution')
+
+        if show:
+            plt.show()
+
+        return (fig, ax)
+
+    def plot_slopes_plotly(self, bins:int = 100, show:bool = True):
+        """ Plot a histogram of the slopes """
+
+        import plotly.express as px
+
+        fig = px.histogram(self.slopes, x='Slope [m/m]',
+                           nbins=bins, title='Slope distribution',
+                           histnorm='probability density')
+
+        fig.update_layout(xaxis_title='Slope [m/m]', yaxis_title='Frequency')
+
+        if show:
+            fig.show(renderer='browser')
+
+        return fig

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 17
+        self.patch = 20
 
     def __str__(self):
 

wolfhece/lazviewer/__init__.py

@@ -1,13 +1,22 @@
-from . import _add_path
-from .viewer.viewer import *
-from .points.points import *
-from .points.expr import *
-from scipy.spatial import kdtree
-
-try:
-    from .processing.estimate_normals.estimate_normals import estimate_normals
-except Exception as e:
-    print(e)
-    print('Could not import estimate_normals')
-    print('Please installed the VC++ redistributable from https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads')
+import logging
+# Check __onWindows__ variable from wolfhece/__init__.py
+from ..os_check import isWindows
+
+if not isWindows():
+    # If not on Windows, raise an exception
+    logging.info('Not on Windows, ignoring the lazviewer package')
+
+else:
+    from . import _add_path
+    from .viewer.viewer import *
+    from .points.points import *
+    from .points.expr import *
+    from scipy.spatial import kdtree
+
+    try:
+        from .processing.estimate_normals.estimate_normals import estimate_normals
+    except Exception as e:
+        print(e)
+        print('Could not import estimate_normals')
+        print('Please installed the VC++ redistributable from https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads')
 

wolfhece/mesh2d/bc_manager.py

@@ -1050,7 +1050,7 @@ class BcManager(wx.Frame):
         """
         nb=0
         for valbc in bc.values():
-            if valbc != '99999.0':
+            if float(valbc) != 99999.0:
                 nb+=1
         return nb
 

wolfhece/mesh2d/cst_2D_boundary_conditions.py

@@ -30,7 +30,7 @@ class BCType_2D_GPU(Enum):
     """ Boundary conditions for 2D simulations with wolfgpu """
 
     # The numbers match the numbers in Wolf's simulations parameters.
-    # H    = (1,_('Water level [m]'))
+    H    = (1,_('Water level [m]'))
     QX   = (2,_('Flow rate along X [m²/s]'))
     QY   = (3,_('Flow rate along Y [m²/s]'))
     NONE = (4,_('None'))

wolfhece/mesh2d/gpu_2d.py

@@ -101,9 +101,12 @@ class Sim_2D_GPU():
             ('qx','Initial discharge along X [m^2/s]',WOLF_ARRAY_FULL_SINGLE),
             ('qy','Initial discharge along Y [m^2/s]',WOLF_ARRAY_FULL_SINGLE),
             ('bridge_roof','Bridge/Culvert (roof el.) [m]',WOLF_ARRAY_FULL_SINGLE),
+            ('water_surface_elevation','Water surface elevation [m]',WOLF_ARRAY_FULL_SINGLE),
         ]}
 
-        self.files_ic=['Initial water depth [m]','Initial discharge along X [m^2/s]','Initial discharge along Y [m^2/s]']
+        self.files_ic=['Initial water depth [m]',
+                       'Initial discharge along X [m^2/s]',
+                       'Initial discharge along Y [m^2/s]']
 
         # Files for the simulation
         self.files_others={'Generic file':[
@@ -166,7 +169,11 @@ class Sim_2D_GPU():
         else:
             return None
 
-    def __getitem__(self, key:Literal['nap', 'bathymetry', 'manning', 'infiltration_zones', 'h', 'qx', 'qy', 'bridge_roof']) -> WolfArray:
+    def __getitem__(self, key:Literal['nap', 'bathymetry',
+                                      'manning', 'infiltration_zones',
+                                      'h', 'qx', 'qy',
+                                      'bridge_roof',
+                                      'water_surface_elevation']) -> WolfArray:
         """ Get an array from the simulation """
 
         if self.is_loaded:
@@ -174,12 +181,33 @@ class Sim_2D_GPU():
                 descr = self._get_description_arrays()[self._get_name_arrays().index(key)]
 
                 if key not in self._cached_arrays:
-                    locarray = WolfArray(srcheader=self.get_header(),
-                                         np_source=self.sim.__getattribute__(key),
-                                         idx= descr,
-                                         nullvalue=self.nullvalues[key],
-                                         whichtype=self.files_array['Characteristics'][self._get_name_arrays().index(key)][2],
-                                         masknull=False)
+                    if key in ['water_surface_elevation']:
+
+                        top = self['bathymetry']
+                        h = self['h']
+
+                        locarray = top + h
+                        locarray.idx = descr
+                        locarray.nullvalue = self.nullvalues[key]
+
+                        def wse_write_all():
+                            top = self['bathymetry']
+                            new_h = self['water_surface_elevation'] - top
+
+                            # Filter negative values
+                            new_h.array.data[new_h.array.data < 0.] = 0.
+
+                            new_h.write_all(str(self.dir / "h.npy"))
+
+                        locarray.write_all = wse_write_all
+
+                    else:
+                        locarray = WolfArray(srcheader=self.get_header(),
+                                            np_source=self.sim.__getattribute__(key),
+                                            idx= descr,
+                                            nullvalue=self.nullvalues[key],
+                                            whichtype=self.files_array['Characteristics'][self._get_name_arrays().index(key)][2],
+                                            masknull=False)
                     locarray.loaded = True
                     locarray.filename = str(self.dir / f"{key}.npy")
 
@@ -354,7 +382,15 @@ class Sim_2D_GPU():
     def nullvalues(self) -> dict[str,int]:
         """ Define null values for the arrays """
 
-        return {'nap':0, 'bathymetry':99999., 'manning':0, 'infiltration_zones':0, 'h':0., 'qx':0., 'qy':0., 'bridge_roof':99999.}
+        return {'nap':0,
+                'bathymetry':99999.,
+                'manning':0,
+                'infiltration_zones':0,
+                'h':0.,
+                'qx':0.,
+                'qy':0.,
+                'bridge_roof':99999.,
+                'water_surface_elevation':0.}
 
     def verify_files(self):
         """ Verify the files """
@@ -649,4 +685,4 @@ class Sim_2D_GPU():
         self.sim._infiltration_zones[:,:]= tmp[:,:]
 
         tmp = np.load(self.dir / "NAP.npy")
-        self.sim._nap[:,:]= tmp[:,:]
+        self.sim._nap[:,:]= tmp[:,:]