wolfhece 2.2.16__py3-none-any.whl → 2.2.18__py3-none-any.whl

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 = 16
+        self.patch = 18
 
     def __str__(self):
 

wolfhece/assets/mesh.py

@@ -16,7 +16,7 @@ class Mesh2D(header_wolf):
         self.shape = src_header.shape
         self._factor = None
 
-    def plot_cells(self, ax:Axes=None, color='black', **kwargs):
+    def plot_cells(self, ax:Axes=None, transpose:bool= False, color='black', **kwargs):
         """ Plot the grid of the mesh.
         """
 
@@ -27,13 +27,28 @@ class Mesh2D(header_wolf):
 
         [xmin, xmax], [ymin, ymax] = self.get_bounds()
 
-        for y in np.linspace(ymin, ymax, endpoint=True, num=self.nby + 1):
-            ax.plot([xmin, xmax], [y, y], color=color, **kwargs)
+        if transpose:
+
+            # plot the grid of the mesh in a transposed way
+            for x in np.linspace(xmin, xmax, endpoint=True, num=self.nbx + 1):
+                ax.plot([ymin, ymax], [x, x], color=color, **kwargs)
 
-        for x in np.linspace(xmin, xmax, endpoint=True, num=self.nbx + 1):
-            ax.plot([x, x], [ymin, ymax], color=color, **kwargs)
+            for y in np.linspace(ymin, ymax, endpoint=True, num=self.nby + 1):
+                ax.plot([y, y], [xmin, xmax], color=color, **kwargs)
+
+            self.set_aspect_labels_matrice(ax=ax, **kwargs)
+
+        else:
+
+            # plot the grid of the mesh
+            for y in np.linspace(ymin, ymax, endpoint=True, num=self.nby + 1):
+                ax.plot([xmin, xmax], [y, y], color=color, **kwargs)
+
+            for x in np.linspace(xmin, xmax, endpoint=True, num=self.nbx + 1):
+                ax.plot([x, x], [ymin, ymax], color=color, **kwargs)
+
+            self.set_aspect_labels(ax=ax, **kwargs)
 
-        self.set_aspect_labels(ax=ax, **kwargs)
         return fig, ax
 
     def plot_center_cells(self, ax:Axes=None, color='black', linestyle='--', **kwargs):
@@ -77,6 +92,34 @@ class Mesh2D(header_wolf):
 
         return fig, ax
 
+    def set_ticks_as_matrice(self, ax:Axes=None, Fortran_type:bool = True, **kwargs):
+        """ Set the ticks of the axis as the row and column of a matrice """
+
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
+        [xmin, xmax], [ymin, ymax] = self.get_bounds()
+
+        if Fortran_type:
+            x_ticks = [f'{i}' for i in range(1,self.nbx+1)]
+            y_ticks = [f'{i}' for i in range(1,self.nby+1)]
+        else:
+            x_ticks = [f'{i}' for i in range(self.nbx)]
+            y_ticks = [f'{i}' for i in range(self.nby)]
+
+        ax.set_yticks(np.linspace(xmin+self.dx/2., xmax-self.dx/2., endpoint=True, num=self.nbx))
+        ax.set_xticks(np.linspace(ymin+self.dy/2., ymax-self.dy/2., endpoint=True, num=self.nby))
+        
+        x_ticks.reverse()
+        ax.set_yticklabels(x_ticks)
+        ax.set_xticklabels(y_ticks)
+
+        self.set_aspect_labels_matrice(ax=ax, **kwargs)
+
+        return fig, ax
+
     def plot_circle_at_centers(self, ax:Axes=None, color='black', radius:float=None, **kwargs):
         """ Plot circles at the center of the cells.
         """
@@ -124,6 +167,64 @@ class Mesh2D(header_wolf):
         self.set_aspect_labels(ax=ax, **kwargs)
 
         return fig, ax
+    
+    def plot_memoryposition_at_centers(self, ax:Axes=None, 
+                                       transpose=False, 
+                                       Fortran_type:bool = True, 
+                                       f_contiguous:bool = True,
+                                       **kwargs):
+        """ Plot the position of the cells at the center of the cells.
+        """
+
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
+        [xmin, xmax], [ymin, ymax] = self.get_bounds()
+
+        if transpose:
+            k = 0
+            if Fortran_type:
+                k+=1
+
+            all_y = list(np.linspace(xmin + self.dx/2., xmax - self.dx/2., endpoint=True, num=self.nbx))
+            all_x = list(np.linspace(ymin + self.dy/2., ymax - self.dy/2., endpoint=True, num=self.nby))
+
+            all_y.reverse()
+
+            if f_contiguous:
+
+                for x in all_x:
+                    for y in all_y:
+
+                        ax.text(x, y, f'{k}', horizontalalignment='center', verticalalignment='center', **kwargs)
+                        k+=1
+            else:
+
+                for y in all_y:
+                    for x in all_x:
+
+                        ax.text(x, y, f'{k}', horizontalalignment='center', verticalalignment='center', **kwargs)
+                        k+=1
+                        
+            self.set_aspect_labels_matrice(ax=ax, **kwargs)
+
+        else:
+            
+            k = 0
+            if Fortran_type:
+                k+=1
+
+            for y in np.linspace(ymin + self.dy/2., ymax - self.dy/2., endpoint=True, num=self.nby):
+                for x in np.linspace(xmin + self.dx/2., xmax - self.dx/2., endpoint=True, num=self.nbx):
+
+                    ax.text(x, y, f'{k}', horizontalalignment='center', verticalalignment='center', **kwargs)
+                    k+=1
+
+            self.set_aspect_labels(ax=ax, **kwargs)
+
+        return fig, ax
 
     def plot_indices_at_bordersX(self, ax:Axes=None, Fortran_type:bool = True, **kwargs):
         """ Plot the indices of the cells at the borders of the cells.
@@ -599,6 +700,27 @@ class Mesh2D(header_wolf):
         ax.set_xlabel('X (m)')
         ax.set_ylabel('Y (m)')
         return fig, ax
+    
+    def set_aspect_labels_matrice(self, ax:Axes=None, **kwargs):
+        """ Set the aspect of the plot to be equal.
+        """
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
+        [xmin, xmax], [ymin, ymax] = self.get_bounds()
+
+        ax.set_aspect('equal')
+        ax.set_ylim(xmin, xmax)
+        ax.set_xlim(ymin, ymax)
+        ax.set_xlabel('columns')
+        ax.set_ylabel('rows')
+
+        #set x ais on the upper side
+        ax.xaxis.set_ticks_position('top')
+        ax.xaxis.set_label_position('top')
+        return fig, ax
 
     def zeros(self):
         """ Return a 2D array of zeros with the shape of the mesh.

wolfhece/hydrometry/kiwis_wolfgui.py

@@ -13,14 +13,13 @@ import logging
 
 from ..drawing_obj import Element_To_Draw
 
-# try:
-#     # Trying to import the hydrometry_hece module from the hydrometry_hece package
-#     # containing the KEY access to the SPW server
-#     from ..hydrometry_hece.kiwis_hece import hydrometry_hece as hydrometry
-# except:
-#     # If the hydrometry_hece module is not found, we import the hydrometry module from the hydrometry package
-#     from .kiwis import hydrometry
-from .kiwis import hydrometry
+try:
+    # Trying to import the hydrometry_hece module from the hydrometry_hece package
+    # containing the KEY access to the SPW server
+    from ..hydrometry_hece.kiwis_hece import hydrometry_hece as hydrometry
+except:
+    # If the hydrometry_hece module is not found, we import the hydrometry module from the hydrometry package
+    from .kiwis import hydrometry
 
 from .kiwis_gui import hydrometry_gui
 from ..PyVertex import cloud_vertices, wolfvertex, Cloud_Styles, getIfromRGB, getRGBfromI

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/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[:,:]