wolfhece 2.2.45__py3-none-any.whl → 2.2.47__py3-none-any.whl

wolfhece/dike.py

@@ -32,17 +32,19 @@ from wolfhece.wolf_array import WolfArray
 from wolfhece.matplotlib_fig import Matplotlib_Figure
 from wolfhece.PyTranslate import _
 
-try:
-    from wolfgpu.SimulationRunner import SimulationRunner, SimulationInjector, SimulationProxy
-    from wolfgpu.simple_simulation import SimulationDuration, SimpleSimulation
-    from wolfgpu.results_store import ResultsStore
-except ImportError:
-    logging.warning(_("Warning: wolfgpu module not found. Coupled WOLF-pydike simulations will not be available."))
 class CoupledSimulation():
     """
-    Class for the coupled simulation between WOLF and pydike.
+    Class for the coupled simulation between WOLF and pydike. !!! UNDER DEVELOPMENT !!!
     """
+
     def __init__(self):
+        try:
+            from wolfgpu.SimulationRunner import SimulationRunner, SimulationInjector, SimulationProxy
+            from wolfgpu.simple_simulation import SimulationDuration, SimpleSimulation
+            from wolfgpu.results_store import ResultsStore
+        except ImportError:
+            logging.warning(_("Warning: wolfgpu module not found. Coupled WOLF-pydike simulations will not be available."))
+
         self.filename = None
         self.injectorWolf = None
         self.interpMatrix = None
@@ -54,7 +56,8 @@ class CoupledSimulation():
 
 class InjectorWolf(Element_To_Draw):
     """
-    Class for the injector object.
+    Class for the injector object. !!! UNDER DEVELOPMENT !!!
+    The injector is used to inject the breach topography in the WOLF simulation.
     """
     def __init__(self, idx = '', plotted = True, mapviewer=None, need_for_wx = False):
         super().__init__(idx, plotted, mapviewer, need_for_wx)
@@ -242,7 +245,7 @@ class DikeWolf(Element_To_Draw):
 
     def set_injector(self):
         """
-        Set the injector for the dike object.
+        Set the injector for the dike object. !!! UNDER DEVELOPMENT !!!
         :param injector: Injector object to be set.
         """
         self.injectorWolf = InjectorWolf()
@@ -250,9 +253,16 @@ class DikeWolf(Element_To_Draw):
 
     def run_2Dcoupled(self, params_dir=None):
         """
-        Run the dike breaching simulation coupled with WOLF.
+        Run the dike breaching simulation coupled with WOLF. !!! UNDER DEVELOPMENT !!!
         :param store_dir: Directory where the simulation will be run.
         """
+        try:
+            from wolfgpu.SimulationRunner import SimulationRunner, SimulationInjector, SimulationProxy
+            from wolfgpu.simple_simulation import SimulationDuration, SimpleSimulation
+            from wolfgpu.results_store import ResultsStore
+        except ImportError:
+            logging.warning(_("Warning: wolfgpu module not found. Coupled WOLF-pydike simulations will not be available."))
+
         if self.injectorWolf is None:
             logging.error(_("Injector is not set. Please set the injector before running the simulation."))
             return

wolfhece/lazviewer/laz_viewer.py

@@ -616,22 +616,45 @@ class xyz_laz_grids():
 
         import asyncio
 
-        dirs = listdir(dir_grids)
-
-        logging.info(_('Reading grids information -- {} grids'.format(len(dirs))))
-
         def init_grid(curdir):
             if (Path(dir_grids) / Path(curdir)).is_dir():
                 return xyz_laz_grid(join(dir_grids, curdir))
 
             return None
 
+        # check if an event loop is running
+        # If it is the case, read data in a single thread
+        try:
+            asyncio.get_running_loop()
+            logging.info(_('Event loop detected - reading grids in single thread'))
+            use_async = False
+        except RuntimeError:
+            use_async = True
+
+        if not use_async:
+            dirs = listdir(dir_grids)
+
+            logging.info(_('Reading grids information -- {} grids'.format(len(dirs))))
+
+            self.grids = [init_grid(curdir) for curdir in dirs if (Path(dir_grids) / Path(curdir)).is_dir()]
+            self.grids = list(filter(None, self.grids))
+
+            logging.info(_('Grids initialized'))
+            return
+
+        # else use asyncio to read in parallel
+        dirs = listdir(dir_grids)
+
+        logging.info(_('Reading grids information -- {} grids'.format(len(dirs))))
+
         async def init_grid_async(curdir):
             return init_grid(curdir)
 
-        loop = asyncio.get_event_loop()
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
         tasks = [init_grid_async(curdir) for curdir in dirs]
         self.grids = list(filter(None, loop.run_until_complete(asyncio.gather(*tasks))))
+        loop.close()
 
         logging.info(_('Grids initialized'))
 
@@ -1472,7 +1495,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
         self._xlsFrame.Show()
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent.parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent.parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self._xlsFrame.SetIcon(icon)
 

wolfhece/math_parser/calculator.py

@@ -64,7 +64,7 @@ class Calculator(wx.Frame):
         self._disp.SetFocus()
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent.parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent.parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self.SetIcon(icon)
 

wolfhece/matplotlib_fig.py

@@ -246,7 +246,7 @@ class Matplotlib_ax_properties():
         self._myprops.SetTitle(_('Ax properties'))
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self._myprops.SetIcon(icon)
 
@@ -970,7 +970,7 @@ class Matplolib_line_properties():
         self._myprops.SetTitle(_('Line properties'))
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self._myprops.SetIcon(icon)
 
@@ -1402,7 +1402,7 @@ class Matplotlib_Figure(wx.Frame):
     def set_wx(self):
         """ Set the wx Frame Design """
 
-        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf.ico")))
 
         self._sizer = wx.BoxSizer(wx.VERTICAL)
 
@@ -2325,7 +2325,7 @@ class Matplotlib_figure_properties():
         self._myprops.SetTitle(_('Figure properties'))
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self._myprops.SetIcon(icon)
 

wolfhece/mesh2d/wolf2dprev.py

@@ -8928,30 +8928,22 @@ class block_contour(vector):
     def __init__(self, lines: list = ..., is2D=True, name='', parentzone=None) -> None:
         super().__init__(lines, is2D, name, parentzone)
 
-    def set_limits(self):
-        """ Retain current limits before any modification """
-
-        # Set self.minx, self.maxx), (self.miny, self.maxy)
-        # on basis of the self.myvertices
-
-        self.find_minmax()
-        self.mylimits = ((self.xmin, self.xmax), (self.ymin, self.ymax))
 
     def verify_limits(self):
         """ Verify that the current vertices are inside the set block's limits """
 
-        if self.mylimits is None:
+        if self._mylimits is None:
             return
 
         self.find_minmax()
 
-        if self.xmin < self.mylimits[0][0] or self.xmax > self.mylimits[0][1] or \
-                self.ymin < self.mylimits[1][0] or self.ymax > self.mylimits[1][1]:
+        if self.xmin < self._mylimits[0][0] or self.xmax > self._mylimits[0][1] or \
+                self.ymin < self._mylimits[1][0] or self.ymax > self._mylimits[1][1]:
 
             for curv in self.myvertices:
                 curv: wolfvertex
                 # Force the vertex inside self.mylimits
-                curv.limit2bounds(self.mylimits)
+                curv.limit2bounds(self._mylimits)
 
 
 COLOURS_BLOCKS=[(0,0,255),(255,0,0),(0,255,0),(255,255,0),(255,0,255),(0,255,255),(0,125,255),(255,125,0),(125,0,255),(25,25,255)]
@@ -9032,7 +9024,7 @@ class block_description:
                 self.contour.add_vertex(curvert)
 
             self.contour.close_force()  ##on force la fermeture du contour extérieur des blocs
-            self.contour.set_limits() # on retient les limites en cas de modifications
+            self.contour._set_limits() # on retient les limites en cas de modifications
 
             ##emprise du bloc en accord avec le grid magnétique et
             # l'extension de surface utile pour les relations de voisinage entre blocs

wolfhece/pydike.py

@@ -1,276 +1,5 @@
-"""
-Author: HECE - University of Liege, Pierre Archambeau
-Date: 2024
-
-Copyright (c) 2024 University of Liege. All rights reserved.
-
-This script and its content are protected by copyright law. Unauthorized
-copying or distribution of this file, via any medium, is strictly prohibited.
-"""
-
-import logging
-
-import numpy as np
-from shapely.geometry import Point, LineString
-
-from.drawing_obj import Element_To_Draw
-from .PyVertexvectors import Triangulation, vector,Zones, zone
-from .wolf_array import WolfArray, header_wolf
-
-class SyntheticDike(Element_To_Draw):
-    """ Dike class for synthetic dikes based on a trace vector, width of the crest and lateral slopes.
-    """
-
-    def __init__(self, idx:str = '', plotted:bool = True, mapviewer = None, need_for_wx:bool = False):
-
-        super().__init__(idx, plotted, mapviewer, need_for_wx)
-
-        self._triangulation = None
-        self._zones = Zones()
-        newzone = zone(name='dike')
-
-        self._zones.add_zone(newzone, forceparent=True)
-
-    @property
-    def triangulation(self) -> Triangulation:
-        """ Return the triangulation of the dike """
-        return self._triangulation
-
-    @property
-    def zones(self) -> Zones:
-        """ Return the zones of the dike """
-        return self._zones
-
-    def create_from_slopes(self, trace:vector,
-                             slope_up:float, slope_down:float,
-                             width_up:float, width_down:float,
-                             zmin:float, zmax:float, ds:float):
-
-        """ Create the dike triangulation based on the trace vector and the width of the dike.
-
-        :param trace: Trace vector of the dike
-        :param slope_up: Slope of the dike on the upstream side [slope = dz/dx]
-        :param slope_down: Slope of the dike on the downstream side [slope = dz/dx]
-        :param width_up: Width of the dike on the upstream side [m]
-        :param width_down: Width of the dike on the downstream side [m]
-        :param zmin: Minimum elevation of the dike [m]
-        :param zmax: Maximum elevation of the dike [m]
-        :param ds: Distance for rebinning [m]
-        """
-
-        assert ds > 0.0, "Distance for rebinning must be positive"
-        assert slope_up > 0.0, "Slope must be positive"
-        assert slope_down > 0.0, "Slope must be positive"
-        assert width_up >= 0.0, "Width must be positive"
-        assert width_down >= 0.0, "Width must be positive"
-        assert zmin < zmax, "zmin must be less than zmax"
-
-        myzone = self._zones.myzones[0]
-        myzone.myvectors = []
-
-        # Impose altimetry of the crest
-        trace.z = zmax
-
-        # add the trace vector to the zone
-        myzone.add_vector(trace, forceparent=True)
-
-        # CREST of the dike
-        # create parallel vectors to the trace vector - right and left
-
-        if width_up > 0.0:
-            distances_up = list(np.linspace(0, width_up, int(width_up/ds)+1, endpoint=True))[1:]
-            for curds in distances_up:
-                # create a new vector parallel to the trace vector
-                parup = trace.parallel_offset(curds, 'right')
-                myzone.add_vector(parup, 0, forceparent=True)
-                # impose altimetry of the dike
-                parup.z = zmax
-        else:
-            # no width on the upstream side -> use the trace vector
-            parup = trace
-
-        if width_down > 0.0:
-            distances_down = list(np.linspace(0, width_down, int(width_down/ds)+1, endpoint=True))[1:]
-            for curds in distances_down:
-                pardown = trace.parallel_offset(curds, 'left')
-                myzone.add_vector(pardown, forceparent=True)
-                # impose altimetry of the dike
-                pardown.z = zmax
-        else:
-            # no width on the downstream side -> use the trace vector
-            pardown = trace
-
-        # distances to the crest
-        distances_up   = (zmax-zmin) / slope_up
-        distances_up = list(np.linspace(0, distances_up, int(distances_up/ds)+1, endpoint=True))[1:]
-        # distances_up.reverse()
-        # iterate over the distup basd on ds
-        for curds in distances_up:
-            # create a new vector parallel to the trace vector
-            parup_new = parup.parallel_offset(curds, 'right')
-            myzone.add_vector(parup_new, 0, forceparent=True)
-            # impose altimetry of the dike
-            parup_new.z = zmax - slope_up * curds
-
-        distances_down = (zmax-zmin) / slope_down
-        distances_down = list(np.linspace(0, distances_down, int(distances_down/ds)+1, endpoint=True))[1:]
-        for curds in distances_down:
-            pardown_new  = pardown.parallel_offset(curds, 'left')
-            myzone.add_vector(pardown_new, forceparent=True) # append
-            # impose altimetry of the dike
-            pardown_new.z = zmax - slope_down * curds
-
-        # on dispose de multiples vecteurs dans la zone, orientés de l'amont vers l'aval
-        trace.update_lengths()
-
-        nb_along_trace  = int(trace.length3D / ds) # nombre de points sur la trace
-
-        self._triangulation = myzone.create_multibin(nb_along_trace)
-
-    def create_from_shape(self, trace:vector, shape:vector, ds:float):
-        """ create the dike triangulation based on the trace vector and the shape vector
-
-        :param trace: Trace vector of the dike
-        :param shape: Transversal shape of the dike in (s,z) coordinates, s=0.0 is on the trace vector, elevations are relative to the trace vector
-        :param ds: Distance for rebinning [m]
-        """
-
-        myzone = self._zones.myzones[0]
-        myzone.myvectors = []
-
-        # add the trace vector to the zone
-        myzone.add_vector(trace, forceparent=True)
-
-        # get the shapely linestring of the trace -> projection
-        ref_ls = trace.linestring
-
-        # Create parallels of the crest according to the shape vector
-        # -----------------------------------------------------------
-
-        # get coordinates of the shape vector
-        shape_vertices = shape.xy
-
-        # Separate the upstream and downstream vertices
-        up_vertices = shape_vertices[shape_vertices[:, 0] > 0.0]
-        down_vertices = shape_vertices[shape_vertices[:, 0] < 0.0]
-
-        # reverse the order of downstream vertices
-        down_vertices = down_vertices[::-1]
-
-        # Altitude au droit de la trace
-        z_shape_trace = shape_vertices[shape_vertices[:, 0] == 0.0][0][1]
-
-        # UPSTREAM PART
-
-        # Loop over the upstream vertices
-        z_previous = z_shape_trace
-        s_previous = 0.0
-        distance_cum = 0.0 # useful for the cumulated distance -> parallel offset
-        for cur_sz in up_vertices:
-
-            ds_loc    = cur_sz[0] - s_previous       # distance between the two points in the shape
-            slope_loc = (z_previous - cur_sz[1]) / ds_loc  # local slope of the shape
-
-            # rebin the distance
-            distances_up = list(np.linspace(0, ds_loc, int(ds_loc/ds)+1, endpoint=True))[1:]
-
-            deltaz_cum = 0.0 # Cumulated elevation difference
-
-            # iterate over the distup basd on ds
-            for curds in distances_up:
-                # create a new vector parallel to the trace vector
-                # need to add the cumulated distance to the current distance as we
-                parup = trace.parallel_offset(curds + distance_cum, 'right')
-
-                if parup is None:
-                    logging.warning("No parallel vector found for distance %f", curds + distance_cum)
-                    continue
-
-                myzone.add_vector(parup, 0, forceparent=True)
-
-                # local delta elevation
-                deltaz_loc = -slope_loc * curds - deltaz_cum # local difference
-
-                parup_z = []
-
-                # we need to interpolate the elevation according to the trace
-
-                # Iterate over the vertices
-                for vert in parup.myvertices:
-                    # project the vertex on the previous trace
-                    proj = ref_ls.project(Point(vert.x, vert.y), normalized=True)
-                    # get the elevation of the trace at the projection point
-                    z_loc = ref_ls.interpolate(proj, normalized= True).z
-                    # add the local delta elevation
-                    z_loc += deltaz_loc
-                    parup_z.append(z_loc)
-
-                parup.z = parup_z
-                ref_ls = parup.linestring
-                deltaz_cum += deltaz_loc
-                z_previous = cur_sz[1]
-                s_previous = cur_sz[0] # update the elevation of the trace
-
-            distance_cum += distances_up[-1] # cumulate the distance
-
-        # create downstream
-        ref_ls = trace.linestring
-
-        z_previous = z_shape_trace
-        s_previous = 0.0
-        distance_cum = 0.0
-        # Loop over the downstream vertices
-        for cur_sz in down_vertices:
-
-            ds_loc    = -(cur_sz[0] - s_previous)
-            slope_loc = (z_previous - cur_sz[1]) / ds_loc
-
-            # rebin the distance
-            distances_down = list(np.linspace(0, ds_loc, int(ds_loc/ds)+1, endpoint=True))[1:]
-
-            deltaz_cum = 0.0
-
-            # iterate over the distup basd on ds
-            for curds in distances_down:
-                pardown = trace.parallel_offset(curds + distance_cum, 'left')
-
-                if pardown is None:
-                    logging.warning("No parallel vector found for distance %f", curds + distance_cum)
-                    continue
-
-                myzone.add_vector(pardown, forceparent=True)
-
-                # impose local elevation
-                deltaz_loc = -slope_loc * curds - deltaz_cum # local difference
-
-                pardown_z = []
-                # we need to interpolate the elevation according to the trace
-                for vert in pardown.myvertices:
-                    # project the vertex on the trace
-                    proj = ref_ls.project(Point(vert.x, vert.y), normalized=True)
-                    # get the elevation of the trace at the projection point
-                    z_loc = ref_ls.interpolate(proj, normalized= True).z
-                    # add the local delta elevation
-                    z_loc += deltaz_loc
-                    pardown_z.append(z_loc)
-
-                # impose the elevation
-                pardown.z = pardown_z
-                ref_ls = pardown.linestring
-                deltaz_cum += deltaz_loc
-                z_previous =cur_sz[1] # update the elevation of the trace
-                s_previous = cur_sz[0]
-
-            distance_cum += distances_down[-1]
-
-        # on dispose de multiples vecteurs dans la zone, orientés de l'amont vers l'aval
-        trace.update_lengths()
-
-        nb_along_trace  = int(trace.length3D / ds) # nombre de points sur la trace
-
-        self._triangulation = myzone.create_multibin(nb_along_trace)
-
-        for curvect in myzone.myvectors:
-            curvect.reset_linestring()
+import warnings
 
+warnings.warn("The module wolfhece.pydike is deprecated. Please use wolfhece.synthetic_dike instead.", DeprecationWarning, stacklevel=2)
 
+import synthetic_dike