wolfhece 2.1.98__py3-none-any.whl → 2.1.100__py3-none-any.whl

wolfhece/analyze_vect.py

@@ -0,0 +1,177 @@
+
+from pathlib import Path
+import numpy as np
+from shapely.geometry import Polygon, Point, LineString
+from shapely import prepare, is_prepared, destroy_prepared
+
+import wx
+import logging
+from tqdm import tqdm
+
+from .PyTranslate import _
+from .PyVertexvectors import Zones, zone, vector, wolfvertex
+from .matplotlib_fig import Matplotlib_Figure as mpl_plot, Matplotlib_ax_properties as mpl_ax, Matplolib_line_properties as mpl_line, Matplotlib_figure_properties as mpl_fig
+from .matplotlib_fig import PRESET_LAYOUTS
+from .wolf_array import WolfArray
+from .wolfresults_2D import Wolfresults_2D
+from .Results2DGPU import wolfres2DGPU
+
+class Compare_vectors():
+    """ Compare multiple vectors """
+
+    def __init__(self) -> None:
+
+        self.fig:mpl_plot = None
+
+        self._reference:vector = None
+        self._reference_ls:LineString = None
+        self._ref_s:np.ndarray = None
+        self._ref_obj:dict[str, WolfArray | wolfres2DGPU | Wolfresults_2D] = {}
+        self._ref_values:zone = None
+
+        self._to_compare:dict[vector, list[WolfArray | wolfres2DGPU | Wolfresults_2D]] = {}
+        self._compare_values:dict[vector, zone] = {}
+
+    @property
+    def layout(self):
+        """ Layout of the figure """
+        return self.fig.layout
+
+    @layout.setter
+    def layout(self, value:dict | tuple | list | str):
+        """ Set layout of the figure """
+        self.fig = mpl_plot(value)
+        self.fig.Show()
+
+    @property
+    def reference(self):
+        """ Reference vector """
+        return self._reference
+
+    @reference.setter
+    def reference(self, value:vector):
+        """ Set reference vector """
+        if not isinstance(value, vector):
+            logging.error(_('Reference must be a vector'))
+            return
+
+        self._reference = value
+        self._reference_ls = value.asshapely_ls()
+        prepare(self._reference_ls)
+        self._ref_s = self._reference.get_s2d()
+
+    def __del__(self):
+        """ Destructor """
+
+        if self._reference_ls is not None:
+            if is_prepared(self._reference_ls):
+                destroy_prepared(self._reference_ls)
+
+    def add_ref_values(self, values:WolfArray | wolfres2DGPU | Wolfresults_2D):
+        """ Add values to the reference vector """
+
+        self._ref_obj[values.idx] = values
+
+    def del_ref_values(self, which:int | str):
+        """ Pop values from the reference vector """
+
+        if isinstance(which, str):
+            if which in self._ref_obj:
+                self._ref_obj.pop(which)
+        elif isinstance(which, int):
+            if which < len(self._ref_obj):
+                self._ref_obj.pop(list(self._ref_obj.keys())[which])
+
+    def reset_ref_values(self):
+        """ Reset reference values """
+
+        self._ref_obj = {}
+
+    def get_ref_values(self):
+        """ Retrieve reference values """
+
+        self._ref_values = self.reference.get_values_linked(self._ref_obj)
+
+    def add_compare(self, support:vector, values:list[WolfArray | wolfres2DGPU | Wolfresults_2D] = None):
+        """ Add values to compare """
+
+        if not isinstance(support, vector):
+            logging.error(_('Support must be a vector'))
+            return
+
+        if values is not None:
+            if not isinstance(values, list):
+                values = [values]
+
+            if isinstance(values, list):
+                if not all(isinstance(x, WolfArray | wolfres2DGPU | Wolfresults_2D) for x in values):
+                    logging.error(_('Values must be a list of WolfArray, Wolfresults_2D or Wolfres2DGPU'))
+                    return
+
+        if support in self._to_compare:
+            self._to_compare[support] += values
+        else:
+            self._to_compare[support] = values
+
+    def reset_compare(self):
+        """ Reset comparison values """
+
+        self._to_compare = {}
+
+    def del_compare(self, which:int | str):
+        """ Pop values from the comparison vector """
+
+        if isinstance(which, str):
+            if which in self._to_compare:
+                self._to_compare.pop(which)
+        elif isinstance(which, int):
+            if which < len(self._to_compare):
+                self._to_compare.pop(list(self._to_compare.keys())[which])
+
+    def get_compare_values(self):
+        """ Retrieve comparison values """
+
+        for curvect in self._to_compare:
+            self._compare_values[curvect] = curvect.get_values_linked({cur.idx: cur for cur in self._to_compare[curvect]})
+
+    def plot_ref(self, axis:int = 0):
+        """ Plot reference vector """
+
+        if self.fig is None:
+            logging.error(_('No figure layout defined'))
+            return
+
+        for curvect in self._ref_values.myvectors:
+            xyz = curvect.asnparray3d()
+            x = [self._reference_ls.project(Point(x,y)) for x,y in xyz[:,0:2]]
+            y = xyz[:,2]
+
+            self.fig.plot(x=x, y=y, ax=axis, label=curvect.myname)
+
+    def plot_compare(self, axis:int = 0):
+        """ Plot comparison vectors along reference vector.
+
+        We must project comparison vectors on the reference vector and plot them.
+        """
+
+        if self.fig is None:
+            logging.error(_('No figure layout defined'))
+            return
+
+        for curvect in self._compare_values:
+            for curval in self._compare_values[curvect].myvectors:
+                xyz = curval.asnparray3d()
+                x = [self._reference_ls.project(Point(x,y)) for x,y in xyz[:,0:2]]
+                y = xyz[:,2]
+
+                self.fig.plot(x=x, y=y, ax=axis, label=curval.myname)
+
+    def set_x_bounds(self, smin:float, smax:float, axis:int = 0):
+        """ Set x bounds for the figure """
+
+        self.fig.set_x_bounds(smin, smax, axis)
+
+    def set_y_bounds(self, ymin:float, ymax:float, axis:int = 0):
+        """ Set y bounds for the figure """
+
+        self.fig.set_y_bounds(ymin, ymax, axis)

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 98
+        self.patch = 100
 
     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):
+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
+def _grad_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, k, diameter, reynolds):
+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
+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/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,33 @@ 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()
+
+        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 +160,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 +186,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):