wolfhece 2.2.16__py3-none-any.whl → 2.2.17__py3-none-any.whl

wolfhece/wolfresults_2D.py

@@ -201,10 +201,10 @@ def u_splitting(q_left:float, q_right:float, h_left:float, h_right:float) -> flo
 
 def _process_danger_map_chunk(chunk):
     import pickle
-    obj, start, end, every = chunk
+    obj, start, end, every, hmin = 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)
+    return new.danger_map(start, end, every, None, hmin)
 
 class Props_Res_2D(wx.Frame):
     """
@@ -2314,153 +2314,187 @@ class Wolfresults_2D(Element_To_Draw):
                     return
 
             else:
-                # We are here for "classic" CPU results
-                parts=splitext(fname)
-                if len(parts)>1:
-                    self.filename = parts[0]
-                else:
-                    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:
-                        trl=f.read().splitlines()
-                        self.translx=float(trl[1])
-                        self.transly=float(trl[2])
-
-                self.myblocks={}
-                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()
-
-                    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 = self._dll_tools.r2D_get_header_one_block(i+1)
-
-                        curhead = self.head_blocks[getkeyblock(i)]=header_wolf()
-                        curhead.nbx = nbx
-                        curhead.nby = nby
-                        curhead.origx = ox
-                        curhead.origy = oy
-                        curhead.dx = dx
-                        curhead.dy = dy
-                        curhead.translx = self.translx
-                        curhead.transly = self.transly
-
-                        curblock.waterdepth.dx = dx
-                        curblock.waterdepth.dy = dy
-                        curblock.waterdepth.nbx = nbx
-                        curblock.waterdepth.nby = nby
-                        curblock.waterdepth.origx = ox
-                        curblock.waterdepth.origy = oy
-                        curblock.waterdepth.translx = self.translx
-                        curblock.waterdepth.transly = self.transly
-
-                        curblock.top.dx = dx
-                        curblock.top.dy = dy
-                        curblock.top.nbx = nbx
-                        curblock.top.nby = nby
-                        curblock.top.origx = ox
-                        curblock.top.origy = oy
-                        curblock.top.translx = self.translx
-                        curblock.top.transly = self.transly
-
-                        curblock.qx.dx = dx
-                        curblock.qx.dy = dy
-                        curblock.qx.nbx = nbx
-                        curblock.qx.nby = nby
-                        curblock.qx.origx = ox
-                        curblock.qx.origy = oy
-                        curblock.qx.translx = self.translx
-                        curblock.qx.transly = self.transly
-
-                        curblock.qy.dx = dx
-                        curblock.qy.dy = dy
-                        curblock.qy.nbx = nbx
-                        curblock.qy.nby = nby
-                        curblock.qy.origx = ox
-                        curblock.qy.origy = oy
-                        curblock.qy.translx = self.translx
-                        curblock.qy.transly = self.transly
-
-                        curblock.rough_n.dx = dx
-                        curblock.rough_n.dy = dy
-                        curblock.rough_n.nbx = nbx
-                        curblock.rough_n.nby = nby
-                        curblock.rough_n.origx = ox
-                        curblock.rough_n.origy = oy
-                        curblock.rough_n.translx = self.translx
-                        curblock.rough_n.transly = self.transly
-
-                        curblock.eps.dx = dx
-                        curblock.eps.dy = dy
-                        curblock.eps.nbx = nbx
-                        curblock.eps.nby = nby
-                        curblock.eps.origx = ox
-                        curblock.eps.origy = oy
-                        curblock.eps.translx = self.translx
-                        curblock.eps.transly = self.transly
-
-                        curblock.k.dx = dx
-                        curblock.k.dy = dy
-                        curblock.k.nbx = nbx
-                        curblock.k.nby = nby
-                        curblock.k.origx = ox
-                        curblock.k.origy = oy
-                        curblock.k.translx = self.translx
-                        curblock.k.transly = self.transly
-
-                        curblock._is_manning_strickler = self.myparam.blocks[i].is_Manning_surface_friction
-                        curblock._is_colebrook = self.myparam.blocks[i].is_Colebrook_surface_friction
-                        curblock._has_turbulence_model = self.myparam.blocks[i].has_turbulence
-
-                        _param_turb = self.myparam.blocks[i].get_params_turbulence()
-                        if 'cmu' in _param_turb:
-                            curblock._cmu = _param_turb['cmu']
-                        if 'cnu' in _param_turb:
-                            curblock._cnu = _param_turb['cnu']
-
-                else:
-                    nb_blocks = self.myblocfile.nb_blocks
-
-                    for i in range(nb_blocks):
-                        #print(f"Reading block {getkeyblock(i)}")
-                        curblock = OneWolfResult(i, parent = self)
-                        self.myblocks[getkeyblock(i)] = curblock
-                        curblock.waterdepth.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-                        curblock.top.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-                        curblock.qx.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-                        curblock.qy.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-                        curblock.rough_n.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-                        curblock.eps.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-                        curblock.k.set_header(self.mymnap.head_blocks[getkeyblock(i)])
-
-                        curblock._is_manning_strickler = self.myparam.blocks[i].is_Manning_surface_friction
-                        curblock._is_colebrook = self.myparam.blocks[i].is_Colebrook_surface_friction
-                        curblock._has_turbulence_model = self.myparam.blocks[i].has_turbulence
-
-                        _param_turb = self.myparam.blocks[i].get_params_turbulence()
-                        if 'cmu' in _param_turb:
-                            curblock._cmu = _param_turb['cmu']
-                        if 'cnu' in _param_turb:
-                            curblock._cnu = _param_turb['cnu']
-
-                self.allocate_ressources()
-                self.read_topography()
-                self.read_ini_mb()
-
-                self.loaded_rough = False
+                self._loader_CPU2D(fname)
+                # # We are here for "classic" CPU results
+                # parts=splitext(fname)
+                # if len(parts)>1:
+                #     self.filename = parts[0]
+                # else:
+                #     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:
+                #         trl=f.read().splitlines()
+                #         self.translx=float(trl[1])
+                #         self.transly=float(trl[2])
+
+                # self.myblocks={}
+                # 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()
+
+                #     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 = self._dll_tools.r2D_get_header_one_block(i+1)
+
+                #         curhead = self.head_blocks[getkeyblock(i)]=header_wolf()
+                #         curhead.nbx = nbx
+                #         curhead.nby = nby
+                #         curhead.origx = ox
+                #         curhead.origy = oy
+                #         curhead.dx = dx
+                #         curhead.dy = dy
+                #         curhead.translx = self.translx
+                #         curhead.transly = self.transly
+
+                #         curblock.waterdepth.dx = dx
+                #         curblock.waterdepth.dy = dy
+                #         curblock.waterdepth.nbx = nbx
+                #         curblock.waterdepth.nby = nby
+                #         curblock.waterdepth.origx = ox
+                #         curblock.waterdepth.origy = oy
+                #         curblock.waterdepth.translx = self.translx
+                #         curblock.waterdepth.transly = self.transly
+
+                #         curblock.top.dx = dx
+                #         curblock.top.dy = dy
+                #         curblock.top.nbx = nbx
+                #         curblock.top.nby = nby
+                #         curblock.top.origx = ox
+                #         curblock.top.origy = oy
+                #         curblock.top.translx = self.translx
+                #         curblock.top.transly = self.transly
+
+                #         curblock.qx.dx = dx
+                #         curblock.qx.dy = dy
+                #         curblock.qx.nbx = nbx
+                #         curblock.qx.nby = nby
+                #         curblock.qx.origx = ox
+                #         curblock.qx.origy = oy
+                #         curblock.qx.translx = self.translx
+                #         curblock.qx.transly = self.transly
+
+                #         curblock.qy.dx = dx
+                #         curblock.qy.dy = dy
+                #         curblock.qy.nbx = nbx
+                #         curblock.qy.nby = nby
+                #         curblock.qy.origx = ox
+                #         curblock.qy.origy = oy
+                #         curblock.qy.translx = self.translx
+                #         curblock.qy.transly = self.transly
+
+                #         curblock.rough_n.dx = dx
+                #         curblock.rough_n.dy = dy
+                #         curblock.rough_n.nbx = nbx
+                #         curblock.rough_n.nby = nby
+                #         curblock.rough_n.origx = ox
+                #         curblock.rough_n.origy = oy
+                #         curblock.rough_n.translx = self.translx
+                #         curblock.rough_n.transly = self.transly
+
+                #         curblock.eps.dx = dx
+                #         curblock.eps.dy = dy
+                #         curblock.eps.nbx = nbx
+                #         curblock.eps.nby = nby
+                #         curblock.eps.origx = ox
+                #         curblock.eps.origy = oy
+                #         curblock.eps.translx = self.translx
+                #         curblock.eps.transly = self.transly
+
+                #         curblock.k.dx = dx
+                #         curblock.k.dy = dy
+                #         curblock.k.nbx = nbx
+                #         curblock.k.nby = nby
+                #         curblock.k.origx = ox
+                #         curblock.k.origy = oy
+                #         curblock.k.translx = self.translx
+                #         curblock.k.transly = self.transly
+
+                #         curblock._is_manning_strickler = self.myparam.blocks[i].is_Manning_surface_friction
+                #         curblock._is_colebrook = self.myparam.blocks[i].is_Colebrook_surface_friction
+                #         curblock._has_turbulence_model = self.myparam.blocks[i].has_turbulence
+
+                #         _param_turb = self.myparam.blocks[i].get_params_turbulence()
+                #         if 'cmu' in _param_turb:
+                #             curblock._cmu = _param_turb['cmu']
+                #         if 'cnu' in _param_turb:
+                #             curblock._cnu = _param_turb['cnu']
+
+                # else:
+                #     nb_blocks = self.myblocfile.nb_blocks
+
+                #     for i in range(nb_blocks):
+                #         #print(f"Reading block {getkeyblock(i)}")
+                #         curblock = OneWolfResult(i, parent = self)
+                #         self.myblocks[getkeyblock(i)] = curblock
+                #         curblock.waterdepth.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                #         curblock.top.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                #         curblock.qx.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                #         curblock.qy.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                #         curblock.rough_n.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                #         curblock.eps.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                #         curblock.k.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+
+                #         curblock._is_manning_strickler = self.myparam.blocks[i].is_Manning_surface_friction
+                #         curblock._is_colebrook = self.myparam.blocks[i].is_Colebrook_surface_friction
+                #         curblock._has_turbulence_model = self.myparam.blocks[i].has_turbulence
+
+                #         _param_turb = self.myparam.blocks[i].get_params_turbulence()
+                #         if 'cmu' in _param_turb:
+                #             curblock._cmu = _param_turb['cmu']
+                #         if 'cnu' in _param_turb:
+                #             curblock._cnu = _param_turb['cnu']
+
+                # self.allocate_ressources()
+                # self.read_topography()
+                # self.read_ini_mb()
+
+                # self.loaded_rough = False
         else:
             self.myblocks={}
 
+        self._post_loader()
+        # self.nbx = 1
+        # self.nby = 1
+
+        # ox=9999999.
+        # oy=9999999.
+        # ex=-9999999.
+        # ey=-9999999.
+        # for curblock in self.myblocks.values():
+        #     curhead=curblock.waterdepth.get_header(False)
+        #     ox=min(ox,curhead.origx)
+        #     oy=min(oy,curhead.origy)
+        #     ex=max(ex,curhead.origx+float(curhead.nbx)*curhead.dx)
+        #     ey=max(ey,curhead.origy+float(curhead.nby)*curhead.dy)
+        # self.dx = ex-ox
+        # self.dy = ey-oy
+        # self.origx = ox
+        # self.origy = oy
+
+        # self._nb_results = None
+        # self.timesteps = []
+        # self.times = []
+
+        # self.properties:Props_Res_2D = None
+        # self.set_properties()
+
+        # self.mngselection = SelectionDataMB(self)
+        # self.myops = None
+        # self._active_blocks = 0
+
+    def _post_loader(self):
+        """ Post loader for CPU/GPU results """
+
         self.nbx = 1
         self.nby = 1
 
@@ -2490,6 +2524,188 @@ class Wolfresults_2D(Element_To_Draw):
         self.myops = None
         self._active_blocks = 0
 
+    def _loader_CPU2D(self, fname:str) -> int:
+        """ Loader for CPU results """
+
+        # We are here for "classic" CPU results
+        parts=splitext(fname)
+        if len(parts)>1:
+            self.filename = parts[0]
+        else:
+            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:
+                trl=f.read().splitlines()
+                self.translx=float(trl[1])
+                self.transly=float(trl[2])
+
+        self.myblocks={}
+        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()
+
+            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 = self._dll_tools.r2D_get_header_one_block(i+1)
+
+                curhead = self.head_blocks[getkeyblock(i)]=header_wolf()
+                curhead.nbx = nbx
+                curhead.nby = nby
+                curhead.origx = ox
+                curhead.origy = oy
+                curhead.dx = dx
+                curhead.dy = dy
+                curhead.translx = self.translx
+                curhead.transly = self.transly
+
+                curblock.waterdepth.dx = dx
+                curblock.waterdepth.dy = dy
+                curblock.waterdepth.nbx = nbx
+                curblock.waterdepth.nby = nby
+                curblock.waterdepth.origx = ox
+                curblock.waterdepth.origy = oy
+                curblock.waterdepth.translx = self.translx
+                curblock.waterdepth.transly = self.transly
+
+                curblock.top.dx = dx
+                curblock.top.dy = dy
+                curblock.top.nbx = nbx
+                curblock.top.nby = nby
+                curblock.top.origx = ox
+                curblock.top.origy = oy
+                curblock.top.translx = self.translx
+                curblock.top.transly = self.transly
+
+                curblock.qx.dx = dx
+                curblock.qx.dy = dy
+                curblock.qx.nbx = nbx
+                curblock.qx.nby = nby
+                curblock.qx.origx = ox
+                curblock.qx.origy = oy
+                curblock.qx.translx = self.translx
+                curblock.qx.transly = self.transly
+
+                curblock.qy.dx = dx
+                curblock.qy.dy = dy
+                curblock.qy.nbx = nbx
+                curblock.qy.nby = nby
+                curblock.qy.origx = ox
+                curblock.qy.origy = oy
+                curblock.qy.translx = self.translx
+                curblock.qy.transly = self.transly
+
+                curblock.rough_n.dx = dx
+                curblock.rough_n.dy = dy
+                curblock.rough_n.nbx = nbx
+                curblock.rough_n.nby = nby
+                curblock.rough_n.origx = ox
+                curblock.rough_n.origy = oy
+                curblock.rough_n.translx = self.translx
+                curblock.rough_n.transly = self.transly
+
+                curblock.eps.dx = dx
+                curblock.eps.dy = dy
+                curblock.eps.nbx = nbx
+                curblock.eps.nby = nby
+                curblock.eps.origx = ox
+                curblock.eps.origy = oy
+                curblock.eps.translx = self.translx
+                curblock.eps.transly = self.transly
+
+                curblock.k.dx = dx
+                curblock.k.dy = dy
+                curblock.k.nbx = nbx
+                curblock.k.nby = nby
+                curblock.k.origx = ox
+                curblock.k.origy = oy
+                curblock.k.translx = self.translx
+                curblock.k.transly = self.transly
+
+                curblock._is_manning_strickler = self.myparam.blocks[i].is_Manning_surface_friction
+                curblock._is_colebrook = self.myparam.blocks[i].is_Colebrook_surface_friction
+                curblock._has_turbulence_model = self.myparam.blocks[i].has_turbulence
+
+                _param_turb = self.myparam.blocks[i].get_params_turbulence()
+                if 'cmu' in _param_turb:
+                    curblock._cmu = _param_turb['cmu']
+                if 'cnu' in _param_turb:
+                    curblock._cnu = _param_turb['cnu']
+
+        else:
+            nb_blocks = self.myblocfile.nb_blocks
+
+            for i in range(nb_blocks):
+                #print(f"Reading block {getkeyblock(i)}")
+                curblock = OneWolfResult(i, parent = self)
+                self.myblocks[getkeyblock(i)] = curblock
+                curblock.waterdepth.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                curblock.top.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                curblock.qx.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                curblock.qy.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                curblock.rough_n.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                curblock.eps.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+                curblock.k.set_header(self.mymnap.head_blocks[getkeyblock(i)])
+
+                curblock._is_manning_strickler = self.myparam.blocks[i].is_Manning_surface_friction
+                curblock._is_colebrook = self.myparam.blocks[i].is_Colebrook_surface_friction
+                curblock._has_turbulence_model = self.myparam.blocks[i].has_turbulence
+
+                _param_turb = self.myparam.blocks[i].get_params_turbulence()
+                if 'cmu' in _param_turb:
+                    curblock._cmu = _param_turb['cmu']
+                if 'cnu' in _param_turb:
+                    curblock._cnu = _param_turb['cnu']
+
+        self.allocate_ressources()
+        self.read_topography()
+        self.read_ini_mb()
+
+        self.loaded_rough = False
+
+    def __getstate__(self):
+        """Get the state of the object for pickling"""
+        state = self.__dict__.copy()
+        # Remove unpicklable attributes
+
+        topop = ['mapviewer',
+                 'properties',
+                 'mngselection',
+                 'myops',
+                 '_dll_tools',
+                 'myparam',
+                 'myblocfile',
+                 'mymnap']
+
+        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
+
+        if not 'isGPU' in list(state.keys()):
+            self._loader_CPU2D(self.filenamegen)
+            self._post_loader()
+            self._dll_tools = Tools2DFortran(self.filenamegen)
+
     @property
     def all_dt(self):
         #FIXME : defined in GPU version --> to be implemented for CPU version
@@ -5122,7 +5338,10 @@ class Wolfresults_2D(Element_To_Draw):
         self.get_working_array()
         self.updatepalette(whichpal)
 
-    def danger_map(self, start:int=0, end:int=-1, every:int=1, callback=None) -> Union[tuple[WolfArray, WolfArray, WolfArray, WolfArray], tuple[WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB]]:
+    def danger_map(self, start:int=0, end:int=-1,
+                   every:int=1, callback=None,
+                   hmin:float = None) -> Union[tuple[WolfArray, WolfArray, WolfArray, WolfArray, WolfArray, WolfArray],
+                                            tuple[WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB]]:
         """
         Create Danger Maps
 
@@ -5131,13 +5350,22 @@ class Wolfresults_2D(Element_To_Draw):
         :param every: step interval
         :param callback: optional callback to update progress
 
-        :return : tuple of WolfArray or WolfArrayMB - H, U_norm, Q_norm, Z, Head
+        :return : tuple of WolfArray or WolfArrayMB - H, U_norm, Q_norm, Z, Head, Time_of_arrival, Time_of_maximum
         """
 
+        DEFAULT_TOA = 0.
+
+        if hmin is None:
+            hmin = self.epsilon
+
         # Number of  time steps
         number_of_time_steps = self.get_nbresults()
         if end ==-1:
-            end = number_of_time_steps
+            end = number_of_time_steps - 1
+
+        if end > number_of_time_steps:
+            logging.warning("End time step is greater than the number of time steps. Setting end to the last time step.")
+            end = number_of_time_steps - 1
 
         # Init Danger Maps basde on results type
         #    If only one block --> WolfArray
@@ -5148,7 +5376,16 @@ class Wolfresults_2D(Element_To_Draw):
         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]
+        danger_map_matrix_toa = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_tom = 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,
+                  danger_map_matrix_toa,
+                  danger_map_matrix_tom]
 
         for curdanger in danger:
             curdanger.nullvalue = 0.
@@ -5159,12 +5396,15 @@ class Wolfresults_2D(Element_To_Draw):
         #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))
+                callback(time_step, "Step {} / {}".format(int(time_step+1), int(end)))
 
-            self.read_oneresult(time_step+1)
+            self.read_oneresult(time_step)
+
+            cur_time = self.times[time_step]
 
             if self.nb_blocks>1:
                 for curblock in self.myblocks.keys():
@@ -5188,14 +5428,23 @@ class Wolfresults_2D(Element_To_Draw):
                     z[ij]   = wd.array[ij] + top.array[ij]
                     head[ij]= z[ij] + v[ij]**2./2/9.81
 
+                    # Fill the time of arrival
+                    danger_map_matrix_toa[curblock].array[(danger_map_matrix_toa.array == DEFAULT_TOA) & (wd.array > hmin)] = cur_time
+
+                    # Fill the time of maximum
+                    #  Searching where wd > h_max
+                    ij_h = np.where((danger_map_matrix_h[curblock].array < wd.array) & (~wd.array.mask))
+                    danger_map_matrix_tom[curblock].array[ij_h] = cur_time
+
                     # Comparison
                     for curdanger, curcomp in zip(danger, [wd.array, v, mom, z, head]):
-                        ij = np.where((curdanger.array < curcomp) & (~wd.array.mask))
-                        curdanger.array.data[ij] = curcomp[ij]
-                        curdanger.array.mask[ij] = False
+                        ij = np.where((curdanger[curblock].array < curcomp) & (~wd.array.mask))
+                        curdanger[curblock].array.data[ij] = curcomp[ij]
+                        curdanger[curblock].array.mask[ij] = False
 
             else:
                 curblock = getkeyblock(0)
+
                 wd = self.get_h_for_block(curblock)
                 qx = self.get_qx_for_block(curblock)
                 qy = self.get_qy_for_block(curblock)
@@ -5214,8 +5463,16 @@ class Wolfresults_2D(Element_To_Draw):
                 z[ij]   = wd.array[ij] + top.array[ij]
                 head[ij]= z[ij] + v[ij]**2./2/9.81
 
+                # Fill the time of arrival
+                danger_map_matrix_toa.array[(danger_map_matrix_toa.array == DEFAULT_TOA) & (wd.array > hmin)] = cur_time
+
+                # Fill the time of maximum
+                #  Searching where wd > h_max
+                ij_h = np.where((danger_map_matrix_h.array < wd.array) & (~wd.array.mask))
+                danger_map_matrix_tom.array[ij_h] = cur_time
+
                 # Comparison
-                for curdanger, curcomp in zip(danger, [wd.array, v, mom, z, head]):
+                for curdanger, curcomp in zip(danger[:5], [wd.array, v, mom, z, head]):
                     ij = np.where((curdanger.array < curcomp) & (~wd.array.mask))
                     curdanger.array.data[ij] = curcomp[ij]
                     curdanger.array.mask[ij] = False
@@ -5228,37 +5485,30 @@ class Wolfresults_2D(Element_To_Draw):
                 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[:,:]
+                danger_map_matrix_toa[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_tom[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 __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]]:
+            danger_map_matrix_toa.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_tom.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,
+                danger_map_matrix_toa,
+                danger_map_matrix_tom)
+
+    def danger_map_multiprocess(self, start:int=0, end:int=-1,
+                                every:int=1,
+                                callback=None,
+                                hmin:float = None,
+                                nb_processors:int = -1) -> Union[tuple[WolfArray, WolfArray, WolfArray, WolfArray, WolfArray, WolfArray],
+                                                                 tuple[WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB]]:
         """
         Create Danger Maps using multiprocessing
 
@@ -5268,18 +5518,37 @@ class Wolfresults_2D(Element_To_Draw):
         :param callback: optional callback to update progress
         """
 
+        DEFAULT_TOA = 0.
+
         from multiprocessing import Pool, cpu_count
 
+        if hmin is None:
+            hmin = self.epsilon
+
         if nb_processors == -1:
             nb_processors = cpu_count()
+        elif nb_processors > cpu_count():
+            nb_processors = cpu_count()
+        elif nb_processors < 1:
+            nb_processors = 1
+
+        if end == -1:
+            end = self.get_nbresults() - 1
+        if end > self.get_nbresults():
+            logging.warning("End time step is greater than the number of time steps. Setting end to the last time step.")
+            end = self.get_nbresults() - 1
 
         if nb_processors > self.get_nbresults():
-            nb_processors = self.get_nbresults()
+            logging.warning('Number of processors is greater than the number of time steps.')
+            nb_processors = int(self.get_nbresults() /4)
+        elif nb_processors > end-start+1:
+            logging.warning('Number of processors is greater than the number of time steps.')
+            nb_processors = int((end-start)/4)
 
-        # Split the range of time steps into chunks for multiprocessing
-        if end == -1:
-            end = self.get_nbresults()
+        if nb_processors < 1:
+            nb_processors = 1
 
+        # Create a list of chunks
         starts = [start + i * every for i in range(nb_processors)]
         ends = [end - i * every for i in range(nb_processors-1,-1,-1)]
 
@@ -5294,7 +5563,18 @@ class Wolfresults_2D(Element_To_Draw):
             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)))]
+        # clip ends to end
+        for i in range(len(ends)):
+            if ends[i] > end:
+                ends[i] = end
+
+        everys = [min(nb_processors, (_end - _start)) for _start, _end in zip(starts, ends)]
+
+        chunks = [(self,
+                   starts[i],
+                   ends[i],
+                   everys[i],
+                   hmin) for i in range(min(nb_processors, len(starts)))]
 
         # Create a pool of workers
         with Pool(processes=nb_processors) as pool:
@@ -5306,7 +5586,16 @@ class Wolfresults_2D(Element_To_Draw):
         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]
+        danger_map_matrix_toa = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_tom = 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,
+                  danger_map_matrix_toa,
+                  danger_map_matrix_tom]
 
         for curdanger in danger:
             curdanger.nullvalue = 0.
@@ -5315,16 +5604,89 @@ class Wolfresults_2D(Element_To_Draw):
 
         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)
+
+                for i in range(self.nb_blocks):
+
+                    # time of arrival
+                    # Store if the value is DEFAULT_TOA  and the new value is > 0
+                    # Other cases correspond to an lower TOA
+
+                    danger_toa = danger_map_matrix_toa[i].array
+                    res_toa = result[5][i].array
+
+                    ij = np.where((danger_toa.data == DEFAULT_TOA) & (res_toa.data > 0.))
+                    danger_toa.data[ij] = res_toa.data[ij]
+                    danger_toa.mask[ij] = False
+
+                    # time of peak
+                    # Le temps de pic n'a pas encore été atteint et un valeur existe --> on prend
+                    danger_tom = danger_map_matrix_tom[i].array
+                    danger_h   = danger_map_matrix_h[i].array
+                    res_tom = result[6][i].array
+                    res_h = result[0][i].array
+
+                    # Le temps de pic a été initialisé et une autre valeur existe --> on prend le temps où la hauteur est max
+                    ij = np.where((danger_tom.data > 0.) & (danger_h.data == res_h.data) & (~res_tom.mask))
+                    danger_tom.data[ij] = np.minimum(res_tom.data[ij], danger_tom.data[ij])
+                    danger_tom.mask[ij] = False
+
+                    # Le temps de pic a été initialisé et une autre valeur existe --> on prend le temps où la hauteur est max
+                    ij = np.where((danger_tom.data > 0.) & (danger_h.data < res_h.data) & (~res_tom.mask))
+                    danger_tom.data[ij] = res_tom.data[ij]
+                    danger_tom.mask[ij] = False
+                    danger_h.data[ij] = res_h.data[ij]
+
+                    ij = np.where(((danger_tom.data == 0.) & (res_tom.data > 0.)))
+                    danger_tom.data[ij] = res_tom.data[ij]
+                    danger_h.data[ij]   = res_h.data[ij]
+                    danger_tom.mask[ij] = False
+
+                # for i in range(self.nb_blocks):
+                    for idx, curdanger in enumerate(danger[:5]):
+
+                        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):
+                # time of arrival
+                # Store if the value is DEFAULT_TOA  and the new value is > 0
+                # Other cases correspond to an lower TOA
+
+                danger_toa = danger_map_matrix_toa.array
+                res_toa = result[5].array
+
+                ij = np.where((danger_toa.data == DEFAULT_TOA) & (res_toa.data > 0.))
+                danger_toa.data[ij] = res_toa.data[ij]
+                danger_toa.mask[ij] = False
+
+                # time of peak
+                # Le temps de pic n'a pas encore été atteint et un valeur existe --> on prend
+                danger_tom = danger_map_matrix_tom.array
+                danger_h   = danger_map_matrix_h.array
+                res_tom = result[6].array
+                res_h = result[0].array
+
+                # Le temps de pic a été initialisé et une autre valeur existe --> on prend le temps où la hauteur est max
+                ij = np.where((danger_tom.data > 0.) & (danger_h.data == res_h.data) & (~res_tom.mask))
+                danger_tom.data[ij] = np.minimum(res_tom.data[ij], danger_tom.data[ij])
+                danger_tom.mask[ij] = False
+
+                # Le temps de pic a été initialisé et une autre valeur existe --> on prend le temps où la hauteur est max
+                ij = np.where((danger_tom.data > 0.) & (danger_h.data < res_h.data) & (~res_tom.mask))
+                danger_tom.data[ij] = res_tom.data[ij]
+                danger_tom.mask[ij] = False
+                danger_h.data[ij] = res_h.data[ij]
+
+                ij = np.where(((danger_tom.data == 0.) & (res_tom.data > 0.)))
+                danger_tom.data[ij] = res_tom.data[ij]
+                danger_h.data[ij]   = res_h.data[ij]
+                danger_tom.mask[ij] = False
+
+                for idx, curdanger in enumerate(danger[:5]):
                     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:
@@ -5333,13 +5695,20 @@ class Wolfresults_2D(Element_To_Draw):
                 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[:,:]
+                danger_map_matrix_toa[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_tom[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[:,:]
+            danger_map_matrix_toa.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_tom.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)
+        return (danger_map_matrix_h, danger_map_matrix_v,
+                danger_map_matrix_mom, danger_map_matrix_z,
+                danger_map_matrix_head,
+                danger_map_matrix_toa, danger_map_matrix_tom)
 
     def danger_map_only_h(self, start:int=0, end:int=-1, every:int=1) -> WolfArray:
         """