wolfhece 2.0.55__py3-none-any.whl → 2.1.1__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

@@ -887,6 +887,7 @@ if :\n \
                 return 'SanSerif'
             else:
                 return 'Arial'
+
 class vector:
     """
     Objet de gestion d'informations vectorielles
@@ -911,11 +912,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
@@ -1047,6 +1051,9 @@ class vector:
         """
         Return tuple with :
           - (lower-left corner), (upper-right corner)
+
+        If you want [[xmin,xmax],[ymin,ymax]], use get_bounds_xx_yy() instead.
+
         """
         if grid is None:
             return ((self.xmin, self.ymin), (self.xmax, self.ymax))
@@ -1062,6 +1069,9 @@ class vector:
         """
         Return tuple with :
           - (xmin,xmax), (ymin, ymax)
+
+        If you want [[lower-left corner],[upper-right corner]], use get_bounds() instead.
+
         """
         if grid is None:
             return ((self.xmin, self.xmax), (self.ymin, self.ymax))
@@ -1095,6 +1105,7 @@ class vector:
         """
         Mise en évidence
         """
+
         self._oldcolor = self.myprop.color
         self._oldwidth = self.myprop.color
 
@@ -1105,6 +1116,7 @@ class vector:
         """
         Mise en retrait
         """
+
         try:
             self.myprop.color = self._oldcolor
             self.myprop.width = self._oldwidth
@@ -1367,12 +1379,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 +1812,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 +2159,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)
 
-            return copied_vector
+        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
+
+        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:
     """
@@ -2369,8 +2393,13 @@ class zone:
     def add_vector(self, addedvect:vector, index=-99999, forceparent=False):
         """
         Ajout d'une instance 'vector'
-        Le compteur est incrémenté
+
+        :param addedvect: instance 'vector' à ajouter
+        :param index: position d'insertion
+        :param forceparent: True = forcer le parent à être la zone dans lequel le vecteur est ajouté
+
         """
+
         if index==-99999 or index >self.nbvectors:
             self.myvectors.append(addedvect)
         else:
@@ -2474,8 +2503,13 @@ class zone:
             if self.idgllist!=-99999:
                 glCallList(self.idgllist)
             else:
+                self.has_legend = False
+                self.has_image  = False
+
                 for curvect in self.myvectors:
                     curvect.plot()
+                    self.has_legend |= curvect.myprop.legendvisible
+                    self.has_image  |= curvect.myprop.imagevisible
 
         if self.has_legend:
             for curvect in self.myvectors:
@@ -3657,6 +3691,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
@@ -4398,6 +4440,7 @@ class Zones(wx.Frame, Element_To_Draw):
             boxright.Add(self.capturevertices,0,wx.EXPAND)
             boxright.Add(self.dynapar,0,wx.EXPAND)
             boxright.Add(self.createapar,0,wx.EXPAND)
+            boxright.Add(self.reverseorder,0,wx.EXPAND)
             boxright.Add(self.modifyvertices,0,wx.EXPAND)
             boxright.Add(self.insertvertices,0,wx.EXPAND)
             boxright.Add(self.splitvertices,0,wx.EXPAND)
@@ -4699,8 +4742,56 @@ class Zones(wx.Frame, Element_To_Draw):
         """
         Remplissage de la structure wx
         """
+
+        def store_tree_state(tree:TreeListCtrl):
+
+            expended_items = []
+            root = tree.GetRootItem()
+
+            if root is None:
+                return
+
+            def traverse_and_store(item):
+                if not item.IsOk():
+                    return
+                if tree.IsExpanded(item):
+                    expended_items.append(tree.GetItemData(item))
+
+                child = tree.GetFirstChild(item)
+                while child.IsOk():
+                    traverse_and_store(child)
+                    child = tree.GetNextItem(child)
+
+            traverse_and_store(root)
+
+            return expended_items
+
+        def restore_tree_state(tree:TreeListCtrl, expended_items):
+
+            root = tree.GetRootItem()
+
+            if root is None:
+                return
+
+            def traverse_and_restore(item):
+                if not item.IsOk():
+                    return
+
+                if tree.GetItemData(item) in expended_items:
+                    tree.Expand(item)
+
+                child = tree.GetFirstChild(item)
+                while child.IsOk():
+                    traverse_and_restore(child)
+                    child = tree.GetNextItem(child)
+
+            traverse_and_restore(root)
+
         if self.wx_exists:
             if self.xls is not None:
+
+                expanded = store_tree_state(self.treelist)
+
                 self.treelist.DeleteAllItems()
 
                 root = self.treelist.GetRootItem()
@@ -4712,6 +4803,8 @@ class Zones(wx.Frame, Element_To_Draw):
 
                 self.treelist.Expand(mynode)
 
+                restore_tree_state(self.treelist, expanded)
+
     def expand_tree(self, objzone=None):
         """
         Développe la structure pour un objet spécifique stocké dans la self.treelist
@@ -5594,17 +5687,54 @@ class Zones(wx.Frame, Element_To_Draw):
             else:
                 myitemdata.unuse()
 
+    def _callback_destroy_props(self):
+
+        self.myprops = None
+
+    def _callback_prop(self):
+
+        if self._myprops is None:
+            logging.warning(_('No properties available'))
+            return
+
+        for curzone in self.myzones:
+            for curvec in curzone.myvectors:
+                curvec.myprop.fill_property(self._myprops, updateOGL = False)
+
+        if self.mapviewer is not None:
+            self.prep_listogl()
+            self.mapviewer.Refresh()
+
+
+    def _edit_all_properties(self):
+        """ Show properties of the zone --> will be applied to all vectors int he zone """
+
+        locvec = vector()
+        locvec.myprop.show()
+
+        self._myprops = locvec.myprop.myprops
+
+        self._myprops[('Legend','X')] = 99999.
+        self._myprops[('Legend','Y')] = 99999.
+        self._myprops[('Legend','Text')] = _('Not used')
+        self._myprops.Populate()
+        self._myprops.set_callbacks(self._callback_prop, self._callback_destroy_props)
+
+
     def OnRDown(self, event:TreeListEvent):
         """
         Affiche les propriétés du vecteur courant
         Clicl-droit
         """
         if self.wx_exists:
-            if self.verify_activevec() and self.verify_activezone():
-                return
+            if self.active_zone is None and self.active_zone is None:
+
+                logging.info(_('You will edit the properties of the entire instance (all zones and all vectors)'))
+                self._edit_all_properties()
 
-            if isinstance(self.last_active, vector):
+            elif isinstance(self.last_active, vector):
                 self.active_vector.myprop.show()
+
             elif isinstance(self.last_active, zone):
                 self.active_zone.show_properties()
 
@@ -5620,6 +5750,9 @@ class Zones(wx.Frame, Element_To_Draw):
                 self.Activate_vector(myitemdata)
             elif isinstance(myitemdata,zone):
                 self.Activate_zone(myitemdata)
+            else:
+                self.Activate_vector(None)
+                self.Activate_zone(None)
 
             self.last_active = myitemdata
 
@@ -5631,6 +5764,12 @@ class Zones(wx.Frame, Element_To_Draw):
         """
         if self.wx_exists:
             self.active_vector = object
+
+            if self.active_vector is None:
+                logging.info(_('Active vector is now set to None'))
+                self.xls.ClearGrid()
+                return
+
             self.xls_active_vector()
 
             if object.parentzone is not None:
@@ -5656,12 +5795,22 @@ class Zones(wx.Frame, Element_To_Draw):
         """
         if self.wx_exists:
             self.active_zone = object
+
+            if self.active_zone is None:
+                logging.info(_('Active zone is now set to None'))
+                self.xls.ClearGrid()
+                return
+
             if object.active_vector is not None:
                 self.active_vector = object.active_vector
             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 = 55
+        self.minor = 1
+        self.patch = 1
 
     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