wolfhece 2.1.114__py3-none-any.whl → 2.1.115__py3-none-any.whl

wolfhece/PyGui.py

@@ -2942,9 +2942,8 @@ class Wolf2DGPUModel(GenMapManager):
 
         if self._wp is not None:
             try:
-                if self._wp.Shown:
-                    self._sim.sim.from_wolfparam(self._wp)
-                    self._sim.sim._save_json()
+                self._sim.sim.from_wolfparam(self._wp)
+                self._sim.sim._save_json()
             except Exception as e:
                 self._wp = None
                 logging.debug(_('Error while saving parameters for simulation {}'.format(self._sim.sim.path.name)))
@@ -3047,6 +3046,14 @@ class Wolf2DGPUModel(GenMapManager):
 
         ret_infil=[]
         nmax = ma.max(self.arrays['infiltration_zones'].array)
+
+        if nmax == 99999:
+            logging.warning(_('Maximum index in infiltration zones is 99999. It seems to be a bad null value - Check the array !'))
+            logging.warning(_('Replacing 99999 by 0'))
+            self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array == 99999] = 0
+            nmax = ma.max(self.arrays['infiltration_zones'].array)
+            logging.info(_('New maximum index in infiltration zones is {}'.format(nmax)))
+
         nmin = ma.min(self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array > 0])
         l = ma.unique(self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array > 0]).tolist()
         chronos = self.sim.sim.infiltrations_chronology
@@ -3416,6 +3423,7 @@ class Wolf2DGPUModel(GenMapManager):
         """ Apply the changes """
 
         if self._wp is not None:
+            self._wp.apply_changes_to_memory()
             self._callbackwp()
 
     def show_properties(self):
@@ -3633,9 +3641,11 @@ class Wolf2DGPUModel(GenMapManager):
             # Apply changes
             # -------------
             self._btn_apply = wx.Button(self._panel, label=_('Apply changes'))
-            self._btn_apply.SetToolTip(_('Apply the changes to the memory (not saved on disk)'))
+            self._btn_apply.SetToolTip(_('Apply the changes to the memory (and save on disk)'))
             self._btn_apply.Bind(wx.EVT_BUTTON, self._apply_changes)
 
+            self._sizer_principal.Add(self._btn_apply, 1, wx.EXPAND)
+
             self._panel.SetSizer(self._sizer_gen)
 
             self._sizer_principal.Add(self._sizer_properties, 4, wx.EXPAND)

wolfhece/PyPalette.py

@@ -352,6 +352,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             if fn != '' and fn is not None:
                 plt.savefig(fn[:-4]+'_h.png', format='png')
 
+        fig.set_visible(False)
+
         return fig, ax
 
     def plot(self, fig: Figure, ax: plt.Axes):

wolfhece/PyVertexvectors.py

@@ -59,7 +59,7 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(tri)
         self.nb_pts = len(pts)
 
-        self._start_move = None
+        self._move_start = None
         self._move_step = None  # step for a move
         self._rotation_center = None
         self._rotation_step = None
@@ -580,6 +580,10 @@ class vectorproperties:
 
             self.used=True
 
+        # FIXME : to be changed
+        # if self.parent is not None:
+        #     self.closed = self.parent.closed
+
         self.init_extra()
 
     def init_extra(self):
@@ -716,7 +720,13 @@ class vectorproperties:
         self.color = getIfromRGB(props[('Draw','Color')])
         self.width = props[('Draw','Width')]
         self.style = props[('Draw','Style')]
+
+        old_closed = self.closed
         self.closed = props[('Draw','Closed')]
+
+        if old_closed != self.closed:
+            self.parent._reset_listogl()
+
         self.filled = props[('Draw','Filled')]
         self.transparent = props[('Draw','Transparent')]
         self.alpha = props[('Draw','Alpha')]
@@ -733,75 +743,15 @@ class vectorproperties:
         self.legendrelpos = props[('Legend','Relative position')]
 
         text = props[('Legend','Text')]
-        if text is _('Not used'):
-            pass
-        elif text == _('name'):
-            self.legendtext = self.parent.myname
-        elif text == _('first z'):
-            self.legendtext = str(self.parent.myvertices[0].z)
-        elif text == _('length2D'):
-            self.legendtext = str(self.parent.length2D)
-        elif text == _('length3D'):
-            self.legendtext = str(self.parent.length3D)
-        elif text == _('id'):
-            self.legendtext = str(self.parent.parentzone.myvectors.index(self.parent))
-        else:
-            self.legendtext = text
+
+        self.parent.set_legend_text(text)
 
         self.legendvisible = props[('Legend','Visible')]
 
         posx = props[('Legend','X')]
         posy = props[('Legend','Y')]
 
-        if posx == _('Not used'):
-            pass
-        elif posx.lower() == _('median'):
-            # valeur mediane selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.median(xy[:,0])
-        elif posx.lower() == _('mean'):
-            # valeur moyenne selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.mean(xy[:,0])
-        elif posx.lower() == _('min'):
-            # valeur minimale selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.min(xy[:,0])
-        elif posx.lower() == _('max'):
-            # valeur maximale selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.max(xy[:,0])
-        elif posx.lower() == _('first'):
-            self.legendx = self.parent.myvertices[0].x
-        elif posx.lower() == _('last'):
-            self.legendx = self.parent.myvertices[-1].x
-        else:
-            self.legendx = float(posx)
-
-        if posy == _('Not used'):
-            pass
-        elif posy.lower() == _('median'):
-            # valeur mediane selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.median(xy[:,1])
-        elif posy.lower() == _('mean'):
-            # valeur moyenne selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.mean(xy[:,1])
-        elif posy.lower() == _('min'):
-            # valeur minimale selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.min(xy[:,1])
-        elif posy.lower() == _('max'):
-            # valeur maximale selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.max(xy[:,1])
-        elif posy.lower() == _('first'):
-            self.legendy = self.parent.myvertices[0].y
-        elif posy.lower() == _('last'):
-            self.legendy = self.parent.myvertices[-1].y
-        else:
-            self.legendy = float(posy)
+        self.parent.set_legend_position(posx,posy)
 
         self.legendlength = props[('Legend','Length')]
         self.legendheight = props[('Legend','Height')]
@@ -816,9 +766,9 @@ class vectorproperties:
         move_step = props[('Move','Step [m]')]
 
         if posx != 99999. and posy != 99999.:
-            self.parent._start_move = (posx,posy)
+            self.parent._move_start = (posx,posy)
         else:
-            self.parent._start_move = None
+            self.parent._move_start = None
 
         if move_step != 99999.:
             self.parent._move_step = move_step
@@ -959,68 +909,7 @@ if :\n \
         Then, add the current properties to the UI
         """
         self._defaultprop()
-
-        self.myprops[('Draw','Color')]      = getRGBfromI(self.color)
-        self.myprops[('Draw','Width')]      = self.width
-        self.myprops[('Draw','Style')]      = self.style
-        self.myprops[('Draw','Closed')]     = self.closed
-        self.myprops[('Draw','Filled')]     = self.filled
-        self.myprops[('Draw','Transparent')]= self.transparent
-        self.myprops[('Draw','Alpha')]          = self.alpha
-        self.myprops[('Draw','Flash')]      = self.flash
-
-        self.myprops[('Legend','Visible')]  = self.legendvisible
-        self.myprops[('Legend','Text')]     = self.legendtext
-        self.myprops[('Legend','Relative position')]=self.legendrelpos
-        self.myprops[('Legend','X')]        = self.legendx
-        self.myprops[('Legend','Y')]        = self.legendy
-        self.myprops[('Legend','Bold')]     = self.legendbold
-        self.myprops[('Legend','Italic')]   = self.legenditalic
-
-        self.myprops[('Legend','Font name')]= self._convert_fontname2int(self.legendfontname)
-
-        self.myprops[('Legend','Font size')]= self.legendfontsize
-        self.myprops[('Legend','Color')]    = getRGBfromI(self.legendcolor)
-        self.myprops[('Legend','Underlined')]= self.legendunderlined
-
-        self.myprops[('Legend','Length')]     = self.legendlength
-        self.myprops[('Legend','Height')]     = self.legendheight
-        self.myprops[('Legend','Priority')]   = self.legendpriority
-        self.myprops[('Legend','Orientation')]= self.legendorientation
-
-        self.myprops[('Image','Attached image')] = str(self.attachedimage)
-        self.myprops[('Image','To show')] = self.imagevisible
-
-        if self.parent._rotation_center is not None:
-            self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
-            self.myprops[('Rotation','Center Y')] = self.parent._rotation_center[1]
-        else:
-            self.myprops[('Rotation','Center X')] = 99999.
-            self.myprops[('Rotation','Center Y')] = 99999.
-
-        if self.parent._rotation_step is not None:
-            self.myprops[('Rotation','Step [degree]')] = self.parent._rotation_step
-        else:
-            self.myprops[('Rotation','Step [degree]')] = 99999.
-
-        self.myprops[('Rotation', 'Angle [degree]')] = 0.
-
-        if self.parent._start_move is not None:
-            self.myprops[('Move','Start X')] = self.parent._start_move[0]
-            self.myprops[('Move','Start Y')] = self.parent._start_move[1]
-        else:
-            self.myprops[('Move','Start X')] = 99999.
-            self.myprops[('Move','Start Y')] = 99999.
-
-        if self.parent._move_step is not None:
-            self.myprops[('Move','Step [m]')] = self.parent._move_step
-        else:
-            self.myprops[('Move','Step [m]')] = 99999.
-
-        self.myprops[('Move','Delta X')] = 0.
-        self.myprops[('Move','Delta Y')] = 0.
-
-        self.myprops.Populate()
+        self.update_myprops()
         self.myprops.Layout()
         self.myprops.SetSizeHints(500,800)
         self.myprops.Show()
@@ -1068,7 +957,70 @@ if :\n \
             else:
                 return 'Arial'
 
+    def update_myprops(self):
+        """ Update the properties """
 
+        if self.myprops is not None:
+            self.myprops[('Draw','Color')]      = getRGBfromI(self.color)
+            self.myprops[('Draw','Width')]      = self.width
+            self.myprops[('Draw','Style')]      = self.style
+            self.myprops[('Draw','Closed')]     = self.closed
+            self.myprops[('Draw','Filled')]     = self.filled
+            self.myprops[('Draw','Transparent')]= self.transparent
+            self.myprops[('Draw','Alpha')]          = self.alpha
+            self.myprops[('Draw','Flash')]      = self.flash
+
+            self.myprops[('Legend','Visible')]  = self.legendvisible
+            self.myprops[('Legend','Text')]     = self.legendtext
+            self.myprops[('Legend','Relative position')]=self.legendrelpos
+            self.myprops[('Legend','X')]        = self.legendx
+            self.myprops[('Legend','Y')]        = self.legendy
+            self.myprops[('Legend','Bold')]     = self.legendbold
+            self.myprops[('Legend','Italic')]   = self.legenditalic
+
+            self.myprops[('Legend','Font name')]= self._convert_fontname2int(self.legendfontname)
+
+            self.myprops[('Legend','Font size')]= self.legendfontsize
+            self.myprops[('Legend','Color')]    = getRGBfromI(self.legendcolor)
+            self.myprops[('Legend','Underlined')]= self.legendunderlined
+
+            self.myprops[('Legend','Length')]     = self.legendlength
+            self.myprops[('Legend','Height')]     = self.legendheight
+            self.myprops[('Legend','Priority')]   = self.legendpriority
+            self.myprops[('Legend','Orientation')]= self.legendorientation
+
+            self.myprops[('Image','Attached image')] = str(self.attachedimage)
+            self.myprops[('Image','To show')] = self.imagevisible
+
+            if self.parent._rotation_center is not None:
+                self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
+                self.myprops[('Rotation','Center Y')] = self.parent._rotation_center[1]
+            else:
+                self.myprops[('Rotation','Center X')] = 99999.
+                self.myprops[('Rotation','Center Y')] = 99999.
+
+            if self.parent._rotation_step is not None:
+                self.myprops[('Rotation','Step [degree]')] = self.parent._rotation_step
+            else:
+                self.myprops[('Rotation','Step [degree]')] = 99999.
+
+            self.myprops[('Rotation', 'Angle [degree]')] = 0.
+
+            if self.parent._move_start is not None:
+                self.myprops[('Move','Start X')] = self.parent._move_start[0]
+                self.myprops[('Move','Start Y')] = self.parent._move_start[1]
+            else:
+                self.myprops[('Move','Start X')] = 99999.
+                self.myprops[('Move','Start Y')] = 99999.
+
+            if self.parent._move_step is not None:
+                self.myprops[('Move','Step [m]')] = self.parent._move_step
+            else:
+                self.myprops[('Move','Step [m]')] = 99999.
+
+            self.myprops[('Move','Delta X')] = 0.
+            self.myprops[('Move','Delta Y')] = 0.
+            self.myprops.Populate()
 class vector:
     """
     Objet de gestion d'informations vectorielles
@@ -1104,7 +1056,7 @@ class vector:
 
         self.myname=''
         self.is2D = is2D  # Force a 2D interpretation of the vertices, even if a z coordinate is present.
-        self.closed=False # True if the vector is a polygon. !! The last vertex is not necessarily the same as the first one. In this case, some routines will add a virtual segment at the end. !!
+        # self.closed=False # True if the vector is a polygon. !! The last vertex is not necessarily the same as the first one. In this case, some routines will add a virtual segment at the end. !!
 
         self.mytree = None
 
@@ -1155,7 +1107,7 @@ class vector:
             self.myprop=vectorproperties(parent=self)
 
         self._cache_vertices = None
-        self._start_move = None
+        self._move_start = None
         self._move_step = None
 
         self._rotation_center = None
@@ -1176,6 +1128,103 @@ class vector:
         if fromnumpy is not None:
             self.add_vertices_from_array(fromnumpy)
 
+    def set_legend_text(self, text:str):
+        """ Set the legend text """
+
+        if text is _('Not used'):
+            pass
+        elif text == _('name'):
+            self.myprop.legendtext = self.myname
+        elif text == _('first z'):
+            if self.nbvertices>0:
+                self.myprop.legendtext = str(self.myvertices[0].z)
+            else:
+                self.myprop.legendtext = ''
+        elif text == _('length2D'):
+            self.myprop.legendtext = str(self.length2D)
+        elif text == _('length3D'):
+            self.myprop.legendtext = str(self.length3D)
+        elif text == _('id'):
+            if self.parentzone is not None:
+                self.myprop.legendtext = str(self.parentzone.myvectors.index(self))
+            else:
+                self.myprop.legendtext = ''
+        else:
+            self.myprop.legendtext = str(text)
+
+        self.myprop.update_myprops()
+
+    def set_legend_position(self, x:str | float, y:str | float):
+        """ Set the legend position """
+
+        if isinstance(x, str):
+            if x == _('Not used'):
+                pass
+            elif x.lower() == _('median'):
+                # valeur mediane selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.median(xy[:,0])
+            elif x.lower() == _('mean'):
+                # valeur moyenne selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.mean(xy[:,0])
+            elif x.lower() == _('min'):
+                # valeur minimale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.min(xy[:,0])
+            elif x.lower() == _('max'):
+                # valeur maximale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.max(xy[:,0])
+            elif x.lower() == _('first'):
+                self.myprop.legendx = self.myvertices[0].x
+            elif x.lower() == _('last'):
+                self.myprop.legendx = self.myvertices[-1].x
+            else:
+                self.myprop.legendx = float(x)
+        elif isinstance(x, float):
+            self.myprop.legendx = x
+
+        if isinstance(y, str):
+            if y == _('Not used'):
+                pass
+            elif y.lower() == _('median'):
+                # valeur mediane selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.median(xy[:,1])
+            elif y.lower() == _('mean'):
+                # valeur moyenne selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.mean(xy[:,1])
+            elif y.lower() == _('min'):
+                # valeur minimale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.min(xy[:,1])
+            elif y.lower() == _('max'):
+                # valeur maximale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.max(xy[:,1])
+            elif y.lower() == _('first'):
+                self.myprop.legendy = self.myvertices[0].y
+            elif y.lower() == _('last'):
+                self.myprop.legendy = self.myvertices[-1].y
+            else:
+                self.myprop.legendy = float(y)
+        elif isinstance(y, float):
+            self.myprop.legendy = y
+
+        self.myprop.update_myprops()
+
+    @property
+    def closed(self) -> bool:
+        return self.myprop.closed
+
+    @closed.setter
+    def closed(self, value:bool):
+        self.myprop.closed = value
+        if self.myprop.myprops is not None:
+            self.myprop.myprops.Populate()
+
     def set_cache(self):
         """ Set the cache for the vertices """
 
@@ -1729,6 +1778,11 @@ class vector:
             self.add_vertex(self.myvertices[0])
         self.closed=True
 
+    def force_to_close(self):
+        """ Force the vector to be closed """
+
+        self.close_force()
+
     def _nblines(self):
         """
         routine utile pour l'initialisation sur base de 'lines'
@@ -1842,15 +1896,21 @@ class vector:
 
         return len(not_in_use) > 0
 
-    def get_subpolygons(self):
+    def get_subpolygons(self) -> list[list[wolfvertex]]:
         """
         Return a list of polygons from the vector
 
         If the vector has no interior, the list contains the whole vector as a polygon
         """
 
+        if self.nbvertices == 0:
+            return []
+
         if self.myprop.filled:
-            return [self.myvertices]
+            if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
+                return [self.myvertices + [self.myvertices[0]]]
+            else:
+                return [self.myvertices]
 
         else:
             if self.has_interior:
@@ -1874,7 +1934,10 @@ class vector:
 
                 return alls
             else:
-                return [self.myvertices]
+                if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
+                    return [self.myvertices + [self.myvertices[0]]]
+                else:
+                    return [self.myvertices]
 
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """
@@ -3077,7 +3140,7 @@ class zone:
         self.has_legend = False # indicate if at least one vector in the zone has a legend
         self.has_image  = False # indicate if at least one vector in the zone has an image
 
-        self._start_move = None # starting point for a move
+        self._move_start = None # starting point for a move
         self._move_step = None  # step for a move
         self._rotation_center = None # center of rotation
         self._rotation_step = None   # step for rotation
@@ -3115,6 +3178,22 @@ class zone:
             # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    def set_legend_text(self, text:str):
+        """
+        Set the legend text for the zone
+        """
+
+        for curvect in self.myvectors:
+            curvect.set_legend_text(text)
+
+    def set_legend_position(self, x, y):
+        """
+        Set the legend position for the zone
+        """
+
+        for curvect in self.myvectors:
+            curvect.set_legend_position(x, y)
+
     @property
     def area(self):
         """ Compute the area of the zone """
@@ -3134,7 +3213,7 @@ class zone:
         for curvect in self.myvectors:
             curvect.clear_cache()
 
-        self._start_move = None
+        self._move_start = None
         self._move_step = None
         self._rotation_center = None
         self._rotation_step = None
@@ -4985,7 +5064,7 @@ class Zones(wx.Frame, Element_To_Draw):
         self.ty=ty
         self.myzones=[]
 
-        self._start_move = None
+        self._move_start = None
         self._move_step = None
         self._rotation_center = None
         self._rotation_step = None
@@ -5140,6 +5219,21 @@ class Zones(wx.Frame, Element_To_Draw):
                 if names.count(curzone.myname)>1:
                     curzone.myname += '_'+str(idx)
 
+    def set_legend_text(self, text:str):
+        """
+        Set the legend text for the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_legend_text(text)
+
+    def set_legend_position(self, x, y):
+        """
+        Set the legend position for the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_legend_position(x, y)
 
     @property
     def nbzones(self):
@@ -7390,9 +7484,9 @@ class Zones(wx.Frame, Element_To_Draw):
         posx = self._myprops[('Move','Start X')]
         posy = self._myprops[('Move','Start Y')]
         if posx != 99999. and posy != 99999.:
-            self._start_move = (posx,posy)
+            self._move_start = (posx,posy)
         else:
-            self._start_move = None
+            self._move_start = None
 
         step = self._myprops[('Move','Step [m]')]
         if step != 99999.:
@@ -7461,9 +7555,9 @@ class Zones(wx.Frame, Element_To_Draw):
 
         self._myprops['Rotation', 'Angle [degree]'] = 0.
 
-        if self._start_move is not None:
-            self._myprops[('Move', 'Start X')] = self._start_move[0]
-            self._myprops[('Move', 'Start Y')] = self._start_move[1]
+        if self._move_start is not None:
+            self._myprops[('Move', 'Start X')] = self._move_start[0]
+            self._myprops[('Move', 'Start Y')] = self._move_start[1]
         else:
             self._myprops[('Move', 'Start X')] = 99999.
             self._myprops[('Move', 'Start Y')] = 99999.

wolfhece/Results2DGPU.py

@@ -156,6 +156,7 @@ class wolfres2DGPU(Wolfresults_2D):
                  store = None):
 
         fname = Path(fname)
+        self._nap = None
 
         if not fname.name.lower() == 'simul_gpu_results':
             for curdir in fname.iterdir():
@@ -234,6 +235,7 @@ class wolfres2DGPU(Wolfresults_2D):
             curblock.qx = WolfArray(path.join(sim_path, 'simul.qxbin'))
             curblock.qy = WolfArray(path.join(sim_path, 'simul.qybin'))
             curblock.rough_n = WolfArray(path.join(sim_path, 'simul.frot'))
+            self._nap = WolfArray(path.join(sim_path, 'simul.napbin'))
 
         else:
 
@@ -304,6 +306,13 @@ class wolfres2DGPU(Wolfresults_2D):
                 logging.error(_('No manning file found in the simulation directory -- Results will not be shown in viewer'))
                 return -8
 
+            pathnap = sim_path / params['maps']['NAP']
+            if pathnap.exists():
+                self._nap = WolfArray(pathnap)
+            else:
+                logging.error(_('No nap file found in the simulation directory -- Results will not be shown in viewer'))
+                return -9
+
         # Force nullvalue to zero because it will influence the size of the arrow in vector field views
         curblock.qx.nullvalue = 0.
         curblock.qy.nullvalue = 0.
@@ -312,7 +321,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
         self.head_blocks[getkeyblock(0)] = curblock.top.get_header()
 
-        to_check =[curblock.waterdepth, curblock.qx, curblock.qy, curblock.rough_n]
+        to_check =[curblock.waterdepth, curblock.qx, curblock.qy, curblock.rough_n, self._nap]
         check = False
         for curarray in to_check:
             check |= curarray.dx != curblock.top.dx
@@ -324,7 +333,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
         if check:
             if (sim_path / 'simul.top').exists():
-                logging.error(_("Inconsistent header file in .top, .qxbin, .qybin or .frot files"))
+                logging.error(_("Inconsistent header file in .top, .qxbin, .qybin, .napbin or .frot files"))
                 logging.error(_("Forcing information into memory from the .top file -- May corrupt spatial positionning -- Please check your data !"))
             elif pathbathy.exists():
                 logging.error(_("Inconsistent header file"))
@@ -639,17 +648,40 @@ class wolfres2DGPU(Wolfresults_2D):
                 logging.error(_('Bad index for initial conditions'))
                 return
 
+        nap = self._nap
+
         self.set_currentview(views_2D.WATERDEPTH)
 
         hini = self.as_WolfArray()
+        hini.nullvalue = 0.
+        hini.set_nullvalue_in_mask()
+
+        if hini[nap == 1].max() > 0.:
+            logging.warning(_('Some cells are not dry in the initial conditions outside the NAP areas'))
+            logging.warning(_('Setting the water depth to zero in these cells'))
+            hini[nap == 0] = 0.
 
         self.set_currentview(views_2D.QX)
 
         qxini = self.as_WolfArray()
+        qxini.nullvalue = 0.
+        qxini.set_nullvalue_in_mask()
 
         self.set_currentview(views_2D.QY)
 
         qyini = self.as_WolfArray()
+        qyini.nullvalue = 0.
+        qyini.set_nullvalue_in_mask()
+
+        if qxini[nap == 1].max() > 0.:
+            logging.warning(_('Some cells are not dry in the initial conditions outside the NAP areas'))
+            logging.warning(_('Setting the water depth to zero in these cells'))
+            qxini[nap == 0] = 0.
+
+        if qyini[nap == 1].max() > 0.:
+            logging.warning(_('Some cells are not dry in the initial conditions outside the NAP areas'))
+            logging.warning(_('Setting the water depth to zero in these cells'))
+            qyini[nap == 0] = 0.
 
         if (hini is not None) and (qxini is not None) and (qyini is not None):
 
@@ -657,9 +689,10 @@ class wolfres2DGPU(Wolfresults_2D):
             # qxini = qxini.as_WolfArray()
             # qyini = qyini.as_WolfArray()
 
-            hini.write_all(self.filename.parent  / 'h.npy')
-            qxini.write_all(self.filename.parent / 'qx.npy')
-            qyini.write_all(self.filename.parent / 'qy.npy')
+            dir = Path(self.filename).parent
+            hini.write_all(dir  / 'h.npy')
+            qxini.write_all(dir / 'qx.npy')
+            qyini.write_all(dir / 'qy.npy')
 
             logging.info(_('Initial conditions saved as Numpy files'))
         else: