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

wolfhece/mesh2d/wolf2dprev.py

@@ -1682,6 +1682,18 @@ class prev_parameters_blocks:
     # Friction
     # ********
 
+    def get_lateral_friction_coefficient(self) -> float:
+        """ Returns the lateral friction coefficient """
+        return self._lateral_manning
+
+    def set_lateral_friction_coefficient(self, lateral_friction_coefficient:float):
+        """ Set the lateral friction coefficient """
+
+        assert isinstance(lateral_friction_coefficient, float), "lateral_friction_coefficient must be a float"
+        assert lateral_friction_coefficient >= 0., "lateral_friction_coefficient must be >= 0"
+
+        self._lateral_manning = lateral_friction_coefficient
+
     def set_params_surface_friction(self, model_type:Literal['Horizontal',
                                                             'Modified surface corrected 2D (HECE)',
                                                             'Modified surface corrected 2D + Lateral external borders (HECE)',

wolfhece/os_check.py

@@ -0,0 +1,16 @@
+import os
+
+# Check if we are on Windows
+if os.name == 'nt':
+    __onWindows__ = True
+else:
+    __onWindows__ = False
+
+def isWindows():
+    """
+    Check if the current operating system is Windows.
+
+    Returns:
+        bool: True if the OS is Windows, False otherwise.
+    """
+    return __onWindows__

wolfhece/pydike.py

@@ -10,63 +10,267 @@ 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
 
-class Dike(Triangulation,Zones):
+        # create downstream
+        ref_ls = trace.linestring
 
-    def __init__(self, trace:vector, width:float, slopeup:float, slopedown:float, fn='', pts=..., tri=..., idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
+        z_previous = z_shape_trace
+        s_previous = 0.0
+        distance_cum = 0.0
+        # Loop over the downstream vertices
+        for cur_sz in down_vertices:
 
-        super().__init__(fn, pts, tri, idx, plotted, mapviewer, need_for_wx)
+            ds_loc    = -(cur_sz[0] - s_previous)
+            slope_loc = (z_previous - cur_sz[1]) / ds_loc
 
-        self.slopeup = slopeup
-        self.slopedown = slopedown
-        self.width = width
-        self.trace = trace
+            # rebin the distance
+            distances_down = list(np.linspace(0, ds_loc, int(ds_loc/ds)+1, endpoint=True))[1:]
 
-        newzone = zone(name='dike',parent=self)
-        self.add_zone(newzone)
-        newzone.add_vector(trace)
+            deltaz_cum = 0.0
 
-    def create(self,zmin,zmax,ds):
+            # iterate over the distup basd on ds
+            for curds in distances_down:
+                pardown = trace.parallel_offset(curds + distance_cum, 'left')
 
-        myzone:zone
-        myzone = self.myzones[0]
+                if pardown is None:
+                    logging.warning("No parallel vector found for distance %f", curds + distance_cum)
+                    continue
 
-        parright = self.trace.parallel_offset(self.width/2.,'right')
-        parleft = self.trace.parallel_offset(self.width/2.,'left')
+                myzone.add_vector(pardown, forceparent=True)
 
-        myzone.add_vector(parright)
-        myzone.add_vector(parleft,0)
+                # impose local elevation
+                deltaz_loc = -slope_loc * curds - deltaz_cum # local difference
 
-        allpar = [parright,parleft, self.trace]
-        for curpar in allpar:
-            for curv in curpar.myvertices:
-                curv.z=zmax
+                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)
 
-        distup = (zmax-zmin)/self.slopeup
-        parup  = parright.parallel_offset(distup,'right')
+                # 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]
 
-        distdown = (zmax-zmin)/self.slopedown
-        pardown  = parleft.parallel_offset(distdown,'left')
+            distance_cum += distances_down[-1]
 
-        myzone.add_vector(parup)
-        myzone.add_vector(pardown,0)
+        # on dispose de multiples vecteurs dans la zone, orientés de l'amont vers l'aval
+        trace.update_lengths()
 
-        allpar = [parup,pardown]
-        for curpar in allpar:
-            for curv in curpar.myvertices:
-                curv.z=zmin
+        nb_along_trace  = int(trace.length3D / ds) # nombre de points sur la trace
 
-        # on dispose de 5 vecteurs dans la zone, orientés de l'aval vers l'amont
+        self._triangulation = myzone.create_multibin(nb_along_trace)
 
-        self.trace.update_lengths()
-        nb = int(self.trace.length3D/ds)
-        nb2 = int(max(distup,distdown)/ds)
+        for curvect in myzone.myvectors:
+            curvect.reset_linestring()
 
-        mytri = myzone.create_multibin(nb,nb2)
-        self.tri = mytri.tri
-        self.pts = mytri.pts
-        self.nb_pts = mytri.nb_pts
-        self.nb_tri = mytri.nb_tri
 
-        pass

wolfhece/tools2d_dll.py

@@ -5,6 +5,12 @@ import logging
 
 from .wolf_array import header_wolf, getkeyblock
 
+from .os_check import isWindows
+
+# Check if the platform is Windows
+if not isWindows():
+    raise OSError("This module is only compatible with Windows.")
+
 try:
     import pefile
 except ImportError: