wolfhece 2.0.55__py3-none-any.whl → 2.1.1__py3-none-any.whl

wolfhece/bernoulli/network.py

@@ -0,0 +1,128 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from .pipe import pipe
+from .chamber import chamber, junction
+
+class network():
+
+    def __init__(self) -> None:
+
+        self.chambers:list[chamber] = []
+        self.pipes:list[pipe] = []
+        self.links:list[tuple[chamber,chamber,pipe]] = []
+
+    def add_chamber(self, chamber):
+        self.chambers.append(chamber)
+
+    def add_pipe(self, pipe):
+        self.pipes.append(pipe)
+
+    def link(self, chamber1, chamber2, pipe):
+        self.links.append((chamber1, chamber2, pipe))
+
+    def update(self, dt:float):
+
+        for chamber in self.chambers:
+            chamber.reset_q()
+
+        for chamber1, chamber2, pipe in self.links:
+            pipe.head_up = chamber1.head
+            pipe.head_down = chamber2.head
+            pipe.solve_flowrate()
+
+            chamber1.add_qout(pipe.flowrate)
+            chamber2.add_qin(pipe.flowrate)
+
+        for chamber in self.chambers:
+            chamber.update(dt)
+
+if __name__ == "__main__":
+
+    def test_simplenetwork():
+
+        chamber1 = chamber()
+        chamber2 = chamber()
+        pipe1 = pipe()
+
+        net = network()
+        net.add_chamber(chamber1)
+        net.add_chamber(chamber2)
+        net.add_pipe(pipe1)
+        net.link(chamber1, chamber2, pipe1)
+
+        chamber1.elevation = 0.
+        chamber2.elevation = 0.
+        chamber1.area = 1.
+        chamber2.area = 1.
+
+        chamber1.head = 10.
+        chamber2.head = 0.
+
+        pipe1.viscosity = 1.e-6
+        pipe1.density = 1000.
+        pipe1.gravity = 9.81
+
+        pipe1.length = 100.
+        pipe1.diameter = 0.5
+
+        pipe1.k = 0.0001
+
+        net.update(1.)
+
+    def test_simplenetwork_w_junction(dt:float = 1.):
+
+        chamber1 = chamber()
+        chamber2 = chamber()
+        junc = junction()
+        pipe1 = pipe()
+        pipe2 = pipe()
+
+        net = network()
+        net.add_chamber(chamber1)
+        net.add_chamber(chamber2)
+        net.add_chamber(junc)
+
+        net.add_pipe(pipe1)
+        net.add_pipe(pipe2)
+
+        net.link(chamber1, junc, pipe1)
+        net.link(junc, chamber2, pipe2)
+
+        chamber1.elevation = 0.
+        chamber2.elevation = 0.
+
+        chamber1.area = 1.
+        chamber2.area = 1.
+
+        chamber1.is_bc = True
+        chamber1.bc_value = 10.
+
+        chamber2.is_bc = True
+        chamber2.bc_value = 0.
+
+        chamber1.head = 10.
+        chamber2.head = 0.
+        junc.head = 4.
+
+        for curpipe in [pipe1, pipe2]:
+
+            curpipe.viscosity = 1.e-6
+            curpipe.density = 1000.
+            curpipe.gravity = 9.81
+
+            curpipe.length = 50.
+            curpipe.diameter = 0.5
+
+            curpipe.k = 0.0001
+
+        evol = [junc.head]
+        old_head = 4.1
+        while abs(junc.head - old_head) > 1e-6:
+            old_head = junc.head
+            net.update(dt)
+            evol.append(junc.head)
+
+        plt.plot(evol)
+        plt.show()

wolfhece/bernoulli/pipe.py

@@ -0,0 +1,194 @@
+import numpy as np
+from math import pi
+from scipy.optimize import fsolve
+
+from .losses import f_colebrook_white
+from .fluids import Water
+
+GRAVITY = 9.81 # m/s^2
+class pipe():
+    """ Pipe class for Bernoulli's equation """
+
+    def __init__(self) -> None:
+
+        self._head_up:float = 0.    # upstream head         [m]
+        self._head_down:float = 0.  # downstream head       [m]
+        self._flowrate:float = 0.   # flowrate              [$m^3s^{-1}$]
+        self._k:float = 0.          # roughness of the pipe [m]
+
+        self.length:float = 0.      # Length of the pipe [m]
+        self.diameter:float = 0.    # Diameter of the pipe [m]
+
+        self.fluid = Water()
+
+        self.f = 0.02 # Initial guess for the friction factor
+
+    @property
+    def head_up(self):
+        return self._head_up
+
+    @head_up.setter
+    def head_up(self, value):
+        self._head_up = value
+
+    @property
+    def head_down(self):
+        return self._head_down
+
+    @head_down.setter
+    def head_down(self, value):
+        self._head_down = value
+
+    @property
+    def flowrate(self):
+        return self._flowrate
+
+    @flowrate.setter
+    def flowrate(self, value):
+        self._flowrate = value
+        self._solve_friction_factor()
+
+    @property
+    def k(self):
+        return self._k
+
+    @k.setter
+    def k(self, value):
+        self._k = value
+        self._solve_friction_factor()
+
+    @property
+    def area(self):
+        return pi * (self.diameter/2.)**2.
+
+    @property
+    def velocity(self):
+        return self.flowrate / self.area
+
+    @property
+    def perimeter(self):
+        return pi * self.diameter
+
+    @property
+    def epsilon(self):
+        return self.k / self.diameter
+
+    @property
+    def reynolds(self):
+        return self.velocity * self.diameter / self.fluid.nu
+
+    @property
+    def head_loss_k(self):
+        return self.length / self.diameter * self.friction_factor
+
+    @property
+    def head_loss(self):
+        return self.head_loss_k * self.velocity**2. / (2. * GRAVITY)
+
+    def _solve_friction_factor(self):
+        """ Update the friction factor using the Colebrook-White equation """
+
+        self.f = f_colebrook_white(self.f, self.k, self.diameter, self.reynolds)
+
+        return self.f
+
+    @property
+    def friction_factor(self):
+        return self.f
+
+    @property
+    def bernoulli_error(self):
+        return self.head_up - self.head_down - self.head_loss
+
+    def solve_flowrate(self):
+
+        def loc_bernoulli(flowrate):
+            self.flowrate = flowrate
+            return self.bernoulli_error
+
+        flowrate_solution = fsolve(loc_bernoulli, self.flowrate)
+
+        self.flowrate = flowrate_solution[0]
+
+        return self.flowrate
+
+    def solve_head_up(self):
+
+        def loc_bernoulli(head_up):
+            self.head_up = head_up
+            return self.bernoulli_error
+
+        head_up_solution = fsolve(loc_bernoulli, self.head_up)
+
+        self.head_up = head_up_solution[0]
+
+        return self.head_up
+
+    def solve_head_down(self):
+
+        def loc_bernoulli(head_down):
+            self.head_down = head_down
+            return self.bernoulli_error
+
+        head_down_solution = fsolve(loc_bernoulli, self.head_down)
+
+        self.head_down = head_down_solution[0]
+
+        return self.head_down
+
+    def solve_k(self):
+
+        def loc_bernoulli(k):
+            self.k = k
+            return self.bernoulli_error
+
+        k_solution = fsolve(loc_bernoulli, self.k)
+
+        self.k = k_solution[0]
+
+        return self.k
+
+
+if __name__ == '__main__':
+
+
+    def test_pipe():
+        pipe1 = pipe()
+
+        pipe1.head_up = 10.
+        pipe1.head_down = 0.
+        pipe1.length = 100.
+        pipe1.diameter = 0.5
+
+        pipe1.k = 0.0001
+        pipe1.flowrate = 1.
+
+        print(pipe1.reynolds)
+
+        print(pipe1.head_loss)
+
+        assert abs(pipe1.head_loss - 3.737978364) < 1e-6
+
+        print(pipe1.solve_flowrate())
+        assert abs(pipe1.flowrate - 1.644579263) < 1e-6
+
+        pipe1.flowrate = 1.
+        pipe1.head_up = 10.
+        print(pipe1.solve_head_down())
+
+        assert abs(pipe1.head_down - 6.262021636) < 1e-6
+
+        pipe1.flowrate = 1.
+        pipe1.head_down = 0.
+        print(pipe1.solve_head_up())
+
+        assert abs(pipe1.head_up - 3.737978364) < 1e-6
+
+        pipe1.flowrate = 1.
+        pipe1.head_up = 10.
+        pipe1.head_down = 0.
+        print(pipe1.solve_k())
+
+        assert abs(pipe1.k - 4.95827141E-03) < 1e-9
+
+    pass

wolfhece/lagrangian/example_domain.py

@@ -93,7 +93,7 @@ def circle_velocity_field(size:int=201, oxoy:tuple[float]=(0.,0.), dxdy:tuple[fl
 
     return ps, t_total
 
-def labyrinth(filename:str=r'doc\examples\labyrinth\lab_uv.npz', nb_particles:int=100, every:float=100.) -> tuple[Particle_system, float]:
+def labyrinth(filename:str=r'docs\source\_static\examples\labyrinth\lab_uv.npz', nb_particles:int=100, every:float=100.) -> tuple[Particle_system, float]:
     """
     Load a labyrinth velocity field from file.
 

wolfhece/mesh2d/bc_manager.py

@@ -7,7 +7,7 @@ from typing import Union,Literal
 from os.path import exists
 from pathlib import Path
 
-from .cst_2D_boundary_conditions import BCType_2D_OO, BCType_2D, ColorsNb, choose_bc_type
+from .cst_2D_boundary_conditions import BCType_2D_OO, BCType_2D, ColorsNb, choose_bc_type, Direction
 from ..PyTranslate import _
 from ..wolf_array import WolfArray
 from .wolf2dprev import prev_boundary_conditions, boundary_condition_2D, prev_parameters_simul
@@ -37,8 +37,11 @@ class BcManager(wx.Frame):
                  DestroyAtClosing=False,
                  Callback=None,
                  mapviewer=None,
+                 wolfparent=None,
                  *args, **kwargs):
 
+        self.wolfparent = wolfparent
+
         self._filename_cl = ''
         self._filename_sux = ''
         self.dx  = dx
@@ -95,6 +98,12 @@ class BcManager(wx.Frame):
             self.Show(True)
             self._plot_init()
 
+        if wolfparent is not None:
+            self.FindBorders()
+            self.parse(wolfparent.sim.bc2txt())
+            self.update_colors()
+
+
     @property
     def linked_array(self):
         return self._linked_array
@@ -276,6 +285,7 @@ class BcManager(wx.Frame):
 
     def OnClose(self, event:wx.MouseEvent):
         """ Close the window """
+
         if self._DestroyAtClosing:
             self._Callback(self)
             self.Destroy()
@@ -526,10 +536,10 @@ class BcManager(wx.Frame):
                 self._checkBC[tbc].Value=True
                 txt=''
                 if values[tbc]['same']:
-                    for curval in values[tbc]['val']:
+                    for curval in values[tbc]['val'].values():
                         txt += str(curval)
                 else:
-                    for curval in values[tbc]['val']:
+                    for curval in values[tbc]['val'].values():
                         txt += str(curval) +' or '
                     txt+='...'
                 self._valueBC[tbc].Value=txt
@@ -546,6 +556,7 @@ class BcManager(wx.Frame):
         self.bordersY['selected'][:]=False
         self.update_colors()
 
+
     def OnClearselection(self,event:wx.MouseEvent):
         """ Clear selection """
         self.Clearselection()
@@ -724,10 +735,45 @@ class BcManager(wx.Frame):
                         text+= "simul.add_boundary_condition(i={}, j={},bc_type=BoundaryConditionsTypes.{}, bc_value={}, border=Direction.{})\n".format(i,j,namebc,val,direction)
         return text
 
+    def send_to_wolfparent(self):
+        """
+        Send BC to parent
+        """
+        from ..PyGui import Wolf2DModel
+
+        if self.wolfparent is not None:
+
+            if isinstance(self.wolfparent, Wolf2DModel):
+
+                self.wolfparent.reset_boundary_conditions()
+
+                for orient in range(1,3):
+                    if orient==1:
+                        curlist=self.bordersX['bc']
+                        direction=Direction.LEFT
+                    else:
+                        curlist=self.bordersY['bc']
+                        direction=Direction.BOTTOM
+
+                    curlist:dict
+                    ij:str
+                    allbc:dict
+
+                    for ij, allbc in curlist.items():
+                        for tbc, val in allbc.items():
+                            i,j=ij.split('-')
+                            namebc=self._find_Enum_TypeBC(tbc)
+
+                            if(str(val)!='99999.0'):
+                                self.wolfparent.add_boundary_condition(int(i), int(j), namebc, float(val), direction)
+
+                self.wolfparent._show_glob_properties()
+
     def parse(self, text:str):
         """
         Parse text and fill bordersX and bordersY
         """
+
         self._filecontent = text
 
         text=text.splitlines()
@@ -755,7 +801,7 @@ class BcManager(wx.Frame):
             orient=int(float(orient))
             value=float(value)
             if orient==1:
-                texttxt=str(i-1)+'-'+str(j-1)
+                texttxt=str(i)+'-'+str(j)
                 try:
                     index=self.bordersX['indicesstr'].index(texttxt)
                     try:
@@ -773,7 +819,7 @@ class BcManager(wx.Frame):
                 except:
                     logging.info('Bad border indices on X ('+str(i)+'-'+str(j)+(')'))
             elif orient==2:
-                texttxt=str(i-1)+'-'+str(j-1)
+                texttxt=str(i)+'-'+str(j)
                 try:
                     index=self.bordersY['indicesstr'].index(texttxt)
                     try:
@@ -798,6 +844,8 @@ class BcManager(wx.Frame):
         """ Apply <<< button"""
         self.parse(self.File.Value)
 
+        self.send_to_wolfparent()
+
     def OnCopyToClipboard(self,event:wx.MouseEvent):
         """ Copy to clipboard"""
         if self.wx_exists:
@@ -996,6 +1044,9 @@ class BcManager(wx.Frame):
         self._color_bc()
         self._update_buffer()
 
+        if self.mapviewer is not None:
+            self.mapviewer.Refresh()
+
     def _color_bc(self):
         """ Color borders according to number of BC """
         nbmax_colors = len(ColorsNb)
@@ -1043,6 +1094,8 @@ class BcManager(wx.Frame):
 
     def _plot_init(self):
         """ Initialize OpenGL - Program shader"""
+        pass
+
         vertex_shader = glCreateShader(GL_VERTEX_SHADER)
         # glShaderSource(vertex_shader, vertex_shader_source)
 
@@ -1089,6 +1142,7 @@ class BcManager(wx.Frame):
 
     def _update_buffer(self):
         """ Update OpenGL buffer """
+        pass
 
         self.buf_vertices = self._get_coords()
 
@@ -1311,6 +1365,13 @@ class BcManager(wx.Frame):
             if name_bc==name:
                 return curbc.name
 
+    def _find_Enum_TypeBC(self,name:str):
+        """Convert nameBC to intBC"""
+        for curbc in self.bc_type:
+            val_bc, name_bc = curbc.value
+            if name_bc==name:
+                return curbc
+
     def get_lists_for_GPU(self) -> tuple[list[boundary_condition_2D], list[boundary_condition_2D]]:
         """
         Return list of BC for GPU computing

wolfhece/mesh2d/config_manager.py

@@ -317,7 +317,7 @@ class config_manager_2D:
             mydata:prev_infiltration
             txt = _('Number of zones : {} \n'.format(mydata.nb_zones))
             for i in range(1,mydata.nb_zones+1):
-                txt += _('Q zone {} : {} \n'.format(i,mydata.my_Q[0][i]))
+                txt += _('Q zone {} : {} \n'.format(i,mydata._infiltrations_chronology[0][i]))
 
             self.txtctrl.Clear()
             self.txtctrl.WriteText(txt)

wolfhece/mesh2d/cst_2D_boundary_conditions.py

@@ -1,5 +1,6 @@
 from enum import Enum
-from typing import Union
+from typing import Union, Literal
+import logging
 
 if not '_' in __builtins__:
     import gettext
@@ -16,6 +17,8 @@ class Direction(Enum):
     Y     = 2
 
 class BCType_2D_GPU(Enum):
+    """ Boundary conditions for 2D simulations with wolfgpu """
+
     # The numbers match the numbers in Wolf's simulations parameters.
     # H    = (1,_('Water level [m]'))
     QX   = (2,_('Flow rate along X [m²/s]'))
@@ -25,7 +28,10 @@ class BCType_2D_GPU(Enum):
     FROUDE_NORMAL = (8,_('Froude normal to the border [-]'))
 
 class BCType_2D(Enum):
+    """ Boundary conditions for 2D simulations """
+
     # The numbers match the numbers in Wolf's 2D simulations parameters.
+    # The values can not be changed freely by the Python user/developer
     H    = (1,_('Water level [m]'))
     QX   = (2,_('Flow rate along X [m²/s]'))
     QY   = (3,_('Flow rate along Y [m²/s]'))
@@ -44,6 +50,10 @@ class BCType_2D(Enum):
     FROUDE_ABSOLUTE = (16,_('norm of Froude in the cell [-]'))
 
 class BCType_2D_OO(Enum):
+    """ Boundary conditions for 2D simulations with Object-Oriented approach """
+
+    # The numbers match the numbers in Wolf's 2D simulations parameters.
+    # The values can not be changed freely by the Python user/developer
     WATER_DEPTH       = (1, _('Water depth [m]'))
     WATER_LEVEL       = (2, _('Water level [m]'))
     FROUDE_NORMAL     = (4, _('Froude normal to the border [-]'))
@@ -57,7 +67,54 @@ class BCType_2D_OO(Enum):
     CLOSE_CONDUIT_QTANGET     = (62, _('Close conduit - tangent discharge [m²/s]'))
     CLOSE_CONDUIT_H_FOR_SPEED = (63, _('Close conduit - h for speed [m]'))
 
-def choose_bc_type(version:Union[int,str] = 1):
+
+def BCType_2D_To_BCType_2D_GPU(bc_type:BCType_2D) -> BCType_2D_GPU:
+
+    if bc_type in [BCType_2D.H, BCType_2D.H.value[0], BCType_2D.HMOD, BCType_2D.HMOD.value[0]]:
+        return BCType_2D_GPU.HMOD
+    elif bc_type in [BCType_2D.QX, BCType_2D.QX.value[0]]:
+        return BCType_2D_GPU.QX
+    elif bc_type in [BCType_2D.QY, BCType_2D.QY.value[0]]:
+        return BCType_2D_GPU.QY
+    elif bc_type in [BCType_2D.NONE, BCType_2D.NONE.value[0]]:
+        return BCType_2D_GPU.NONE
+    elif bc_type in [BCType_2D.FROUDE_NORMAL, BCType_2D.FROUDE_NORMAL.value[0]]:
+        return BCType_2D_GPU.FROUDE_NORMAL
+    else:
+        logging.error(f"BCType_2D_To_BCType_2D_GPU: {bc_type} not found")
+        return None
+
+
+def revert_bc_type(bc_type:Union[BCType_2D,BCType_2D_OO,BCType_2D_GPU], val:int):
+    """
+    Return the BCType corresponding to the given value
+
+    Useful for GUI or scripts
+    """
+
+    if bc_type == BCType_2D:
+        for bc in BCType_2D:
+            if bc.value[0] == val:
+                return bc
+    elif bc_type == BCType_2D_OO:
+        for bc in BCType_2D_OO:
+            if bc.value[0] == val:
+                return bc
+    elif bc_type == BCType_2D_GPU:
+        for bc in BCType_2D_GPU:
+            if bc.value[0] == val:
+                return bc
+
+    return None
+
+
+def choose_bc_type(version:Literal[1,2,3, 'prev', 'oo', 'gpu'] = 1):
+    """
+    Choose the version of the boundary conditions to use
+
+    Useful for GUI
+    """
+
     if version==1 or version =='prev':
         return BCType_2D
     elif version==2 or version =='oo':