wolfhece 2.1.128__py3-none-any.whl → 2.2.1__py3-none-any.whl

wolfhece/tools2d_dll.py

@@ -0,0 +1,359 @@
+from pathlib import Path
+import numpy as np
+import ctypes as ct
+import logging
+
+from .wolf_array import header_wolf, getkeyblock
+
+try:
+    import pefile
+except ImportError:
+    logging.warning("pefile module not found. Exported functions will not be listed.")
+
+
+class Tools2DFortran:
+    """
+    Fortran routines/functions available in "2d_cpu_tools.f90" in Wolf_OO
+
+    Ref : https://docs.python.org/3/library/ctypes.html et https://gcc.gnu.org/onlinedocs/gfortran/Interoperability-with-C.html
+    Ref : https://stackoverflow.com/questions/59330863/cant-import-dll-module-in-python
+    """
+
+    def __init__(self, fn_simul:str | Path, debugmode:bool = False, path_to_dll:Path = None):
+
+        if debugmode:
+            if path_to_dll is None:
+                self.dll_file = Path(__file__).parent / "libs" / "Wolf_tools_debug.dll"
+            else:
+                self.dll_file = path_to_dll / "Wolf_tools_debug.dll"
+        else:
+            if path_to_dll is None:
+                self.dll_file = Path(__file__).parent / "libs" / "Wolf_tools.dll"
+            else:
+                self.dll_file = path_to_dll / "Wolf_tools.dll"
+
+            self.dll_file = self.dll_file.absolute()
+
+        if not Path(self.dll_file).exists():
+            logging.error(f"File {self.dll_file} does not exist.")
+            return
+
+        # Load the DLL
+        try:
+            self.lib = ct.CDLL(str(self.dll_file))
+        except OSError as e:
+            logging.error(f"Could not load the DLL: {e}")
+            return
+
+        fn_simul = Path(fn_simul).absolute()
+
+        self.fn_simul = str(fn_simul)
+
+        if not Path(self.fn_simul).exists():
+            logging.error(f"File {self.fn_simul} does not exist.")
+            return
+
+        # Convert to ANSI encoding - this is important for Fortran on Windows and Latin-1 encoding
+        self.fn_simul = self.fn_simul.encode('ansi')
+
+        # res2D_init
+        self.lib.r2D_init.restype = None
+        self.lib.r2D_init.argtypes = [ct.c_char_p, ct.c_int]
+
+        self.lib.r2D_nbblocks.restype = ct.c_int
+        self.lib.r2D_nbblocks.argtypes = []
+
+        self.lib.r2D_header_block.restype = ct.c_int
+        self.lib.r2D_header_block.argtypes = [
+            ct.POINTER(ct.c_int),  # nbx
+            ct.POINTER(ct.c_int),  # nby
+            ct.POINTER(ct.c_double),  # ox
+            ct.POINTER(ct.c_double),  # oy
+            ct.POINTER(ct.c_double),  # tx
+            ct.POINTER(ct.c_double),  # ty
+            ct.POINTER(ct.c_double),  # dx
+            ct.POINTER(ct.c_double),  # dy
+            ct.c_int  # which_block
+        ]
+
+        self.lib.r2D_getsizes.restype = None
+        self.lib.r2D_getsizes.argtypes = [
+            ct.POINTER(ct.c_int),  # nbx
+            ct.POINTER(ct.c_int),  # nby
+            ct.c_int  # which_block
+        ]
+
+        self.lib.r2D_getnbresults.restype = ct.c_int
+        self.lib.r2D_getnbresults.argtypes = []
+
+        self.lib.r2D_getresults.restype = None
+        self.lib.r2D_getresults.argtypes = [
+            ct.c_int,  # which
+            ct.c_int,  # nbx
+            ct.c_int,  # nby
+            ct.POINTER(ct.c_float),  # waterdepth
+            ct.POINTER(ct.c_float),  # qx
+            ct.POINTER(ct.c_float),  # qy
+            ct.c_int  # which_block
+        ]
+
+        self.lib.r2D_getturbresults.restype = None
+        self.lib.r2D_getturbresults.argtypes = [
+            ct.c_int,  # which
+            ct.c_int,  # nbx
+            ct.c_int,  # nby
+            ct.POINTER(ct.c_float),  # k
+            ct.POINTER(ct.c_float),  # e
+            ct.c_int  # which_block
+        ]
+
+        self.lib.r2D_get_times_steps.restype = None
+        self.lib.r2D_get_times_steps.argtypes = [
+            ct.POINTER(ct.c_float),  # times
+            ct.POINTER(ct.c_int),  # steps
+            ct.c_int  # nb
+        ]
+
+        self.lib.r2D_get_conv_border.restype = None
+        self.lib.r2D_get_conv_border.argtypes = [
+            ct.c_char_p,  # ptr_fnsim
+            ct.c_char_p,  # ptr_fnvec
+            ct.c_int,  # simul_type
+            ct.c_char_p,  # ptr_fnres
+            ct.c_char_p,  # ptr_fncut
+            ct.c_int,  # len_fnsim
+            ct.c_int,  # len_fnvec
+            ct.c_int,  # len_fnres
+            ct.c_int  # len_fncut
+        ]
+
+
+    def _list_exported_functions(self):
+        """
+        Fortran routines/functions available in
+        """
+
+        pe = pefile.PE(self.dll_file)
+
+        if not hasattr(pe, 'DIRECTORY_ENTRY_EXPORT'):
+            print("No exported functions found.")
+            return
+
+        for exp in pe.DIRECTORY_ENTRY_EXPORT.symbols:
+            print(f"Function: {exp.name.decode('utf-8') if exp.name else 'None'}, Address: {hex(exp.address)}")
+
+    def _r2D_init(self):
+        """
+        Alias for the Fortran function r2D_init.
+
+        subroutine r2D_init(ptr_path, len_path) bind(C, name="r2d_init")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2d_init
+            type(c_ptr), value, intent(in)          :: ptr_path
+            integer(c_int), value, intent(in)       :: len_path
+
+        end subroutine
+        """
+        self.lib.r2D_init(self.fn_simul, ct.c_int(len(self.fn_simul)))
+
+    def r2D_get_number_of_blocks(self):
+        """
+        Alias for the Fortran function r2D_nbblocks.
+
+        function r2D_nbblocks() result(nb_blocks) bind(C, name="r2D_nbblocks")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_nbblocks
+            integer(c_int) :: nb_blocks
+
+        end function
+        """
+        self._r2D_init()
+        nb_blocks = self.lib.r2D_nbblocks()
+        return nb_blocks
+
+    def r2D_get_header_one_block(self, which_block:int):
+        """
+        Alias for the Fortran function r2D_header_block.
+
+        function r2D_header_block(nbx, nby, dx,dy,ox,oy,tx,ty,which_block) result(ret) bind(C, name="r2D_header_block")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_header_block
+            !DEC$ attributes REFERENCE :: nbx, nby
+            !DEC$ attributes REFERENCE :: dx, dy, ox, oy, tx, ty
+            !DEC$ attributes VALUE :: which_block
+            integer(c_int) :: nbx,nby, ret
+            double precision :: ox,oy,tx,ty,dx,dy
+            integer(c_int), intent(in) :: which_block
+
+        end function
+        """
+
+        self._r2D_init()
+        nbx = ct.c_int()
+        nby = ct.c_int()
+        ox = ct.c_double()
+        oy = ct.c_double()
+        tx = ct.c_double()
+        ty = ct.c_double()
+        dx = ct.c_double()
+        dy = ct.c_double()
+        self.lib.r2D_header_block(ct.byref(nbx), ct.byref(nby), ct.byref(dx), ct.byref(dy),
+                                    ct.byref(ox), ct.byref(oy), ct.byref(tx), ct.byref(ty), ct.c_int(which_block))
+
+        return (nbx.value, nby.value, dx.value, dy.value, ox.value, oy.value, tx.value, ty.value)
+
+    def _r2D_get_header_block_python(self, which_block:int) -> header_wolf:
+        """ Return a header_wolf object with the header of the block number which_block."""
+        nbx, nby, dx, dy, ox, oy, tx, ty = self.r2D_get_header_one_block(which_block)
+        newhead = header_wolf()
+        newhead.nbx = nbx
+        newhead.nby = nby
+        newhead.dx = dx
+        newhead.dy = dy
+        newhead.origin = ox, oy
+        newhead.translation = tx, ty
+
+        return newhead
+
+    def r2D_get_header_allblocks(self):
+
+        nbblocks = self.r2D_get_number_of_blocks()
+        blocks = {}
+
+        for i in range(1, nbblocks+1):
+            key = getkeyblock(i, addone=False)
+            blocks[key] = self._r2D_get_header_block_python(i)
+
+        return blocks
+
+    def r2D_get_shape(self, which_block:int):
+        """
+        Alias for the Fortran function r2D_getsizes.
+
+        subroutine r2D_getsizes(nbx,nby,which_block) bind(C, name="r2D_getsizes")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_getsizes
+            integer(c_int), intent(out) :: nbx,nby
+            integer(c_int), intent(in) :: which_block
+
+        end subroutine
+        """
+
+        self._r2D_init()
+        nbx = ct.c_int()
+        nby = ct.c_int()
+        self.lib.r2D_getsizes(ct.byref(nbx), ct.byref(nby), ct.c_int(which_block))
+
+        return nbx.value, nby.value
+
+
+    def r2D_get_number_of_results(self):
+        """
+        Alias for the Fortran function r2D_getnbresults.
+
+        function r2D_getnbresults() result(nb) bind(C, name="r2D_getnbresults")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_getnbresults
+            integer(c_int) :: nb
+
+        end function
+        """
+
+        self._r2D_init()
+        nb = self.lib.r2D_getnbresults()
+        return nb
+
+    def r2D_get_one_result(self, which:int, which_block:int):
+        """
+        Alias for the Fortran function r2D_getresults.
+
+        subroutine r2D_getresults(which,nbx,nby,waterdepth,qx,qy,which_block) bind(C, name="r2D_getresults")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_getresults
+            integer(c_int), intent(in) :: nbx,nby,which
+            integer(c_int), intent(in) :: which_block
+            real, dimension(nbx,nby), intent(out) :: waterdepth,qx,qy
+
+        end subroutine
+        """
+
+        self._r2D_init()
+
+        nbx, nby = self.r2D_get_shape(which_block)
+        waterdepth = np.zeros((nbx, nby), dtype=np.float32, order='F')
+        qx = np.zeros((nbx, nby), dtype=np.float32, order='F')
+        qy = np.zeros((nbx, nby), dtype=np.float32, order='F')
+
+        self.lib.r2D_getresults(ct.c_int(which), ct.c_int(nbx), ct.c_int(nby),
+                                waterdepth.ctypes.data_as(ct.POINTER(ct.c_float)),
+                                qx.ctypes.data_as(ct.POINTER(ct.c_float)),
+                                qy.ctypes.data_as(ct.POINTER(ct.c_float)),
+                                ct.c_int(which_block))
+
+        return waterdepth, qx, qy
+
+    def r2D_get_one_turbulent_result(self, which:int, which_block:int):
+        """
+        Alias for the Fortran function r2D_getturbresults.
+
+        subroutine r2D_getturbresults(which,nbx,nby,k,e,which_block) bind(C, name="r2D_getturbresults")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_getturbresults
+            integer(c_int), intent(in) :: nbx,nby,which
+            integer(c_int), intent(in) :: which_block
+            real, dimension(nbx,nby), intent(out) :: k,e
+
+        end subroutine
+        """
+
+        self._r2D_init()
+
+        nbx, nby = self.r2D_get_shape(which_block)
+        k = np.zeros((nbx, nby), dtype=np.float32, order='F')
+        e = np.zeros((nbx, nby), dtype=np.float32, order='F')
+        self.lib.r2D_getturbresults(ct.c_int(which), ct.c_int(nbx), ct.c_int(nby),
+                                    k.ctypes.data_as(ct.POINTER(ct.c_float)),
+                                    e.ctypes.data_as(ct.POINTER(ct.c_float)),
+                                    ct.c_int(which_block))
+
+        return k, e
+
+    def r2D_get_times_steps(self):
+        """
+        Alias for the Fortran function get_times_steps.
+
+        subroutine get_times_steps(times, steps, nb) bind(C, name="get_times_steps")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_gettimes_steps
+            integer(c_int), intent(in) :: nb
+            real, dimension(nb), intent(out) :: times
+            integer, dimension(nb), intent(out) :: steps
+
+        end subroutine
+        """
+
+        self._r2D_init()
+        nb = self.r2D_get_number_of_results()
+        times = np.zeros((nb), dtype=np.float32, order='F')
+        steps = np.zeros((nb), dtype=np.int32, order='F')
+        self.lib.r2D_get_times_steps(times.ctypes.data_as(ct.POINTER(ct.c_float)),
+                                        steps.ctypes.data_as(ct.POINTER(ct.c_int)),
+                                        ct.c_int(nb))
+        return times, steps
+
+    def r2D_create_convergence_border(self, vec:str='', simtype:int=0, res:str='', cutcell:str=''):
+        """
+        Alias for the Fortran function get_conv_border.
+
+        subroutine get_conv_border(ptr_fnsim, ptr_fnvec, simul_type, ptr_fnres, ptr_fncut, len_fnsim, len_fnvec, len_fnres, len_fncut) bind(C, name="get_conv_border")
+            !DEC$ ATTRIBUTES DLLEXPORT :: r2D_get_conv_border
+            type(c_ptr), value, intent(in)          :: ptr_fnsim, ptr_fnvec, ptr_fnres, ptr_fncut
+            integer(c_int), value, intent(in)       :: len_fnsim, len_fnvec, len_fnres, len_fncut
+
+        end subroutine
+        """
+
+        fn_vec = str(vec).encode('ansi')
+        fn_res = str(res).encode('ansi')
+        fn_cutcell = str(cutcell).encode('ansi')
+
+        self._r2D_init()
+        self.lib.r2D_get_conv_border(self.fn_simul, fn_vec, simtype, fn_res, fn_cutcell,
+                                      ct.c_int(len(self.fn_simul)),
+                                      ct.c_int(len(fn_vec)),
+                                      ct.c_int(len(fn_res)),
+                                      ct.c_int(len(fn_cutcell)))
+
+        return 0

wolfhece/wolf_array.py

@@ -6058,7 +6058,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         Statistics on Selected data or the whole array if no selection
 
         :param inside_polygon: vector or Polygon to select data inside the polygon
-        :return: mean, std, median, sum, values
+        :return: mean, std, median, sum, volume (sum*dx*dy), values
         """
 
         if inside_polygon is not None:
@@ -6074,8 +6074,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         std = np.std(vals)
         median = np.median(vals)
         sum = np.sum(vals)
+        vol = sum * self.dx * self.dy
 
-        return {_('Mean'): mean, _('Std'): std, _('Median'): median, _('Sum'): sum, _('Values'): vals}
+        return {_('Mean'): mean, _('Std'): std, _('Median'): median, _('Sum'): sum, _('Volume'): vol, _('Values'): vals}
 
     def export_geotif(self, outdir:str= '', extent:str= '', EPSG:int = 31370):
         """

wolfhece/wolfresults_2D.py

@@ -45,31 +45,32 @@ from .mesh2d.wolf2dprev import prev_parameters_simul, blocks_file
 from .GraphNotebook import PlotPanel
 from .CpGrid import CpGrid
 from .matplotlib_fig import  Matplotlib_Figure
+from .tools2d_dll import Tools2DFortran
 
 
-try:
-    from .libs import wolfpy
-except Exception as ex:
-    # This convoluted error handling is here to catch an issue
-    # which was difficult to track down: wolfpy was there
-    # but its DLL were not available.
+# try:
+#     from .libs import wolfpy
+# except Exception as ex:
+#     # This convoluted error handling is here to catch an issue
+#     # which was difficult to track down: wolfpy was there
+#     # but its DLL were not available.
 
-    from importlib.util import find_spec
-    s = find_spec('wolfhece.libs.wolfpy')
+#     from importlib.util import find_spec
+#     s = find_spec('wolfhece.libs.wolfpy')
 
-    # Not too sure about this find_spec. If the root
-    # directory is not the good one, the import search may
-    # end up in the site packages, loading the wrong wolfpy.
+#     # Not too sure about this find_spec. If the root
+#     # directory is not the good one, the import search may
+#     # end up in the site packages, loading the wrong wolfpy.
 
-    base = Path(__file__).parent.parts
-    package = Path(s.origin).parent.parts
-    is_submodule = (len(base) <= len(package)) and all(i==j for i, j in zip(base, package))
+#     base = Path(__file__).parent.parts
+#     package = Path(s.origin).parent.parts
+#     is_submodule = (len(base) <= len(package)) and all(i==j for i, j in zip(base, package))
 
-    if is_submodule:
-        msg = _("wolfpy was found but we were not able to load it. It may be an issue with its DLL dependencies")
-        msg += _("The actual error was: {}").format(str(ex))
+#     if is_submodule:
+#         msg = _("wolfpy was found but we were not able to load it. It may be an issue with its DLL dependencies")
+#         msg += _("The actual error was: {}").format(str(ex))
 
-    raise Exception(msg)
+#     raise Exception(msg)
 
 from .wolf_array import WolfArray, getkeyblock, header_wolf, WolfArrayMB, WolfArrayMNAP, header_wolf, SelectionData, SelectionDataMB, VERSION_RGB
 from .mesh2d import wolf2dprev
@@ -130,6 +131,12 @@ def u_splitting(q_left, q_right, h_left, h_right):
         else:
             return (q_left/h_left + q_right/h_right) / 2.
 
+def _process_danger_map_chunk(chunk):
+    import pickle
+    obj, start, end, every = chunk
+    # Create a new instance of the class for each chunk
+    new:Wolfresults_2D = pickle.loads(pickle.dumps(obj))
+    return new.danger_map(start, end, every)
 
 class Props_Res_2D(wx.Frame):
     """
@@ -2213,6 +2220,7 @@ class Wolfresults_2D(Element_To_Draw):
                     self.filename = fname
 
                 self.filenamegen=self.filename
+                self._dll_tools = Tools2DFortran(self.filenamegen) # DLL de calculs de la classe Tools2DFortran
 
                 if exists(self.filename + '.trl'):
                     with open(self.filename + '.trl') as f:
@@ -2224,14 +2232,16 @@ class Wolfresults_2D(Element_To_Draw):
                 self.read_param_simul()
 
                 if exists(self.filename+'.head') or exists(join(dirname(self.filename),'bloc1.head')):
-                    wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
-                    nb_blocks = wolfpy.r2d_nbblocks()
+                    # wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+                    # nb_blocks = wolfpy.r2d_nbblocks()
 
+                    nb_blocks = self._dll_tools.r2D_get_number_of_blocks()
                     for i in range(nb_blocks):
                         curblock = OneWolfResult(i, parent=self)
                         self.myblocks[getkeyblock(i)] = curblock
 
-                        nbx,nby,dx,dy,ox,oy,tx,ty = wolfpy.r2d_hblock(i+1)
+                        # nbx,nby,dx,dy,ox,oy,tx,ty = wolfpy.r2d_hblock(i+1)
+                        nbx, nby,dx,dy,ox,oy,tx,ty = self._dll_tools.r2D_get_header_one_block(i+1)
 
                         curhead = self.head_blocks[getkeyblock(i)]=header_wolf()
                         curhead.nbx = nbx
@@ -2745,8 +2755,10 @@ class Wolfresults_2D(Element_To_Draw):
         if nb == 0:
             self.times, self.timesteps = [],[]
         else:
-            wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
-            self.times, self.timesteps = wolfpy.get_times_steps(nb)
+            # wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+            # self.times, self.timesteps = wolfpy.get_times_steps(nb)
+
+            self.times, self.timesteps = self._dll_tools.r2D_get_times_steps()
 
         return self.times, self.timesteps
 
@@ -2996,8 +3008,10 @@ class Wolfresults_2D(Element_To_Draw):
         """Récupération du nombre de pas sauvegardés --> utilisation de la librairie Fortran"""
 
         if exists(self.filename+'.head'):
-            wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
-            nb = wolfpy.r2d_getnbresults()
+            # wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+            # nb = wolfpy.r2d_getnbresults()
+
+            nb = self._dll_tools.r2D_get_number_of_results()
             self._nb_results = nb
 
             if force_update_timessteps:
@@ -3021,8 +3035,12 @@ class Wolfresults_2D(Element_To_Draw):
             nby = block.waterdepth.nby
 
             # Fortran is 1-based --> which_step+1
-            block.waterdepth.array, block.qx.array, block.qy.array = wolfpy.r2d_getresults(which_step+1, nbx, nby, whichblock)
-            block.k.array, block.eps.array = wolfpy.r2d_getturbresults(which_step+1, nbx, nby, whichblock)
+            # block.waterdepth.array, block.qx.array, block.qy.array = wolfpy.r2d_getresults(which_step+1, nbx, nby, whichblock)
+            # block.k.array, block.eps.array = wolfpy.r2d_getturbresults(which_step+1, nbx, nby, whichblock)
+
+            block.waterdepth.array, block.qx.array, block.qy.array = self._dll_tools.r2D_get_one_result(which_step+1, whichblock)
+            block.k.array, block.eps.array = self._dll_tools.r2D_get_one_turbulent_result(which_step+1, whichblock)
+
             block._force_update_shields = True
 
     def _read_oneblockresult_withoutmask_only_h(self, which_step:int=-1,whichblock:int=-1):
@@ -3040,7 +3058,9 @@ class Wolfresults_2D(Element_To_Draw):
             nby = block.waterdepth.nby
 
             # Fortran is 1-based --> which_step+1
-            block.waterdepth.array, block.qx.array, block.qy.array = wolfpy.r2d_getresults(which_step+1, nbx, nby, whichblock)
+            # block.waterdepth.array, block.qx.array, block.qy.array = wolfpy.r2d_getresults(which_step+1, nbx, nby, whichblock)
+
+            block.waterdepth.array, block.qx.array, block.qy.array = self._dll_tools.r2D_get_one_result(which_step+1, whichblock)
             block._force_update_shields = True
 
     def read_oneblockresult(self, which_step:int=-1, whichblock:int=-1):
@@ -3114,7 +3134,7 @@ class Wolfresults_2D(Element_To_Draw):
 
         if exists(self.filename+'.head'):
             logging.info(_('Reading from results - step :{}'.format(which+1)))
-            wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+            # wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
             for i in range(self.nb_blocks):
                 self.read_oneblockresult(which, i+1)
         else:
@@ -3137,7 +3157,7 @@ class Wolfresults_2D(Element_To_Draw):
 
         if exists(self.filename+'.head'):
             logging.info(_('Reading from results - step :{}'.format(which+1)))
-            wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+            # wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
             for i in range(self.nb_blocks):
                 self._read_oneblockresult_only_h(which, i+1)
         else:
@@ -3175,7 +3195,7 @@ class Wolfresults_2D(Element_To_Draw):
         if exists(self.filename+'.head'):
 
             logging.info(_('Reading result step :{}'.format(self.current_result)))
-            wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
+            # wolfpy.r2d_init(self.filename.ljust(255).encode('ansi'))
 
             for i in range(self.nb_blocks):
                 self.read_oneblockresult(self.current_result, i+1)
@@ -4989,7 +5009,11 @@ class Wolfresults_2D(Element_To_Draw):
             curdanger.reset()
             curdanger.mask_reset()
 
-        for time_step in tqdm(range(start, end, every)):
+        to_compute = np.arange(start, end, every)
+        #add the end
+        if end not in to_compute:
+            to_compute = np.append(to_compute, end)
+        for time_step in tqdm(to_compute):
 
             if callback is not None:
                 callback(time_step, "Step {} / {}".format(time_step+1, end))
@@ -5066,6 +5090,111 @@ class Wolfresults_2D(Element_To_Draw):
 
         return (danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom, danger_map_matrix_z, danger_map_matrix_head)
 
+    def __getstate__(self):
+        """Get the state of the object for pickling"""
+        state = self.__dict__.copy()
+        # Remove unpicklable attributes
+
+        topop = ['mapviewer', 'properties', 'mngselection', 'myops']
+
+        for cur_pop in topop:
+            if cur_pop in state:
+                state.pop(cur_pop)
+        return state
+
+    def __setstate__(self, state):
+        """Set the state of the object after unpickling"""
+        # Restore the state of the object
+        self.__dict__.update(state)
+        # Reinitialize any attributes that were removed during pickling
+        self.mapviewer = None
+        self.properties = None
+        self.mngselection = None
+        self.myops = None
+
+    def danger_map_multiprocess(self, start:int=0, end:int=-1, every:int=1, callback=None, nb_processors:int = -1) -> Union[tuple[WolfArray, WolfArray, WolfArray, WolfArray], tuple[WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB]]:
+        """
+        Create Danger Maps using multiprocessing
+
+        :param start: start time step - 0-based
+        :param end: end time step - 0-based
+        :param every: step interval
+        :param callback: optional callback to update progress
+        """
+
+        from multiprocessing import Pool, cpu_count
+
+        if nb_processors == -1:
+            nb_processors = cpu_count()
+
+        if nb_processors > self.get_nbresults():
+            nb_processors = self.get_nbresults()
+
+        # Split the range of time steps into chunks for multiprocessing
+        if end == -1:
+            end = self.get_nbresults()
+
+        starts = [start + i * every for i in range(nb_processors)]
+        ends = [end - i * every for i in range(nb_processors-1,-1,-1)]
+
+        # pop all start above end
+        for i in range(nb_processors-1,0,-1):
+            if starts[i] >= end:
+                starts.pop(i)
+                ends.pop(i)
+
+        # set end above start
+        for i in range(len(starts)):
+            if starts[i] >= ends[i]:
+                ends[i] = starts[i] + every
+
+        chunks = [(self, start + i * every, end - (nb_processors - i) * every + 1, nb_processors) for i in range(min(nb_processors, len(starts)))]
+
+        # Create a pool of workers
+        with Pool(processes=nb_processors) as pool:
+            results = pool.map(_process_danger_map_chunk, chunks)
+
+        danger_map_matrix_h   = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_v   = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_mom = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_z   = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_head= self.as_WolfArray(copyarray=True)
+
+        danger = [danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom, danger_map_matrix_z, danger_map_matrix_head]
+
+        for curdanger in danger:
+            curdanger.nullvalue = 0.
+            curdanger.reset()
+            curdanger.mask_reset()
+
+        if self.nb_blocks>1:
+            for result in results:
+                for idx, curdanger in enumerate(danger):
+                    for i in range(self.nb_blocks):
+                        curdanger[i].array.data = np.maximum(curdanger[i].array.data, result[idx][i].array.data)
+                        curdanger[i].array.mask = np.logical_or(curdanger[i].array.mask, result[idx][i].array.mask)
+        else:
+            for result in results:
+                for idx, curdanger in enumerate(danger):
+                    curdanger.array.data[:,:] = np.maximum(curdanger.array.data, result[idx].array.data)
+                    curdanger.array.mask[:,:] = np.logical_or(curdanger.array.mask, result[idx].array.mask)
+
+        danger_map_matrix_h.mask_lower(self.epsilon)
+
+        if self.nb_blocks>1:
+            for i in range(self.nb_blocks):
+                danger_map_matrix_v[i].array.mask[:,:]   = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_mom[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_z[i].array.mask[:,:]   = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_head[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+        else:
+            danger_map_matrix_v.array.mask[:,:]   = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_mom.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_z.array.mask[:,:]   = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_head.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+
+        return (danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_mom, danger_map_matrix_z, danger_map_matrix_head)
+
     def danger_map_only_h(self, start:int=0, end:int=-1, every:int=1) -> WolfArray:
         """
         Create Danger Maps
@@ -5431,7 +5560,7 @@ class Wolfresults_2D(Element_To_Draw):
             curavg.mask_reset()
 
         for time_step in tqdm(range(start, end, every)):
-            
+
             if callback is not None:
                 callback(time_step, "Step {} / {}".format(time_step+1, end))