wolfhece 2.1.120__py3-none-any.whl → 2.1.122__py3-none-any.whl

wolfhece/scenario/config_manager.py

@@ -56,7 +56,7 @@ except:
 # mann_*.tif
 # infil_*.tif
 
-ACCEPTED_PREFIX = ['bath_', 'mann_', 'infil_', 'roof_']
+ACCEPTED_PREFIX = ['bath_', 'mann_', 'infil_', 'roof_', 'deck_']
 
 def delete_folder(pth:Path):
     for sub in pth.iterdir():
@@ -472,7 +472,14 @@ class Config_Manager_2D_GPU:
 
         logging.info(_('Number of tif files : {}'.format(len(list_tif))))
 
-        standard_files = ['bathymetry.tif', 'manning.tif', 'infiltration.tif', 'h.tif', 'qx.tif', 'qy.tif', 'roof.tif']
+        standard_files = ['bathymetry.tif', 
+                          'manning.tif', 
+                          'infiltration.tif', 
+                          'h.tif', 
+                          'qx.tif', 
+                          'qy.tif', 
+                          'roof.tif', 
+                          'deck.tif']
 
         log = ''
         for curtif in list_tif:
@@ -509,6 +516,12 @@ class Config_Manager_2D_GPU:
                         loclog += _('Did you mean "roof_" ?') + '\n'
                         break
 
+                tests = ['dec_', 'dek_', 'dck_', 'deeck_', 'decq_']
+                for test in tests:
+                    if curtif.name.lower().startswith(test):
+                        loclog += _('Did you mean "deck_" ?') + '\n'
+                        break
+
                 logging.warning(loclog)
 
                 log += loclog
@@ -772,7 +785,7 @@ class Config_Manager_2D_GPU:
 
         return curdict
 
-    def _select_tif_partname(self, curdict:dict, tifstr:Literal['bath_', 'mann_', 'infil_', 'roof_']):
+    def _select_tif_partname(self, curdict:dict, tifstr:Literal['bath_', 'mann_', 'infil_', 'roof_', 'deck_']):
         """ Select tif files with a 'str' as name's prefix """
 
         assert tifstr in ACCEPTED_PREFIX, _('Bad prefix !')
@@ -785,6 +798,8 @@ class Config_Manager_2D_GPU:
             forced_add = ['infiltration.tif']
         elif tifstr == 'roof_':
             forced_add = ['roof.tif']
+        elif tifstr == 'deck_':
+            forced_add = ['deck.tif']
 
         tif_list = [curtif for curtif in curdict[GPU_2D_file_extensions.TIF.value] \
                     if curtif.name.lower().startswith(tifstr) or \
@@ -807,14 +822,16 @@ class Config_Manager_2D_GPU:
         all_tif_mann = [self._select_tif_partname(curdict, 'mann_') for curdict in curdicts]
         all_tif_infil = [self._select_tif_partname(curdict, 'infil_') for curdict in curdicts]
         all_tif_roof = [self._select_tif_partname(curdict, 'roof_') for curdict in curdicts]
+        all_tif_deck = [self._select_tif_partname(curdict, 'deck_') for curdict in curdicts]
 
         # flatten list of lists
         all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist]
         all_tif_mann = [curel for curlist in all_tif_mann if len(curlist)>0 for curel in curlist]
         all_tif_infil = [curel for curlist in all_tif_infil if len(curlist)>0 for curel in curlist]
         all_tif_roof = [curel for curlist in all_tif_roof if len(curlist)>0 for curel in curlist]
+        all_tif_deck = [curel for curlist in all_tif_deck if len(curlist)>0 for curel in curlist]
 
-        for cur_lst in [all_tif_bath, all_tif_mann, all_tif_infil, all_tif_roof]:
+        for cur_lst in [all_tif_bath, all_tif_mann, all_tif_infil, all_tif_roof, all_tif_deck]:
             for cur_tif in cur_lst:
                 curarray:WolfArray = WolfArray(cur_tif)
                 if curarray.nullvalue != 99999.:
@@ -840,12 +857,14 @@ class Config_Manager_2D_GPU:
         all_tif_mann = [self._select_tif_partname(curdict, 'mann_') for curdict in curdicts]
         all_tif_infil = [self._select_tif_partname(curdict, 'infil_') for curdict in curdicts]
         all_tif_roof = [self._select_tif_partname(curdict, 'roof_') for curdict in curdicts]
+        all_tif_deck = [self._select_tif_partname(curdict, 'deck_') for curdict in curdicts]
 
         # flatten list of lists
         all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist]
         all_tif_mann = [curel for curlist in all_tif_mann if len(curlist)>0 for curel in curlist]
         all_tif_infil = [curel for curlist in all_tif_infil if len(curlist)>0 for curel in curlist]
         all_tif_roof = [curel for curlist in all_tif_roof if len(curlist)>0 for curel in curlist]
+        all_tif_deck = [curel for curlist in all_tif_deck if len(curlist)>0 for curel in curlist]
 
         # création du fichier vrt
         create_vrt_from_files_first_based(all_tif_bath, from_path / '__bath_assembly.vrt')
@@ -861,9 +880,14 @@ class Config_Manager_2D_GPU:
         else:
             logging.info(_('No roof files found ! -> no __roof_assembly.vrt file created !'))
 
+        if len(all_tif_deck)>0:
+            create_vrt_from_files_first_based(all_tif_deck, from_path / '__deck_assembly.vrt')
+        else:
+            logging.info(_('No deck files found ! -> no __deck_assembly.vrt file created !'))
+
     def create_vec(self,
                    from_path:Path,
-                   which:Literal['bath_', 'mann_', 'infil_', 'roof_'] = 'bath_') -> Zones:
+                   which:Literal['bath_', 'mann_', 'infil_', 'roof_', 'deck_'] = 'bath_') -> Zones:
         """ Create a vec file from a path """
 
         assert which in ACCEPTED_PREFIX, _('Bad prefix !')
@@ -923,17 +947,17 @@ class Config_Manager_2D_GPU:
     def translate_vrt2tif(self, from_path:Path):
         """ Translate vrt to tif """
 
-        vrtin = ['__bath_assembly.vrt', '__mann_assembly.vrt', '__infil_assembly.vrt', '__roof_assembly.vrt']
-        fout  = ['__bathymetry.tif'   , '__manning.tif', '__infiltration.tif', '__roof.tif']
+        vrtin = ['__bath_assembly.vrt', '__mann_assembly.vrt', '__infil_assembly.vrt', '__roof_assembly.vrt', '__deck_assembly.vrt']
+        fout  = ['__bathymetry.tif'   , '__manning.tif', '__infiltration.tif', '__roof.tif', '__deck.tif']
 
         for curin, curout in zip(vrtin, fout):
             if (from_path / curin).exists():
                 translate_vrt2tif(from_path / curin, from_path / curout)
 
-    def apply_scripts_bath_mann_inf_roof(self, from_path:Path):
+    def apply_scripts_bath_mann_inf_roof_deck(self, from_path:Path):
         """ Apply all scripts """
 
-        filenames = ['__bathymetry.tif', '__manning.tif', '__infiltration.tif', '__roof.tif']
+        filenames = ['__bathymetry.tif', '__manning.tif', '__infiltration.tif', '__roof.tif', '__deck.tif']
 
         # check if present on disk
         if not all([(from_path / curfile).exists() for curfile in filenames]):
@@ -946,13 +970,15 @@ class Config_Manager_2D_GPU:
 
         arrays = [WolfArray(from_path / curfile) for curfile in filenames]
 
-        self._apply_scripts_update_topo_maning_inf_roof(from_path, arrays[0], arrays[1], arrays[2], arrays[3])
+        self._apply_scripts_update_topo_maning_inf_roof_deck(from_path, arrays[0], arrays[1], arrays[2], arrays[3], arrays[4])
 
         # write the files
         arrays[0].write_all(from_path / '__bathymetry_after_scripts.tif')
         arrays[1].write_all(from_path / '__manning_after_scripts.tif')
         arrays[2].write_all(from_path / '__infiltration_after_scripts.tif')
         arrays[3].write_all(from_path / '__roof_after_scripts.tif')
+        arrays[4].write_all(from_path / '__deck_after_scripts.tif')
+
 
     def _import_scripts(self, from_path:Path, which) -> list[types.ModuleType]:
         """ List all modules in structure and import them.
@@ -994,24 +1020,25 @@ class Config_Manager_2D_GPU:
 
         return imported_mod
 
-    def _import_scripts_topo_manning_inf_roof(self, from_path:Path) -> list[types.ModuleType]:
+    def _import_scripts_topo_manning_inf_roof_deck(self, from_path:Path) -> list[types.ModuleType]:
         """ import all topo and manning scripts from a path """
 
         return self._import_scripts(from_path, WOLF_UPDATE)
 
-    def _apply_scripts_update_topo_maning_inf_roof(self,
+    def _apply_scripts_update_topo_maning_inf_roof_deck(self,
                                               modules:list[types.ModuleType] | Path | str,
                                               array_bat:WolfArray,
                                               array_mann:WolfArray,
                                               array_inf:WolfArray,
-                                              array_roof:WolfArray):
+                                              array_roof:WolfArray,
+                                              array_deck:WolfArray):
         """ Apply all scripts from a list of modules """
 
         if isinstance(modules, str):
             modules = Path(modules)
 
         if isinstance(modules, Path):
-            modules = self._import_scripts_topo_manning_inf_roof(modules)
+            modules = self._import_scripts_topo_manning_inf_roof_deck(modules)
 
         for curmod in modules:
             instmod = curmod.Update_Sim_Scenario()
@@ -1047,6 +1074,13 @@ class Config_Manager_2D_GPU:
             except Exception as e:
                 logging.error(_('An error occured during roof script - {}!').format(e))
 
+            try:
+                if not hasattr(instmod, "update_deck"):
+                    logging.info(_('No update_deck method found in the script {}!').format(curmod))
+                else:
+                    instmod.update_deck(array_deck)
+            except Exception as e:
+                logging.error(_('An error occured during deck script - {}!').format(e))
 
     def _import_scripts_bc(self, from_path:Path) -> list[types.ModuleType]:
         """ Import all BC's scripts from a path """
@@ -1165,23 +1199,81 @@ class Config_Manager_2D_GPU:
         else:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
+    def create_void_deck(self):
+        """ create void deck file """
+
+        if (self.workingdir / 'bathymetry.tif').exists():
+            locheader = self.get_header()
+            deck = WolfArray(srcheader=locheader, whichtype= WOLF_ARRAY_FULL_SINGLE)
+            deck.array.data[:,:] = 99999.
+            deck.nullvalue = 99999.
+            deck.write_all(str(self.workingdir / 'deck.tif'))
+
+            if (self.workingdir / 'deck.tif').exists():
+                logging.info(_('deck.tif created and set to 99999. ! -- Please edit it !'))
+            else:
+                logging.error(_("deck.tif not created ! --  Does 'bathymetry.tif' or any '.tif' file exist in the root directory ?"))
+        else:
+            logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
+
 
-    def verify_bath_roof_deck(self, bathymetry:WolfArray, bridge_roof:WolfArray):
+    def combine_bath_roof_deck(self, bathymetry:WolfArray, 
+                               bridge_roof:WolfArray, bridge_deck:WolfArray,
+                               threshold:float = .05) -> str:
         """ Verify bathymetry, roof and deck """
 
+        ret = ''
         if bridge_roof is None:
-            return
-
+            ret	+= _('No bridge roof found !')
+        if bridge_deck is None:
+            ret	+= _('No bridge deck found !')
+
+        if ret != '':
+            logging.error(ret)
+            return ret
+        
         # si la matrice de toit de pont est plus basse que la bathymétrie, on met à 99999
         # la bathymétrie et le toit de pont.
         # Ainsi, ces maille seront infranchissables.
-        # Cale peut être utile pour discrétiser les piles dans les données du toit, plutôt que de les
+        # Cela peut être utile pour discrétiser les piles dans les données du toit, plutôt que de les
         # laisser inclure dans un fichier bath_ séparé.
-        mask = bridge_roof.array.data < bathymetry.array.data
-        bridge_roof.array.data[mask] = 99999.
-        bathymetry.array.data[mask]  = 99999.
-
 
+        mask_roof = np.where(bridge_roof.array.data != 99999.)
+        mask_deck = np.where(bridge_deck.array.data != 99999.)
+        if mask_roof[0].shape != mask_deck[0].shape:
+            ret += _('Roof and deck have different shapes !\n')
+            ret += _(' -- If not desired, please check your data\n')
+
+        mask = np.where(bridge_roof.array.data > bridge_deck.array.data)
+        if mask[0].shape[0] > 0:
+            ret += _('Some roof values are higher than deck values !\n')
+            ret += _('-- Roof values will be set to deck values\n')
+            bridge_roof.array.data[mask] = bridge_deck.array.data[mask]
+
+        mask = np.where(bridge_roof.array.data <= bathymetry.array.data)
+        if mask[0].shape[0] > 0:
+            ret += _('Some roof values are lower than or equal to bathymetry values !\n')
+            ret += _(' -- Roof values will be set to 99999\n')
+            ret += _(' -- Bathymetry values will be set to max(bath, deck)\n')
+            ret += _(' -- These cells will remain impassable until the water level rises above them\n')
+            bridge_roof.array.data[mask] = 99999.
+            bathymetry.array.data[mask]  = np.maximum(bridge_deck.array.data[mask], bathymetry.array.data[mask]) 
+
+        mask = np.where(bridge_roof.array.data - bathymetry.array.data < threshold)
+        if mask[0].shape[0] > 0:
+            ret += _('Some roof values are close to bathymetry values (threshold is {} cm) !\n').format(int(threshold*100))
+            ret += _(' -- Bathymetry will be impose to the deck level\n')
+            ret += _(' -- New roof values will be set to 99999\n')
+            ret += _(' -- New deck values will be set to 99999\n')
+            bathymetry.array.data[mask] = bridge_deck.array.data[mask]
+            bridge_deck.array.data[mask] = 99999.
+            bridge_roof.array.data[mask] = 99999.
+
+        if ret != '':
+            logging.warning(ret)
+
+        return ret
+    
     def create_simulation(self,
                           dir:Path,
                           idx_hydros:list[int] = [-1],
@@ -1301,16 +1393,28 @@ class Config_Manager_2D_GPU:
             roof = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_SINGLE)
             roof.array.data[:,:] = 99999.
 
+        # check for deck
+        if exists(dir / '__deck.tif'):
+            deck = WolfArray(str(dir / '__deck.tif'))
+            if deck.wolftype != WOLF_ARRAY_FULL_SINGLE:
+                logging.error(_('Deck .tif must be a full single array ! -- The array will be ignored !'))
+                deck = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_SINGLE)
+                deck.array.data[:,:] = 99999.
+        else:
+            deck = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_SINGLE)
+            deck.array.data[:,:] = 99999.
+
         # applying Python scrpitps on ARRAYS
-        self._apply_scripts_update_topo_maning_inf_roof(dir, bat, man, infiltration, roof)
+        self._apply_scripts_update_topo_maning_inf_roof_deck(dir, bat, man, infiltration, roof, deck)
 
-        self.verify_bath_roof_deck(bat, roof)
+        self.combine_bath_roof_deck(bat, roof, deck)
 
         # save arrays on disk
         bat.write_all(str(dir / '__bathymetry_after_scripts.tif'))
         man.write_all(str(dir / '__manning_after_scripts.tif'))
         infiltration.write_all(str(dir / '__infiltration_after_scripts.tif'))
         roof.write_all(str(dir / '__roof_after_scripts.tif'))
+        deck.write_all(str(dir / '__deck_after_scripts.tif'))
 
         # create simulation
         allsims = []
@@ -1386,6 +1490,15 @@ class Config_Manager_2D_GPU:
                 cursim.bridge_roof = roof.array.data
                 logging.info(_("You have {} cells defined as roof").format(roof.nbnotnull))
 
+            # if deck.nbnotnull == 0:
+            #     cursim.bridge_deck = None
+            #     logging.info(_("No cells defined as deck ! -- Deck will be ignored !"))
+            # else:
+            #     cursim.bridge_deck = deck.array.data
+            #     logging.info(_("You have {} cells defined as deck").format(deck.nbnotnull))
+
+            # paramétrage hydro
+
             # add hydrograph
             for idx, curline in curhydro.data.iterrows():
                 cursim.add_infiltration(float(idx), [float(cur) for cur in curline.values])
@@ -1631,33 +1744,41 @@ class UI_Manager_2D_GPU():
         self._create_void_infil.Bind(wx.EVT_BUTTON,self.oncreate_void_infil)
         self._create_void_infil.SetToolTip(_('Create a void infiltration zones file based on bathymetry.tif'))
 
+        bridge_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self._create_void_roof = wx.Button(self._frame,label = _('Create .tif bridge/culvert roof elevation'))
         self._create_void_roof.Bind(wx.EVT_BUTTON,self.oncreate_void_roof)
         self._create_void_roof.SetToolTip(_('Create a void roof file based on bathymetry.tif'))
 
+        self._create_void_deck = wx.Button(self._frame,label = _('Create .tif bridge/culvert deck elevation'))
+        self._create_void_deck.Bind(wx.EVT_BUTTON,self.oncreate_void_deck)
+        self._create_void_deck.SetToolTip(_('Create a void deck file based on bathymetry.tif'))
+
+        bridge_sizer.Add(self._create_void_roof, 1, wx.EXPAND)
+        bridge_sizer.Add(self._create_void_deck, 1, wx.EXPAND)
+
         self._create_void_scripts = wx.Button(self._frame,label = _('Create void scripts'))
         self._create_void_scripts.Bind(wx.EVT_BUTTON,self.oncreate_void_scripts)
         self._create_void_scripts.SetToolTip(_('Create void script files for topography, manning and infiltration'))
 
         self._create_vrt = wx.Button(self._frame,label = _('Assembly .vrt to current level'))
         self._create_vrt.Bind(wx.EVT_BUTTON,self.oncreatevrt)
-        self._create_vrt.SetToolTip(_('Create a .vrt file from all bathymetry, manning, infiltration and roof .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"\n - roof must contain "roof"'))
+        self._create_vrt.SetToolTip(_('Create a .vrt file from all bathymetry, manning, infiltration, roof and deck .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"\n - roof must contain "roof"\n - deck must contain "deck"'))
 
         self._translate_vrt = wx.Button(self._frame,label = _('Translate .vrt to .tif'))
         self._translate_vrt.Bind(wx.EVT_BUTTON,self.ontranslatevrt2tif)
-        self._translate_vrt.SetToolTip(_('Translate .vrt files to .tif files\n\n - __bath_assembly.vrt -> __bathymetry.tif\n - __mann_assembly.vrt -> __manning.tif\n - __infil_assembly.vrt -> __infiltration.tif\n - __roof_assembly.vrt -> __roof.tif'))
+        self._translate_vrt.SetToolTip(_('Translate .vrt files to .tif files\n\n - __bath_assembly.vrt -> __bathymetry.tif\n - __mann_assembly.vrt -> __manning.tif\n - __infil_assembly.vrt -> __infiltration.tif\n - __roof_assembly.vrt -> __roof.tif\n - __deck_assembly.vrt -> __deck.tif'))
 
-        self._apply_scripts = wx.Button(self._frame,label = _('Apply scripts on bathymetry, manning, infiltration and roof elevation'))
+        self._apply_scripts = wx.Button(self._frame,label = _('Apply scripts on bathymetry, manning, infiltration, roof and deck elevation'))
         self._apply_scripts.Bind(wx.EVT_BUTTON,self.onapply_scripts)
-        self._apply_scripts.SetToolTip(_('Apply scripts on bathymetry, manning and infiltration\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n - roof.tif\n\nThe scripts must be in the structure starting with parent directory and descending.'))
+        self._apply_scripts.SetToolTip(_('Apply scripts on bathymetry, manning and infiltration\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n - roof.tif\n - deck.tif\n\nThe scripts must be in the structure starting with parent directory and descending.'))
 
         self._create_vec = wx.Button(self._frame,label = _('Search spatial coverage from current level'))
         self._create_vec.Bind(wx.EVT_BUTTON,self.oncreatevec)
-        self._create_vec.SetToolTip(_('Create a .vecz file (with contour and global bounds) from all bathymetry and manning .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"\n - roof must contain "roof"'))
+        self._create_vec.SetToolTip(_('Create a .vecz file (with contour and global bounds) from all bathymetry and manning .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"\n - roof must contain "roof"\n - deck must contain "deck"'))
 
         self._check_prefix = wx.Button(self._frame,label = _('Check prefix (tif files)'))
         self._check_prefix.Bind(wx.EVT_BUTTON,self.oncheck_prefix)
-        self._check_prefix.SetToolTip(_('Check prefix of .tif files\n\n - bath_*.tif\n - mann_*.tif\n - infil_*.tif\n - roof_*.tif\n\nThe prefix must be "bath_", "mann_", "infil_" and "roof_"'))
+        self._check_prefix.SetToolTip(_('Check prefix of .tif files\n\n - bath_*.tif\n - mann_*.tif\n - infil_*.tif\n - roof_*.tif\n - deck_*.tif\n\nThe prefix must be "bath_", "mann_", "infil_", "roof_" and "deck__"'))
 
         self._checkconsistency = wx.Button(self._frame,label = _('Check consistency'))
         self._checkconsistency.Bind(wx.EVT_BUTTON,self.oncheck_consistency)
@@ -1707,7 +1828,7 @@ class UI_Manager_2D_GPU():
         # buttons -> sizer
         sizer_buttons.Add(self._reload,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_infil,1,wx.EXPAND)
-        sizer_buttons.Add(self._create_void_roof,1,wx.EXPAND)
+        sizer_buttons.Add(bridge_sizer,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_scripts,1,wx.EXPAND)
         sizer_buttons.Add(self._check_prefix,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vrt,1,wx.EXPAND)
@@ -1782,6 +1903,12 @@ class UI_Manager_2D_GPU():
         self._parent.create_void_roof()
         self.reload()
 
+    def oncreate_void_deck(self, e:wx.MouseEvent):
+        """ Création d'un fichier de tablier de pont vide """
+
+        self._parent.create_void_deck()
+        self.reload()
+
     def oncreate_void_scripts(self,e:wx.MouseEvent):
         """ Création d'un script vide """
 
@@ -1898,6 +2025,7 @@ class UI_Manager_2D_GPU():
         if self._selected_item is None or self._selected_item == self._treelist.GetRootItem():
             logging.info(_('No item selected ! -- using root item'))
             with wx.MessageDialog(None, _('No item selected ! -- using root item'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
+                dlg:wx.MessageDialog
                 ret = dlg.ShowModal()
                 if ret != wx.ID_OK:
                     return
@@ -1920,6 +2048,7 @@ class UI_Manager_2D_GPU():
         if self._selected_item is None or self._selected_item == self._treelist.GetRootItem():
             logging.info(_('No item selected ! -- using root item'))
             with wx.MessageDialog(None, _('No item selected ! -- using root item'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
+                dlg:wx.MessageDialog
                 ret = dlg.ShowModal()
                 if ret != wx.ID_OK:
                     return
@@ -1932,7 +2061,7 @@ class UI_Manager_2D_GPU():
             return
 
         # application des scripts
-        self._parent.apply_scripts_bath_mann_inf_roof(mydata['path'])
+        self._parent.apply_scripts_bath_mann_inf_roof_deck(mydata['path'])
 
         self.reload()
         logging.info(_('... done !'))
@@ -1944,6 +2073,7 @@ class UI_Manager_2D_GPU():
         if self._selected_item is None or self._selected_item == self._treelist.GetRootItem():
             logging.info(_('No item selected ! -- using root item'))
             with wx.MessageDialog(None, _('No item selected ! -- using root item ?'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
+                dlg:wx.MessageDialog
                 ret = dlg.ShowModal()
                 if ret != wx.ID_OK:
                     return
@@ -2015,6 +2145,7 @@ class UI_Manager_2D_GPU():
         sims = self.get_sims_only()
 
         with wx.DirDialog(None, _('Choose a directory to store tif files'), style = wx.DD_DIR_MUST_EXIST) as dlg:
+            dlg:wx.DirDialog
             ret = dlg.ShowModal()
             if ret != wx.ID_OK:
                 return
@@ -2034,6 +2165,7 @@ class UI_Manager_2D_GPU():
         logging.info(_('Transferring initial conditions ...'))
 
         with wx.DirDialog(None, _('Choose the source scenario directory'), style = wx.DD_DIR_MUST_EXIST) as dlg:
+            dlg:wx.DirDialog
             ret = dlg.ShowModal()
             if ret != wx.ID_OK:
                 return
@@ -2041,6 +2173,7 @@ class UI_Manager_2D_GPU():
             wdir = dlg.GetPath()
 
         with wx.DirDialog(None, _('Choose the destination scenario directory'), style = wx.DD_DIR_MUST_EXIST) as dlg:
+            dlg:wx.DirDialog
             ret = dlg.ShowModal()
             if ret != wx.ID_OK:
                 return

wolfhece/scenario/update_void.py

@@ -150,6 +150,37 @@ class Update_Sim:
         """
         pass
 
+    def update_deck(self, roof:WolfArray):
+        """
+        FR
+
+        Cette fonction doit être particularisée afin d'appliquer des modifications
+        à l'altimétrie des ponts et ponceaux (toits)'.
+
+        L'information de base se trouve dans le paramètre  'deck' de classe 'WolfArray'.
+
+        La matrice Numpy, en <Float32>, (avec masque - cf np.ma ) est accessible via :
+          - deck.array[:,:]
+          - deck.array.mask[:,:]
+          - deck.array.data[:,:]
+
+        Il n'est pas permis de remplacer la matrice (création d'une nouvelle matrice et/ou pointage d'una autre matrice). Toutes les operations doivent se faire dans l'espace alloué.
+
+        EN
+
+        This function must be customized to apply modifications to the deck elevation of bridges/culverts.
+
+        The basic information is located in the 'deck' parameter ('WolfArray' class).
+
+        The Numpy array, in <Float32>, (with a mask - see np.ma), can be accessed via:
+          - deck.array[:,:]
+          - deck.array.mask[:,:]
+          - deck.array.data[:,:]
+
+        It is not allowed to replace the array (creating a new array and/or pointing an other array). All operations must be performed within the allocated space.
+        """
+        pass
+
 def create_empty_method(method_name, method_signature, docstring, imports):
     # Fonction utilitaire pour créer des méthodes vides avec la même signature, la documentation et les importations
     imports_str = '\n'.join(f'import {module}' for module in imports)

wolfhece/wolf_array.py

@@ -781,8 +781,12 @@ class header_wolf():
             geotr = raster.GetGeoTransform()
             self.dx = geotr[1]
             self.dy = abs(geotr[5])
-            self.origx = geotr[0]
-            self.origy = geotr[3]
+            if geotr[5] < 0.:
+                self.origx = geotr[0]
+                self.origy = geotr[3] + raster.RasterYSize * geotr[5]
+            else:
+                self.origx = geotr[0]
+                self.origy = geotr[3]
             self.nbx = raster.RasterXSize
             self.nby = raster.RasterYSize
 
@@ -833,6 +837,10 @@ class header_wolf():
             self.dy = abs(geotr[5])
             self.origx = geotr[0]
             self.origy = geotr[3]
+
+            if geotr[5] < 0.:
+                self.origy = geotr[3] + raster.RasterYSize * geotr[5]
+
             self.nbx = raster.RasterXSize
             self.nby = raster.RasterYSize
 
@@ -6024,21 +6032,26 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     proj = raster_in.GetProjection()
                     # check if proj is epsg:31370
-                    if 'Lambert 72' not in proj and "31370" not in proj:
+                    if ('Lambert 72' not in proj and "31370" not in proj) and proj != 'LOCAL_CS["unnamed",UNIT["unknown",1],AXIS["Easting",EAST],AXIS["Northing",NORTH]]':
                         logging.error(_('{} projection is not Lambert 72 - EPSG:31370').format(fn))
 
-                        raster_in2 = gdal.Dataset()
-                        gdal.Warp(raster_in2, raster_in, dstSRS='EPSG:31370')
+                        try:
+                            raster_in2 = gdal.Dataset()
+                            gdal.Warp(raster_in2, raster_in, dstSRS='EPSG:31370')
 
-                        # Close the raster_in
-                        raster_in.FlushCache()
-                        raster_in = None
+                            # Close the raster_in
+                            raster_in.FlushCache()
+                            raster_in = None
 
-                        raster_in = raster_in2
+                            raster_in = raster_in2
 
-                        if raster_in is None:
-                            logging.error(_('Could not reproject the file {fn}'))
-                            return
+                            if raster_in is None:
+                                logging.error(_('Could not reproject the file {fn}'))
+                                return
+                        except Exception as e:
+                            logging.error(f'Error in reprojection: {e}')
+                            logging.info('Using the original file')
+                            raster_in = gdal.Open(fn)
 
                     geotr = raster_in.GetGeoTransform()
                     self.dx = geotr[1]
@@ -6208,9 +6221,10 @@ class WolfArray(Element_To_Draw, header_wolf):
                                     style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog:
 
                     if fileDialog.ShowModal() == wx.ID_CANCEL:
-                        return
-
-                    fn_crop = fileDialog.GetPath()
+                        from tempfile import NamedTemporaryFile
+                        tmpfile = str(NamedTemporaryFile(suffix='.tif').name)
+                    else:
+                        fn_crop = fileDialog.GetPath()
 
                 if uly > lly:
                     raster = gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])

wolfhece/wolfresults_2D.py

@@ -4104,7 +4104,7 @@ class Wolfresults_2D(Element_To_Draw):
 
     def get_all_values_xyorpoly_series(self, xy:Union[list[float], vector], for_steps:tuple[int] | list[int] = (0,-1,1)):
         """
-        Get water depth at one or multiple coordinates.
+        Get variables at one or multiple coordinates.
 
         :param xy : list of coordinates
         :param for_steps : tuple of start, end and step -- 0-based -- default is all steps (0,-1,1)
@@ -4350,7 +4350,7 @@ class Wolfresults_2D(Element_To_Draw):
                                   filename: str | Path,
                                   for_steps:tuple[int] | list[int] = (0,-1,1),
                                   erase_if_exists:bool = True,
-                                  only_stats:bool = True):
+                                  all_values:bool = GL_FRAGMENT_INTERPOLATION_OFFSET_BITS):
         """ Export some results at one or multiple coordinates defined by a vector or a list of coordinates
         or a polygon as CSV file
         """
@@ -4363,6 +4363,9 @@ class Wolfresults_2D(Element_To_Draw):
         if erase_if_exists and filename.exists():
             filename.unlink()
 
+        if erase_if_exists and filename.with_stem(filename.stem + '_stats').exists():
+            filename.with_stem(filename.stem + '_stats').unlink()
+
         (times, steps), vals = self.get_values_xyorpoly_series(xy, which, for_steps)
 
         mean= []
@@ -4393,16 +4396,16 @@ class Wolfresults_2D(Element_To_Draw):
             for i in range(len(times)):
                 f.write(f'{times[i]}\t{steps[i]}\t{mean[i]}\t{median[i]}\t{min[i]}\t{max[i]}\n')
 
-        if not only_stats:
+        if all_values:
 
             with open(filename, 'a') as f:
                 if isinstance(xy, list):
-                    f.write(_('Selected nodes'))
-                    f.write('X [m]\tY [m]')
+                    f.write(_('Selected nodes\n'))
+                    f.write('X [m]\tY [m]\n')
                     for cur in xy:
-                        f.write(f'{cur[0]}\t{cur[1]}')
+                        f.write(f'{cur[0]}\t{cur[1]}\n')
 
-                    f.write('\n')
+                    f.write('\n\n')
 
                 f.write(f'Time [s]\tStep [-]\t{which.value[0]}\n')
 

{wolfhece-2.1.120.dist-info → wolfhece-2.1.122.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wolfhece
-Version: 2.1.120
+Version: 2.1.122
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece