wolfhece 2.1.99__py3-none-any.whl → 2.1.101__py3-none-any.whl

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 99
+        self.patch = 101
 
     def __str__(self):
 

wolfhece/bernoulli/losses.py

@@ -10,13 +10,15 @@ copying or distribution of this file, via any medium, is strictly prohibited.
 
 import numpy as np
 from math import pi
-from scipy.optimize import fsolve, newton, root, root_scalar
+from scipy.optimize import newton, root, root_scalar, fsolve
 import matplotlib.pyplot as plt
-from jax import grad, jit, numpy as jnp
+# from jax import grad, jit, numpy as jnp, Array
+from numba import jit
+from jax.scipy.optimize import minimize
 import timeit
 
-@jit
-def _colebrook_white(f, k, diameter, reynolds):
+@jit(nopython=True)
+def _colebrook_white(f:float, k:float, diameter:float, reynolds:float) -> float:
     """
     Colebrook-White equation for friction factor
 
@@ -25,14 +27,17 @@ def _colebrook_white(f, k, diameter, reynolds):
     @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)))
+    ret = 1. / np.sqrt(f) + 2. * np.log10(k / (3.7 * diameter) + 2.51 / (reynolds * np.sqrt(f)))
+    return ret
 
-""" 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)))
+@jit(nopython=True)
+def _grad_colebrook_white(f, k, diameter, reynolds):
 
-def f_colebrook_white(f, k, diameter, reynolds):
+    term1 = -0.5 * f**(-1.5)
+    term2 = 2. * (2.51 / (reynolds * np.sqrt(f))) * (-0.5 * f**(-1.5)) / (k / (3.7 * diameter) + 2.51 / (reynolds * np.sqrt(f)))
+    return term1 + term2
+
+def f_colebrook_white(f:float, k:float, diameter:float, reynolds:float) -> float:
     """
     Solve the Colebrook-White equation using Newton's method
 
@@ -41,11 +46,12 @@ def f_colebrook_white(f, k, diameter, reynolds):
     @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()
 
+    f_sol = fsolve(_colebrook_white, f, args=(k, diameter, reynolds), xtol=1e-14, fprime=_grad_colebrook_white)
+    return f_sol[0]
 
 # Test multiple solvers
+
 def test_colebrook_fsolve():
     """ Test the Colebrook-White equation using Scipy fsolve """
 
@@ -58,7 +64,7 @@ def test_colebrook_fsolve():
     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)
+    f_sol = fsolve(_colebrook_white, f_guess, args=(k, diam, reynolds), xtol=1e-6)
     return f_sol[0]
 
 def test_colebrook_root_scalar():
@@ -73,7 +79,7 @@ def test_colebrook_root_scalar():
     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)
+    f_sol = root_scalar(_colebrook_white, method='brentq', bracket=[1e-10,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():
@@ -89,22 +95,69 @@ def test_colebrook_newton():
 
     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)
+    f_sol = newton(_colebrook_white, f_guess, _grad_colebrook_white, args=(k, diam, reynolds), rtol=1e-6)
     return f_sol.item()
 
+@jit(nopython=True)
+def dichotomy(f, a:float, b:float, args, tol=1e-10, max_iter=1000):
+    def cond_fun(val):
+        a, b, i = val
+        return (b - a) > tol
+
+    def body_fun(val):
+        a, b, i = val
+        c = (a + b) / 2.
+        k, diameter, reynolds = args
+        fa = f(a, k, diameter, reynolds)
+        fc = f(c, k, diameter, reynolds)
+        if fc == 0:
+            return (c, c, i + 1)
+        else:
+            if fa * fc < 0:
+                return (a, c, i + 1)
+            else:
+                return (c, b, i + 1)
+
+    i=0
+    while cond_fun((a, b, i)) and i < max_iter:
+        a, b, i = body_fun((a, b, 0))
+
+    return (a + b) / 2
+
+def test_colebrook_dichotomy():
+    """ 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 = dichotomy(_colebrook_white, 1e-10, 10., (k, diam, reynolds))
+    return f_sol
+
 
 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_ref = f_colebrook_white(.02, 1.e-4, .5, 1/(pi*(.5/2.)**2.)*.5/1.e-6)
+
+    sol_rootscalar = test_colebrook_root_scalar()
+    sol_fsolve     = test_colebrook_fsolve()
+    sol_newton     = test_colebrook_newton()
+    sol_dicho      = test_colebrook_dichotomy()
 
-    sol_newton = f_colebrook_white(.02, 1.e-4, .5, 1/(pi*(.5/2.)**2.)*.5/1.e-6)
+    tfsolve     = timeit.timeit(test_colebrook_fsolve, number = 10000)
+    tnewton     = timeit.timeit(test_colebrook_newton, number = 10000)
+    trootscalar = timeit.timeit(test_colebrook_root_scalar, number = 10000)
+    tdichotomy  = timeit.timeit(test_colebrook_dichotomy, number = 10000)
 
-    assert sol_newton == tnewton
+    assert abs(sol_newton_ref - sol_newton) < 1e-8
+    assert abs(sol_newton_ref - sol_fsolve) < 1e-8
+    assert abs(sol_newton_ref - sol_rootscalar) < 1e-8
+    assert abs(sol_newton_ref - sol_dicho) < 1e-8
 
     pass

wolfhece/bernoulli/losses_jax.py

@@ -0,0 +1,143 @@
+"""
+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 jax
+from jax import lax, jit, grad
+import jax.numpy as jnp
+from jax.scipy.optimize import minimize
+from jax._src.scipy.optimize.bfgs import minimize_bfgs
+from scipy.optimize import minimize as minimize_scipy
+import timeit
+from matplotlib import pyplot as plt
+
+def dichotomy(f, abi:jnp.array, args:jnp.array, tol:jnp.array=jnp.array([1e-8]), max_iter:jnp.array=jnp.array([1000])):
+    """ Dichotomy algorithm to find the root of a function """
+
+    def cond_fun(val:jnp.array) -> bool:
+        """ Condition function for the while loop """
+        a, b, i = val
+        return jnp.any((b - a) > tol) & jnp.any(i < max_iter)
+
+    def body_fun(val:jnp.array) -> jnp.array:
+        """ Body function for the while loop """
+        a, b, i = val
+        c = (a + b) / 2.
+        fa = f(a, args)
+        fc = f(c, args)
+        return lax.cond(fc == 0,
+                        lambda _: jnp.array([c, b, i + 1]),
+                        lambda _: lax.cond(fa * fc < 0,
+                                           lambda _: jnp.array([a, c, i + 1]),
+                                           lambda _: jnp.array([c, b, i + 1]), None), None)
+
+    abi = lax.while_loop(cond_fun, body_fun, abi)
+    return (abi[0] + abi[1]) / 2
+
+@jit
+def _colebrook_white(f:jnp.array, args:jnp.array) -> jnp.array:
+    """
+    Colebrook-White equation for friction factor
+
+    @param args: array containing, k = roughness of the pipe [m], diameter of the pipe [m], Reynolds number [-]
+    """
+    k, diameter, reynolds = args
+    ret = 1. / jnp.sqrt(f) + 2. * jnp.log10(k / (3.7 * diameter) + 2.51 / (reynolds * jnp.sqrt(f)))
+    return ret
+
+@jit
+def _square_colebrook_white(f:jnp.array, args:jnp.array) -> jnp.array:
+    """
+    Square of Colebrook-White equation for friction factor to be minimized
+
+    @param f: float, friction factor [-]
+    @param args: array containing, k = roughness of the pipe [m], diameter of the pipe [m], Reynolds number [-]
+    """
+    return _colebrook_white(f,args)**2
+
+@jit
+def _scalar_exp_square_colebrook_white(g:jnp.array, args:jnp.array) -> jnp.array: #scalar
+    """
+    Square of Colebrook-White equation for friction factor to be minimized.
+
+    Apply a transformation to the friction factor to avoid negative values.
+    Exponential transformation is used.
+
+    @param g: float, friction factor [-]
+    @param args: array containing, k = roughness of the pipe [m], diameter of the pipe [m], Reynolds number [-]
+    """
+    f = jnp.exp(g)
+    return jnp.sum(_colebrook_white(f,args)**2)
+
+_grad_scalar_colebrook_white = grad(_scalar_exp_square_colebrook_white)
+
+@jit
+def grad_colebrook_white(f:jnp.array, args:jnp.array) -> jnp.array:
+    """
+    Gradient of the Colebrook-White equation for friction factor
+
+    @param f: float, friction factor [-]
+    @param args: array containing, k = roughness of the pipe [m], diameter of the pipe [m], Reynolds number [-]
+    """
+
+    # We must apply the exponential transformation to the friction factor
+    # See : _scalar_exp_square_colebrook_white
+    return _grad_scalar_colebrook_white(jnp.log(f), args)
+
+@jit
+def _min_colebrook_white(f:jnp.array, args:jnp.array) -> jnp.array:
+    """
+    Minimize the Colebrook-White equation using BFGS
+
+    @param f: float, initial guess for the friction factor  [-]
+    @param args: array containing, k = roughness of the pipe [m], diameter of the pipe [m], Reynolds number [-]
+    """
+
+    return jnp.sum(jnp.exp(minimize(_scalar_exp_square_colebrook_white, jnp.log(f), args=(args,), method='BFGS', tol=1e-8).x))
+
+
+if __name__ == '__main__':
+
+    args = jnp.array([1.e-4, .5, 1/(jnp.pi*(.5/2.)**2.)*.5/1.e-6])
+
+    # Find the root of the Colebrook-White equation by dichotomy
+    root = dichotomy(_colebrook_white, jnp.array([0.,2.,0]), args)
+    print(f"The root of the function is approximately: {root}")
+
+    optimum  = _min_colebrook_white(jnp.array([0.03]), args)
+
+    print(f"The optimum of the function is approximately: {optimum}")
+    print(f"Delta: {jnp.abs(root - optimum)}")
+
+    # Create a test function to compare the time of execution between dichotomy and BFGS
+    @jit
+    def test_dichotomy():
+        dichotomy(_colebrook_white, jnp.array([0.,2.,0]), args)
+
+    @jit
+    def test_bfgs():
+        _min_colebrook_white(jnp.array([0.03]), args)
+
+    time_dicho = timeit.timeit(test_dichotomy, number=10000)
+    time_bfgs = timeit.timeit(test_bfgs, number=10000)
+    print(f"Time for dichotomy: {time_dicho}")
+    print(f"Time for BFGS: {time_bfgs}")
+
+    # Plot the function and its gradient
+    tested_f = jnp.arange(0.01, 0.03, 0.0001)
+    optimum  = _min_colebrook_white(jnp.array([0.03]), args)
+    all_f    = _square_colebrook_white(tested_f, args)
+    all_grad_ret = grad_colebrook_white(tested_f, args)
+
+    fig,ax = plt.subplots()
+    ax.plot(tested_f, all_f)
+    ax.plot(tested_f, all_grad_ret)
+    ax.scatter(optimum, _square_colebrook_white(optimum, args), color='red', marker='o')
+    ax.scatter(root, _colebrook_white(root, args), color='green', marker='X')
+    plt.show()

wolfhece/bernoulli/pipe.py

@@ -98,7 +98,12 @@ class pipe():
     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)
+        if self.reynolds==0.: # No flow
+            self.f = 0.
+        else:
+            if self.f ==0.:
+                self.f = 0.02
+            self.f = f_colebrook_white(self.f, self.k, self.diameter, self.reynolds)
 
         return self.f
 
@@ -113,7 +118,7 @@ class pipe():
     def solve_flowrate(self):
 
         def loc_bernoulli(flowrate):
-            self.flowrate = flowrate
+            self.flowrate = flowrate[0]
             return self.bernoulli_error
 
         flowrate_solution = fsolve(loc_bernoulli, self.flowrate)

wolfhece/gpuview.py

@@ -376,7 +376,10 @@ class VectorField(Element_To_Draw):
         y[mask] *= newnorms
 
         # recherche du maximum
-        self.max_norm = np.max(newnorms)
+        if newnorms.size > 0:
+            self.max_norm = np.max(newnorms)
+        else:
+            self.max_norm = 0
 
         # x[mask] += np.sign(x[mask])*self.min_size*(1.-norms[mask])
         # y[mask] += np.sign(y[mask])*self.min_size*(1.-norms[mask])

wolfhece/libs/__init__.py

@@ -2,6 +2,7 @@ from pathlib import Path
 import sys
 import os
 import shutil
+import logging
 
 """
 Mandatory DLLs for MKL and Fortran.
@@ -39,26 +40,26 @@ def find_Librarybin(which, test):
     sites = sys.path
 
     candidate = interpreter_path / 'Library/bin'
-    print(f'Searching {which} in {candidate}')
+    logging.debug(f'Searching {which} in {candidate}')
     if candidate.exists():
         if (candidate/test).exists():
-            print(f"Found {which} in {candidate}")
+            logging.debug(f"Found {which} in {candidate}")
             return candidate
 
     candidate = interpreter_path.parent / 'Library/bin'
-    print(f'Searching {which} in {candidate}')
+    logging.debug(f'Searching {which} in {candidate}')
     if candidate.exists():
         if (candidate/test).exists():
-            print(f"Found {which} in {candidate}")
+            logging.debug(f"Found {which} in {candidate}")
             return candidate
 
     for cursite in sites:
         if 'site-packages' in cursite:
             candidate = Path(cursite).parent.parent / 'Library/bin'
-            print(f'Searching {which} in {candidate}')
+            logging.debug(f'Searching {which} in {candidate}')
             if candidate.exists():
                 if (candidate/test).exists():
-                    print(f"Found {which} in {candidate}")
+                    logging.debug(f"Found {which} in {candidate}")
                     return candidate
 
     return None
@@ -67,9 +68,9 @@ mkl_path = find_Librarybin('MKL', MKL_DLLS[0])
 fortran_path = find_Librarybin('FORTRAN', FORTRAN_DLLS[0])
 
 if mkl_path is None:
-    print("MKL package not found -- Please install MKL with 'pip install mkl'")
+    logging.error("MKL package not found -- Please install MKL with 'pip install mkl'")
 if fortran_path is None:
-    print("Fortran package not found -- Please install Intel Fortran RunTime with 'pip install intel_fortran_rt'")
+    logging.error("Fortran package not found -- Please install Intel Fortran RunTime with 'pip install intel_fortran_rt'")
 
 if mkl_path is None or fortran_path is None:
     raise FileNotFoundError("Missing MKL or Fortran package. Please check the output above.")
@@ -82,7 +83,7 @@ if mkl_path.exists():
         dll_path = mkl_path / dll
         if not dll_path.exists():
             error = True
-            print(f"Missing DLL: {dll} in {mkl_path}")
+            logging.error(f"Missing DLL: {dll} in {mkl_path}")
         else:
             if not (mydir / dll).exists():
                 shutil.copy(dll_path, mydir / dll)
@@ -91,7 +92,7 @@ for dll in FORTRAN_DLLS:
     dll_path = fortran_path / dll
     if not dll_path.exists():
         error = True
-        print(f"Missing DLL: {dll} in {fortran_path}")
+        logging.error(f"Missing DLL: {dll} in {fortran_path}")
     else:
         if not (mydir / dll).exists():
             shutil.copy(dll_path, mydir / dll)

wolfhece/math_parser/__init__.py

@@ -225,16 +225,16 @@ class Parser:
 
     def add(self, a, b):
         return a + b
-    
+
     def norm(self, a, b):
         return math.sqrt(a * a + b * b)
-    
+
     def Froude(self, a, b, c):
 
         return math.sqrt(a * a + b * b) / math.sqrt(9.81 * c)
-    
+
     def sto(self, a, b):
-        return dict(a = b)
+        return {a : b}
 
     def sub(self, a, b):
         return a - b

wolfhece/math_parser/calculator.py

@@ -12,10 +12,18 @@ import wx
 import logging
 from pathlib import Path
 
-
+from ..PyTranslate import _
 from . import Parser, Expression
 
 class Calculator(wx.Frame):
+    """
+    Calculator/Array creator
+
+    With this calculator, you can create arrays and perform operations on them.
+    It is possible because the operations are parsed and evaluated by the math_parser module
+    and mathematic operators are allowed directly on WolfArrays.
+
+    """
 
     def __init__(self, mapviewer=None):
 
@@ -23,7 +31,7 @@ class Calculator(wx.Frame):
 
         super(Calculator, self).__init__(None, title='Calculator', size=(500, 300))
 
-        self._memory = {}
+        self._memory = {} # dictionary containing the arrays and local stored variables
 
         self._parser = Parser()
         self._parsed_command:Expression = None
@@ -37,7 +45,11 @@ class Calculator(wx.Frame):
         self._disp = wx.TextCtrl(self, style=wx.TE_RIGHT|wx.TE_RICH2|wx.TE_MULTILINE)
 
         self._comment = wx.TextCtrl(self, style=wx.TE_RIGHT|wx.TE_RICH2|wx.TE_MULTILINE)
-        self.memory   = wx.TextCtrl(self, style=wx.TE_RIGHT|wx.TE_RICH2|wx.TE_MULTILINE)
+        self._comment.SetToolTip(_('Comment block'))
+
+        self._memory_txtctrl   = wx.TextCtrl(self, style=wx.TE_RIGHT|wx.TE_RICH2|wx.TE_MULTILINE)
+        self._memory_txtctrl.SetToolTip(_('Memory positions (contains the ids of the arrays and local variables)'))
+
         self.btn_reset_memory = wx.Button(self, label='Reset Memory')
 
         self.Bind(wx.EVT_BUTTON, lambda v: self.bt_press(v.EventObject.Label))
@@ -45,9 +57,9 @@ class Calculator(wx.Frame):
         self._btns[-1][-2].SetDefault()
 
         self.Bind(wx.EVT_CHAR_HOOK, self.char_press)
-        self.btn_reset_memory.Bind(wx.EVT_BUTTON, lambda v: self._memory.clear())
+        self.btn_reset_memory.Bind(wx.EVT_BUTTON, self.memory_clear_event)
 
-        self.SetSizer(self.pack([self._disp] + [self.pack(x) for x in self._btns] + [self.pack([self._comment, self.btn_reset_memory, self.memory])], orient=wx.VERTICAL))
+        self.SetSizer(self.pack([self._disp] + [self.pack(x) for x in self._btns] + [self.pack([self._comment, self.btn_reset_memory, self._memory_txtctrl])], orient=wx.VERTICAL))
 
         self._disp.SetFocus()
 
@@ -56,6 +68,7 @@ class Calculator(wx.Frame):
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self.SetIcon(icon)
 
+        self.memory_clear()
         self.Show()
 
     def pack(self, items, orient=wx.HORIZONTAL):
@@ -79,7 +92,34 @@ class Calculator(wx.Frame):
 
     @comment.setter
     def comment(self, value):
-        self._comment.Value = str(value)
+        self._comment.Value += str(value)
+
+    def reset_comment(self):
+        self._comment.Value = ''
+
+    @property
+    def memory_txt(self):
+        return self._memory_txtctrl.Value
+
+    @memory_txt.setter
+    def memory_txt(self, value):
+        self._memory_txtctrl.Value += str(value)+'\n'
+
+    def reset_memory(self):
+        self._memory_txtctrl.Value = ''
+
+    def memory_clear(self):
+        self.reset_memory()
+        self._memory.clear()
+
+        if self._mapviewer is not None:
+            from ..PyDraw import draw_type
+            ids = self._mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS, checked_state=None)
+            for id in ids:
+                self.memory_txt += id
+
+    def memory_clear_event(self, e):
+        self.memory_clear()
 
     def check_command(self) -> bool:
         """ Check if the command is valid """
@@ -121,14 +161,15 @@ class Calculator(wx.Frame):
 
         ret = []
         for command in commands:
+            if command == '': continue
             self.command = command
             ret.append(str(self.evaluate(mem_last_command=False)))
 
         self.command = '\n'.join(ret)
 
-
     def evaluate(self, mem_last_command=True):
         """ Evaluate the command """
+
         from ..PyDraw import WolfArray, draw_type
 
         if mem_last_command:
@@ -146,9 +187,10 @@ class Calculator(wx.Frame):
 
                 for key, value in res.items():
                     self._memory[key] = value
-                    comment += f'{key} = {value}\n'
 
-                self.comment = comment
+                    self.comment += f'{key} = {value}\n'
+                    self.memory_txt  += key
+
                 self.command = ''
 
             elif isinstance(res, str|int|float):

wolfhece/mesh2d/bc_manager.py

@@ -17,7 +17,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, Direction
+from .cst_2D_boundary_conditions import BCType_2D_OO, BCType_2D, ColorsNb, choose_bc_type, Direction, BCType_2D_GPU
 from ..PyTranslate import _
 from ..wolf_array import WolfArray
 from .wolf2dprev import prev_boundary_conditions, boundary_condition_2D, prev_parameters_simul
@@ -749,7 +749,7 @@ class BcManager(wx.Frame):
         """
         Send BC to parent
         """
-        from ..PyGui import Wolf2DModel
+        from ..PyGui import Wolf2DModel, Wolf2DGPUModel
 
         if self.wolfparent is not None:
 
@@ -779,6 +779,29 @@ class BcManager(wx.Frame):
 
                 self.wolfparent._show_glob_properties()
 
+            elif isinstance(self.wolfparent, Wolf2DGPUModel):
+                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)
+
     def parse(self, text:str):
         """
         Parse text and fill bordersX and bordersY