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

wolfhece/wolfresults_2D.py

@@ -39,7 +39,7 @@ from .drawing_obj import Element_To_Draw
 from .PyPalette import wolfpalette
 from .PyTranslate import _
 from .gpuview import GRID_N, Rectangle, VectorField
-from .pyshields import get_d_cr, get_d_cr_susp, izbach_d_cr, get_Shields_2D_Manning, get_friction_slope_2D_Manning, get_shear_velocity_2D_Manning
+from .pyshields import get_d_cr, get_d_cr_susp, izbach_d_cr, get_Shields_2D_Manning, get_friction_slope_2D_Manning, get_shear_velocity_2D_Manning, get_shear_velocity_2D_Colebrook
 from .pyviews import WolfViews
 from .mesh2d.wolf2dprev import prev_parameters_simul, blocks_file
 from .GraphNotebook import PlotPanel
@@ -76,67 +76,135 @@ from .wolf_array import WolfArray, getkeyblock, header_wolf, WolfArrayMB, WolfAr
 from .mesh2d import wolf2dprev
 from .PyVertexvectors import vector, zone, Zones
 
+from numba import jit, njit
 
 def outside_domain(val):
     """ Test if a value is outside the calculated domain """
     return val[0][0] is np.ma.masked or val[1][0] =='-'
 
-def q_splitting(q_left, q_right):
-    """ Splitting of the normal flow between two nodes """
+@jit(nopython=True, nogil=True, cache=True)
+def splitting_rule(q_left:float, q_right:float) -> float:
+    """ Ponderation factor - Splitting at border between two nodes
 
+    :return: factor of the left node (0.5 = equal splitting)
+    """
+    epsilon = 1.e-100
+    prod_q = q_left * q_right  # product of the two flows
+    sum_q  = q_left + q_right  # sum of the two flows
+    if prod_q > 0.:
+        # The 2 flows are in the same direction
+        if q_left > 0.:
+            # left is the upstream node
+            return 1.
+        else:
+            # right is the upstream node
+            return 0.
+    elif prod_q < 0.:
+        # The 2 flows are in opposite direction
+        if q_left > 0.:
+            if sum_q > 0.:
+                # The sum is positive, the left node is the upstream node
+                return 1.
+            elif sum_q < 0.:
+                # The sum is negative, the right node is the upstream node
+                return 0.
+            else:
+                # The sum is null, the flow is centered between the two nodes
+                return 0.5
+        elif q_left < 0.:
+            # CONFLICTING FLOWS
+            return 0.5
+        else:
+            # should not be possible
+            raise ValueError("Splitting rule: q_left is null but product is negative")
+    else:
+        # One flow is null or the product is so small that it is considered as null.
+        # FYI, in the GPU code, we compare to espilon.
+        if q_left>epsilon:
+            # left is the upstream node
+            return 1.
+        elif q_right<-epsilon:
+            # right is the upstream node
+            return 0.
+        else:
+            # The flow is centered between the two nodes
+            return .5
+
+@jit(nopython=True, nogil=True, cache=True)
+def q_splitting(q_left:float, q_right:float) -> float:
+    """ Splitting of the normal flow between two nodes """
+    #FIXME : use splitting_rule ?
+    epsilon = 1.e-100
     prod_q = q_left * q_right
-    sum_q = q_left + q_right
+    sum_q  = q_left + q_right
     if prod_q > 0.:
         if q_left > 0.:
             return q_left
         else:
             return q_right
     elif prod_q < 0.:
-        if sum_q > 0.:
-            return q_left
-        elif sum_q < 0.:
-            return q_right
+        if q_left > 0.:
+            if sum_q > 0.:
+                return q_left
+            elif sum_q < 0.:
+                return q_right
+            else:
+                return 0.
+        elif q_left < 0.:
+            # CONFLICTING FLOWS
+            return sum_q / 2.
         else:
-            return 0.
+            # should not be possible
+            raise ValueError("Splitting rule: q_left is null but product is negative")
     else:
-        if q_left<0.:
-            return 0.
-        elif q_right<0.:
-            return 0.
+        if q_left>epsilon:
+            # Left is the upstream node
+            return q_left
+        elif q_right<-epsilon:
+            # right is the upstream node
+            return q_right
         else:
             return sum_q / 2.
 
-def u_splitting(q_left, q_right, h_left, h_right):
+@jit(nopython=True, nogil=True, cache=True)
+def u_splitting(q_left:float, q_right:float, h_left:float, h_right:float) -> float:
     """ Splitting of the normal flow velocity between two nodes """
-
+    #FIXME : use splitting_rule ?
+    epsilon = 1.e-100
     prod_q = q_left * q_right
-    sum_q = q_left + q_right
+    sum_q  = q_left + q_right
     if prod_q > 0.:
         if q_left > 0.:
             return q_left/h_left
         else:
             return q_right/h_right
     elif prod_q < 0.:
-        if sum_q > 0.:
-            return q_left/h_left
-        elif sum_q < 0.:
-            return q_right/h_right
+        if q_left > 0.:
+            if sum_q > 0.:
+                return q_left/h_left
+            elif sum_q < 0.:
+                return q_right/h_right
+            else:
+                return 0.
+        elif q_left < 0.:
+            return (q_left/h_left + q_right/h_right) / 2.
         else:
-            return 0.
+            # should not be possible
+            raise ValueError("Splitting rule: q_left is null but product is negative")
     else:
-        if q_left<0.:
-            return 0.
-        elif q_right<0.:
-            return 0.
+        if q_left>epsilon:
+            return q_left / h_left
+        elif q_right<-epsilon:
+            return q_right / 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
+    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):
     """
@@ -1507,6 +1575,7 @@ class OneWolfResult:
     """
     def __init__(self, idx:int=0, parent = None):
 
+        self.parent:"Wolfresults_2D"
         self.parent = parent
 
         self.wx_exists = wx.GetApp() is not None
@@ -1539,6 +1608,13 @@ class OneWolfResult:
         self._sedimentdensity = 2.65
         self._force_update_shields = True # Force la MAJ du Shields si le diametre ou la densité change
 
+        self._is_manning_strickler = True
+        self._is_colebrook = False
+
+        self._has_turbulence_model = False
+        self._cmu = 0.09
+        self._cnu = 0.08
+
         # self.mngselection = SelectionData(self.current)
 
     @property
@@ -1658,12 +1734,24 @@ class OneWolfResult:
         elif which==views_2D.HEAD:
             self._current=(self.qx**2.+self.qy**2.)**.5/self.waterdepth/(2.*9.81)+self.waterdepth+self.top
             nullvalue = self.qx.nullvalue
+
         elif which==views_2D.KINETIC_ENERGY:
             self._current=self.k
             nullvalue = self.k.nullvalue
         elif which==views_2D.EPSILON:
             self._current=self.eps
             nullvalue = self.eps.nullvalue
+
+        elif which==views_2D.TURB_VISC_2D:
+
+            self._current = self.k**2./self.eps * self._cmu
+            nullvalue = self.k.nullvalue
+
+        elif which==views_2D.TURB_VISC_3D:
+            self.U_Shear = self.get_u_shear()
+            self._current = self.U_Shear * self.waterdepth * self._cnu
+            nullvalue = self.waterdepth.nullvalue
+
         elif which==views_2D.VECTOR_FIELD_Q:
             self._current=(self.qx**2.+self.qy**2.)**.5
             nullvalue = self.qx.nullvalue
@@ -1966,7 +2054,12 @@ class OneWolfResult:
             qnorm = (self.qx**2.+self.qy**2.)**.5
             qnorm.array.mask=self.waterdepth.array.mask
 
-            _u_shear = np.asarray([get_shear_velocity_2D_Manning(qnorm.array[i,j],
+            if self._is_manning_strickler:
+                _u_shear = np.asarray([get_shear_velocity_2D_Manning(qnorm.array[i,j],
+                                                     self.waterdepth.array[i,j],
+                                                     self.rough_n.array.data[i,j]) for i,j in ij])
+            elif self._is_colebrook:
+                _u_shear = np.asarray([get_shear_velocity_2D_Colebrook(qnorm.array[i,j],
                                                      self.waterdepth.array[i,j],
                                                      self.rough_n.array.data[i,j]) for i,j in ij])
 
@@ -1974,9 +2067,16 @@ class OneWolfResult:
 
             return u_shear
 
+        if not (self._is_manning_strickler or self._is_colebrook):
+            logging.error(_('Surface friction is not Manning-Strickler or Colebrook.'))
+            logging.error(_('Cannot compute shear velocity or Program it... in get_u_shear'))
+            ret = WolfArray(mold=self.waterdepth)
+            ret.array.fill(0.)
+            return ret
+
         logging.info(_('Computing shear velocity'))
         u_shear = compute()
-        logging.info(_('End of computing shear velocity'))
+        # logging.info(_('End of computing shear velocity'))
 
         return u_shear
 
@@ -2207,118 +2307,194 @@ class Wolfresults_2D(Element_To_Draw):
         if fname is not None:
 
             if loader is not None:
+                # Used for GPU results
                 if loader(fname) <0:
                     self.loaded = False
                     logging.error(_('Error while loading results - Abort !'))
                     return
 
             else:
-                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
-
-                        self.myblocks[getkeyblock(i)].waterdepth.dx = dx
-                        self.myblocks[getkeyblock(i)].waterdepth.dy = dy
-                        self.myblocks[getkeyblock(i)].waterdepth.nbx = nbx
-                        self.myblocks[getkeyblock(i)].waterdepth.nby = nby
-                        self.myblocks[getkeyblock(i)].waterdepth.origx = ox
-                        self.myblocks[getkeyblock(i)].waterdepth.origy = oy
-                        self.myblocks[getkeyblock(i)].waterdepth.translx = self.translx
-                        self.myblocks[getkeyblock(i)].waterdepth.transly = self.transly
-
-                        self.myblocks[getkeyblock(i)].top.dx = dx
-                        self.myblocks[getkeyblock(i)].top.dy = dy
-                        self.myblocks[getkeyblock(i)].top.nbx = nbx
-                        self.myblocks[getkeyblock(i)].top.nby = nby
-                        self.myblocks[getkeyblock(i)].top.origx = ox
-                        self.myblocks[getkeyblock(i)].top.origy = oy
-                        self.myblocks[getkeyblock(i)].top.translx = self.translx
-                        self.myblocks[getkeyblock(i)].top.transly = self.transly
-
-                        self.myblocks[getkeyblock(i)].qx.dx = dx
-                        self.myblocks[getkeyblock(i)].qx.dy = dy
-                        self.myblocks[getkeyblock(i)].qx.nbx = nbx
-                        self.myblocks[getkeyblock(i)].qx.nby = nby
-                        self.myblocks[getkeyblock(i)].qx.origx = ox
-                        self.myblocks[getkeyblock(i)].qx.origy = oy
-                        self.myblocks[getkeyblock(i)].qx.translx = self.translx
-                        self.myblocks[getkeyblock(i)].qx.transly = self.transly
-
-                        self.myblocks[getkeyblock(i)].qy.dx = dx
-                        self.myblocks[getkeyblock(i)].qy.dy = dy
-                        self.myblocks[getkeyblock(i)].qy.nbx = nbx
-                        self.myblocks[getkeyblock(i)].qy.nby = nby
-                        self.myblocks[getkeyblock(i)].qy.origx = ox
-                        self.myblocks[getkeyblock(i)].qy.origy = oy
-                        self.myblocks[getkeyblock(i)].qy.translx = self.translx
-                        self.myblocks[getkeyblock(i)].qy.transly = self.transly
-
-                        self.myblocks[getkeyblock(i)].rough_n.dx = dx
-                        self.myblocks[getkeyblock(i)].rough_n.dy = dy
-                        self.myblocks[getkeyblock(i)].rough_n.nbx = nbx
-                        self.myblocks[getkeyblock(i)].rough_n.nby = nby
-                        self.myblocks[getkeyblock(i)].rough_n.origx = ox
-                        self.myblocks[getkeyblock(i)].rough_n.origy = oy
-                        self.myblocks[getkeyblock(i)].rough_n.translx = self.translx
-                        self.myblocks[getkeyblock(i)].rough_n.transly = self.transly
-
-                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)])
-
-                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
 
@@ -2348,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
@@ -2832,7 +3190,6 @@ class Wolfresults_2D(Element_To_Draw):
         self.myparam.read_file(self.filename)
 
         self.myblocfile = blocks_file(self)
-        # self.myblocfile.read_file()
 
         self.mymnap = WolfArrayMNAP(self.filename)
 
@@ -2864,7 +3221,7 @@ class Wolfresults_2D(Element_To_Draw):
         for curblock in self.myblocks.values():
             curblock.filter_independent_zones(n_largest)
 
-    def set_currentview(self, which=None, force_wx=False, force_updatepal:bool=False):
+    def set_currentview(self, which:views_2D = None, force_wx:bool = False, force_updatepal:bool=False):
         """
         Set the current view --> see 'views_2D' for supported values
 
@@ -2895,11 +3252,14 @@ class Wolfresults_2D(Element_To_Draw):
             self.plotting=True
             self.mimic_plotdata()
 
-            if which in VIEWS_SEDIMENTARY:
+            if which in VIEWS_SEDIMENTARY + [views_2D.TURB_VISC_3D, views_2D.U_SHEAR]:
 
                 if not self.loaded_rough:
                     self.read_roughness_param()
 
+            if which in [views_2D.KINETIC_ENERGY, views_2D.TURB_VISC_2D, views_2D.TURB_VISC_3D, views_2D.EPSILON]:
+                self.read_oneresult(self.current_result)
+
             for curblock in self.myblocks.values():
                 curblock.set_current(which)
 
@@ -2933,6 +3293,8 @@ class Wolfresults_2D(Element_To_Draw):
             if self.mapviewer is not None:
                 self.reset_plot()
                 self.mapviewer.Refresh()
+        else:
+            logging.error(_('Unknown view - {}'.format(which)))
 
     def allocate_ressources(self):
         """Allocation de l'espace mémoire utile pour le stockage des résultats de chaque bloc"""
@@ -4976,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
 
@@ -4985,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
@@ -5002,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.
@@ -5013,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():
@@ -5042,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)
@@ -5068,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
@@ -5082,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
 
@@ -5122,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)]
 
@@ -5148,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:
@@ -5160,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.
@@ -5169,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:
@@ -5187,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:
         """