wolfhece 2.0.54__py3-none-any.whl → 2.1.0__py3-none-any.whl

wolfhece/PyVertex.py

@@ -169,6 +169,19 @@ class wolfvertex:
         self.y = max(self.y, bounds[1][0])
         self.y = min(self.y, bounds[1][1])
 
+    def is_like(self, v:"wolfvertex", tol:float=1.e-6):
+        """
+        Return True if the vertex is close to another one
+
+        :param v: vertex to compare
+        :param tol: tolerance
+        """
+
+        if abs(self.x - v.x) < tol and abs(self.y - v.y) < tol and abs(self.z - v.z) < tol:
+            return True
+        else:
+            return False
+
 class cloudproperties:
     """
     Properties of a cloud of vertices
@@ -854,7 +867,7 @@ class cloud_vertices(Element_To_Draw):
                 curvert = self.myvertices[item]['vertex']
 
                 if curvert.x > xmin and curvert.x < xmax and curvert.y > ymin and curvert.y < ymax:
-            
+
                     r,g,b = getRGBfromI(self.myprop.legendcolor)
 
                     curtxt_infos = Text_Infos(self.myprop.legendpriority,

wolfhece/PyVertexvectors.py

@@ -911,11 +911,14 @@ class vector:
 
     def __init__(self, lines:list=[], is2D=True, name='NoName', parentzone:"zone"=None, fromshapely=None) -> None:
         """
-        lines : utile pour lecture de fichier
-        is2D : on interprète les 'vertices' comme 2D même si chaque 'wolfvertex' contient toujours x, y et z
-        name : nom du vecteur
-        parentzone : instance de type 'zone' qui contient le 'vector'
+
+        :param lines: utile pour lecture de fichier
+        :param is2D: on interprète les 'vertices' comme 2D même si chaque 'wolfvertex' contient toujours x, y et z
+        :param name: nom du vecteur
+        :param parentzone: instance de type 'zone' qui contient le 'vector'
+
         """
+
         self.myname=''
         self.is2D = is2D
         self.closed=False
@@ -1367,12 +1370,12 @@ class vector:
         # again checks that the vector is not closed; in the case where
         # two vertices are not the same one but have the same coordinates)
 
-        is_open = self.myvertices[-1] is not self.myvertices[0] or \
-            (self.myvertices[-1].x!=self.myvertices[0].x or \
-             self.myvertices[-1].y!=self.myvertices[0].y)
+        is_open = not((self.myvertices[-1] is self.myvertices[0]) or \
+            (self.myvertices[-1].x==self.myvertices[0].x and \
+             self.myvertices[-1].y==self.myvertices[0].y))
 
         if not self.is2D :
-            is_open = is_open and self.myvertices[-1].z!=self.myvertices[0].z
+            is_open = is_open or self.myvertices[-1].z!=self.myvertices[0].z
 
         if is_open:
             self.add_vertex(self.myvertices[0])
@@ -1800,10 +1803,10 @@ class vector:
 
         if length<1:
             length*=1000.
-            alls = np.linspace(0,int(length),nb)
+            alls = np.linspace(0, length, nb)
             alls/=1000.
         else:
-            alls = np.linspace(0,int(length),nb,endpoint=True)
+            alls = np.linspace(0, length, nb, endpoint=True)
 
         pts = [myls.interpolate(curs) for curs in alls]
         # pts = [(curpt.x, curpt.y) for curpt in pts]
@@ -2147,16 +2150,28 @@ class vector:
 
         if name is None:
             name = self.myname + "_copy"
-            if parentzone:
-                copied_vector = vector(name=name,parentzone=parentzone)
-            else:
-                copied_vector = vector(name=name)
 
-            copied_vector.myvertices = copy.deepcopy(self.myvertices)
-            # copied_vector.nbvertices = copy.deepcopy(self.nbvertices)
+        if parentzone:
+            copied_vector = vector(name=name,parentzone=parentzone)
+        else:
+            copied_vector = vector(name=name)
+
+        copied_vector.myvertices = copy.deepcopy(self.myvertices)
+
+        return copied_vector
+
+    def set_legend_to_centroid(self, text:str='', visible:bool=True):
+        """
+        Positionne la légende au centre du vecteur
+        """
+        self.myprop.legendvisible = visible
 
-            return copied_vector
+        ls = self.asshapely_pol()
+        centroid = ls.centroid
 
+        self.myprop.legendx = centroid.x
+        self.myprop.legendy = centroid.y
+        self.myprop.legendtext = text if text else self.myname
 
 class zone:
     """
@@ -3657,6 +3672,14 @@ class zone:
         if self.parent.mapviewer is not None:
             self.prep_listogl()
             self.parent.mapviewer.Refresh()
+
+    def set_legend_to_centroid(self):
+        """
+        Set the legend to the centroid of the zone
+        """
+        for curvec in self.myvectors:
+            curvec.set_legend_to_centroid()
+
 class Zones(wx.Frame, Element_To_Draw):
     """
     Objet de gestion d'informations vectorielles
@@ -5661,7 +5684,11 @@ class Zones(wx.Frame, Element_To_Draw):
             elif object.nbvectors>0:
                 self.Activate_vector(object.myvectors[0])
 
-            self.labelactvect.SetLabel(self.active_vector.myname)
+            if self.active_vector is None:
+                logging.warning(_('No vector in the active zone'))
+            else:
+                self.labelactvect.SetLabel(self.active_vector.myname)
+
             self.labelactzone.SetLabel(self.active_zone.myname)
             self.Layout()
 

wolfhece/Results2DGPU.py

@@ -500,8 +500,7 @@ class Sim_2D_GPU():
         self.loaded = False
 
         if self.filename.exists():
-            self.sim = SimpleSimulation()
-            self.sim.load(self.filename)
+            self.sim = SimpleSimulation.load(self.filename)
             self.loaded = True
 
         pass

wolfhece/apps/version.py

@@ -4,8 +4,8 @@ class WolfVersion():
     def __init__(self):
 
         self.major = 2
-        self.minor = 0
-        self.patch = 54
+        self.minor = 1
+        self.patch = 0
 
     def __str__(self):
 

wolfhece/bernoulli/chamber.py

@@ -0,0 +1,93 @@
+import numpy as np
+from math import pi
+
+class chamber():
+
+    def __init__(self) -> None:
+
+        self.area = 10. # m^2
+        self.elevation = 0. # m
+        self._volume = 100. # m^3
+        self._height = 10. # m
+
+        self.q_in  = []
+        self.q_out = []
+
+        self.is_bc = False
+        self.bc_value = 0.
+
+    def reset_q(self):
+        self.q_in = []
+        self.q_out = []
+
+    def add_qin(self, q):
+        self.q_in.append(q)
+
+    def add_qout(self, q):
+        self.q_out.append(q)
+
+    @property
+    def volume(self):
+        return self._volume
+
+    @volume.setter
+    def volume(self, value):
+        self._volume = value
+        self.solve_height()
+
+    @property
+    def height(self):
+        return self._height
+
+    @height.setter
+    def height(self, value):
+        self._height = value
+        self.solve_volume()
+
+    def solve_volume(self):
+        self._volume = self.area * self.height
+        return self._volume
+
+    def solve_height(self):
+        self._height = self.volume / self.area
+        return self._height
+
+    def update(self, dt:float):
+
+        if self.is_bc:
+            self.head = self.bc_value
+        else:
+            self.volume += (np.sum(np.asarray(self.q_in)) - np.sum(np.asarray(self.q_out))) * dt
+            self.solve_height()
+
+    @property
+    def head(self):
+        return self.elevation + self.height
+
+    @head.setter
+    def head(self, value):
+        self.height = value - self.elevation
+        self.solve_volume()
+
+class junction(chamber):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.area = 1.e-2
+        self.volume = 0.
+        self.height = 0.
+        self.elevation = 0.
+
+        self._head = 0.
+
+    @property
+    def head(self):
+        return self._head
+
+    @head.setter
+    def head(self, value):
+        self._head = value
+
+    def update(self, dt:float):
+
+        self.head += (np.sum(np.asarray(self.q_in)) - np.sum(np.asarray(self.q_out))) * dt

wolfhece/bernoulli/fluids.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class Water():
+
+    rho:float = 1000.
+    mu:float  = 1e-3
+
+    @property
+    def nu(self) -> float:
+        return self.mu / self.rho

wolfhece/bernoulli/losses.py

@@ -0,0 +1,100 @@
+import numpy as np
+from math import pi
+from scipy.optimize import fsolve, newton, root, root_scalar
+import matplotlib.pyplot as plt
+from jax import grad, jit, numpy as jnp
+import timeit
+
+@jit
+def _colebrook_white(f, k, diameter, reynolds):
+    """
+    Colebrook-White equation for friction factor
+
+    @param f: float, friction factor [-]
+    @param k: float, roughness of the pipe [m]
+    @param diameter: float, diameter of the pipe [m]
+    @param reynolds: float, Reynolds number [-]
+    """
+    return 1. / jnp.sqrt(f) + 2. * jnp.log10(k / (3.7 * diameter) + 2.51 / (reynolds * jnp.sqrt(f)))
+
+""" Gradient of the Colebrook-White equation """
+grad_colebrook_white = jit(grad(_colebrook_white))
+""" Second derivative of the Colebrook-White equation """
+grad2_colebrook_white = jit(grad(grad(_colebrook_white)))
+
+def f_colebrook_white(f, k, diameter, reynolds):
+    """
+    Solve the Colebrook-White equation using Newton's method
+
+    @param f: float, initial guess for the friction factor  [-]
+    @param k: float, roughness of the pipe [m]
+    @param diameter: float, diameter of the pipe [m]
+    @param reynolds: float, Reynolds number [-]
+    """
+    f_sol = newton(_colebrook_white, f, grad_colebrook_white, args=(k, diameter, reynolds), rtol=1e-6)
+    return f_sol.item()
+
+
+# Test multiple solvers
+def test_colebrook_fsolve():
+    """ Test the Colebrook-White equation using Scipy fsolve """
+
+    k= 1.e-4
+    diam = .5
+    viscosity = 1.e-6
+    area = pi * (diam/2.)**2.
+    discharge = 1.
+    velocity = discharge / area
+    reynolds = velocity * diam / viscosity
+
+    f_guess = 0.02  # Initial guess for the friction factor
+    f_sol = fsolve(_colebrook_white, f_guess, args=(k, diam, reynolds), xtol=1e-14)
+    return f_sol[0]
+
+def test_colebrook_root_scalar():
+    """ Test the Colebrook-White equation using Scipy root_scalar """
+
+    k= 1.e-4
+    diam = .5
+    viscosity = 1.e-6
+    area = pi * (diam/2.)**2.
+    discharge = 1.
+    velocity = discharge / area
+    reynolds = velocity * diam / viscosity
+
+    f_guess = 0.02  # Initial guess for the friction factor
+    f_sol = root_scalar(_colebrook_white, method='brentq', bracket=[0.,10.], x0 = f_guess, args=(k, diam, reynolds)) #, fprime = grad_colebrook_white, fprime2 = grad2_colebrook_white, xtol=1e-6)
+    return f_sol.root
+
+def test_colebrook_newton():
+    """ Test the Colebrook-White equation using Scipy newton """
+
+    k= 1.e-4
+    diam = .5
+    viscosity = 1.e-6
+    area = pi * (diam/2.)**2.
+    discharge = 1.
+    velocity = discharge / area
+    reynolds = velocity * diam / viscosity
+
+    f_guess = 0.02  # Initial guess for the friction factor
+
+    f_sol = newton(_colebrook_white, f_guess, grad_colebrook_white, args=(k, diam, reynolds), rtol=1e-6)
+    return f_sol.item()
+
+
+if __name__ == '__main__':
+
+    trootscalar = timeit.timeit(test_colebrook_root_scalar, number = 1000)
+    tfsolve     = timeit.timeit(test_colebrook_fsolve, number = 1000)
+    tnewton     = timeit.timeit(test_colebrook_newton, number = 1000)
+
+    trootscalar = test_colebrook_root_scalar()
+    tfsolve     = test_colebrook_fsolve()
+    tnewton     = test_colebrook_newton()
+
+    sol_newton = f_colebrook_white(.02, 1.e-4, .5, 1/(pi*(.5/2.)**2.)*.5/1.e-6)
+
+    assert sol_newton == tnewton
+
+    pass

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.