tilupy 2.0.0__py3-none-any.whl

tilupy/models/ravaflow/read.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jun  1 15:27:36 2021
+
+@author: peruzzetto
+"""
+import os
+
+import numpy as np
+import tilupy.read
+
+# Dictionnary with results names lookup table, to match code output names
+LOOKUP_NAMES = dict(h='hflow',
+                    u='vflow', ux='vflowx', uy='vflowy',
+                    hu='momentum', hu2='ek',
+                    vol='vol', ekint='ekint')
+
+# Classify results
+STATES_OUTPUT = ['h', 'ux', 'uy']
+forces = ['facc', 'fcurv', 'ffric', 'fgrav', 'fpression']
+FORCES_OUTPUT = []
+for axis in ['x', 'y']:
+    for f in forces:
+        FORCES_OUTPUT.append(f + axis)
+
+
+def read_params(file):
+    """
+    Read simulation parameters from file.
+
+    Parameters
+    ----------
+    file : str
+        Parameters file.
+
+    Returns
+    -------
+    params : dict
+        Dictionnary with parameters
+
+    """
+    params = dict()
+    if not file.endswith('.txt'):
+        prefix = file.sep('/')[-1].sep('_')[0]
+        file = os.path.join(file, prefix+'_files',
+                            prefix+'_documentation.txt')
+
+    with open(file, 'r') as f:
+        for line in f:
+            (key, val) = line.split('\t')
+            try:
+                params[key] = float(val)
+            except ValueError:
+                if val == 'TRUE':
+                    params[key] = True
+                if val == 'FALSE':
+                    params[key] = False
+                else:
+                    params[key] = val
+
+    return params
+
+
+def read_ascii(file):
+    """
+    Read ascii grid file to numpy ndarray.
+
+    Parameters
+    ----------
+    file : TYPE
+        DESCRIPTION.
+
+    Returns
+    -------
+    None.
+
+    """
+    dem = np.loadtxt(file, skiprows=6)
+    # dem = np.flip(dem, axis=0).T
+    grid = {}
+    with open(file, 'r') as fid:
+        for i in range(6):
+            tmp = fid.readline().split()
+            grid[tmp[0]] = float(tmp[1])
+    try:
+        x0 = grid['xllcenter']
+        y0 = grid['yllcenter']
+    except KeyError:
+        x0 = grid['xllcorner']
+        y0 = grid['yllcorner']
+    nx = int(grid['ncols'])
+    ny = int(grid['nrows'])
+    dx = dy = grid['cellsize']
+    x = np.linspace(x0, x0+(nx-1)*dx, nx)
+    y = np.linspace(y0, y0+(ny-1)*dy, ny)
+
+    return x, y, dem
+
+
+def read_asciis(file_prefix, folder=None, ind=None, nodigit=False):
+    """
+    Read mutiple ascii grid file matching prefix.
+
+    Parameters
+    ----------
+    file : TYPE
+        DESCRIPTION.
+    ind : TYPE, optional
+        DESCRIPTION. The default is None.
+
+    Returns
+    -------
+    None.
+
+    """
+    if folder is None:
+        folder = os.getcwd()
+
+    files_tmp = os.listdir(folder)
+    files = []
+    for ff in files_tmp:
+        # test is file begins with file_prefix
+        if ff.startswith(file_prefix) and ff.endswith('.asc'):
+            letter = ff.split(file_prefix)[1][0]
+            # After file_prefix, character must be either '.' or a digit
+            if nodigit:
+                if letter == '.':
+                    files.append(ff)
+            else:
+                if letter.isdigit() or letter == '.':
+                    files.append(ff)
+
+    files.sort()
+
+    if ind is not None:
+        if ind == 'final':
+            files = [files[-1]]
+        elif ind == 'initial':
+            files = [files[0]]
+        else:
+            files = [ff for ff in files if int(ff[-8:-4]) in ind]
+
+    files = [os.path.join(folder, ff) for ff in files]
+
+    dem = np.loadtxt(files[0], skiprows=6)
+    if len(files) > 1:
+        dem = dem[:, :, np.newaxis]
+    for ff in files[1:]:
+        _, _, dem2 = np.loadtxt(ff, skiprows=6)
+        dem = np.concatenate((dem, dem2[:, :, np.newaxis]), axis=2)
+
+    dem = np.squeeze(dem)
+
+    return dem
+
+
+class Results(tilupy.read.Results):
+    """Results of shaltop simulations."""
+
+    def __init__(self, text_rheol=None, folder_base=None, **varargs):
+        """
+        Init simulation results.
+
+        Parameters
+        ----------
+        file_params : str
+            File where simulation parameters will be read
+
+        """
+        self.code = 'ravaflow'
+        self.prefix = text_rheol
+        self.folder_base = folder_base
+        file_params = os.path.join(folder_base,
+                                   self.prefix + '_results',
+                                   self.prefix + '_files',
+                                   self.prefix + '_documentation.txt')
+        self.params = read_params(file_params)
+
+        self.folder_ascii = os.path.join(folder_base,
+                                         self.prefix + '_results',
+                                         self.prefix + '_ascii')
+        self.folder_files = os.path.join(folder_base,
+                                         self.prefix + '_results',
+                                         self.prefix + '_files')
+
+        self.set_axes()
+
+        # Get time of outputs
+        with open(os.path.join(self.folder_files,
+                               self.prefix+'_summary.txt')) as fid:
+            self.tim = []
+            for line in fid:
+                res = line.split()
+                if len(res) > 0:
+                    if res[0].isdigit():
+                        self.tim.append(float(res[4]))
+
+    def set_axes(self, x=None, y=None, **varargs):
+        """Set x and y axes."""
+        dd = self.params['Cell size']
+        x = np.arange(self.params['Western boundary']+dd/2,
+                      self.params['Eastern boundary'],
+                      dd)
+        y = np.arange(self.params['Southern boundary']+dd/2,
+                      self.params['Northern boundary'],
+                      dd)
+        self.x = x
+        self.y = y
+        self.nx = len(x)
+        self.ny = len(y)
+
+    def set_zinit(self, zinit=None):
+        """Set zinit, initial topography."""
+        path_zinit = os.path.join(self.folder_ascii,
+                                  self.prefix+'_elev.asc')
+        self.zinit = np.loadtxt(path_zinit, skiprows=6)
+
+    def get_temporal_output(self, name, d=None, t=None, **varargs):
+        """
+        Read 2D time dependent simulation results.
+
+        Parameters
+        ----------
+        name : str
+            Name of output.
+        d : ndarray, optional
+            Data to be read. If None, will be computed.
+            The default is None.
+        t : ndarray, optional
+            Time of results snapshots (1D array), matching last dimension of d.
+            If None, will be computed. The default is None.
+        **varargs : TYPE
+            DESCRIPTION.
+
+        """
+        # Read thicknesses or velocity components
+        file_prefix = self.prefix + '_' + LOOKUP_NAMES[name]
+        d = read_asciis(file_prefix, folder=self.folder_ascii)
+
+        return tilupy.read.TemporalResults(name, d, self.tim)
+
+    def get_static_output(self, name, stat,
+                          d=None, from_file=False, **varargs):
+        """
+        Read 2D time dependent simulation results.
+
+        Parameters
+        ----------
+        name : str
+            Name of output.
+        d : ndarray, optional
+            Data to be read. Last dimension is for time.
+            If None, will be computed.
+            The default is None.
+        **varargs : TYPE
+            DESCRIPTION.
+
+        """
+        if stat in ['initial', 'final']:
+            file_prefix = self.prefix + '_' + LOOKUP_NAMES[name]
+            d = read_asciis(file_prefix, folder=self.folder_ascii, ind=stat)
+        elif stat == 'max' and from_file:
+            file = '{:s}_{:s}_{:s}.asc'.format(self.prefix,
+                                               LOOKUP_NAMES[name],
+                                               stat)
+            file = os.path.join(self.folder_ascii, file)
+            d = np.loadtxt(file, skiprows=6)
+        else:
+            data = self.get_temporal_output(name)
+            d = data.get_temporal_stat(stat).d
+
+        return tilupy.read.StaticResults(name+stat, d)

tilupy/models/saval2D/read.py

@@ -0,0 +1,298 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import numpy as np
+import tilupy.read
+
+# Classify results
+AVAILABLE_OUTPUT = ["h", "hvert", "u", "hu", "hu2", "ux", "uy", "hux", "huy"]
+"""All output available for a shaltop simulation.
+
+Implemented states:
+
+    - h : Flow thickness (normal to the surface)
+    - hux : Momentum flux component in X direction
+    - huy : Momentum flux component in Y direction
+    
+Output computed from other output:
+    
+    - hvert : True vertical flow thickness
+    - ux : Velocity component in X direction
+    - uy : Velocity component in Y direction
+    - u : Norm of the velocity (from ux and uy)
+    - hu : Momentum flux (from h and u)
+    - hu2 : Convective momentum flux (from h and u)
+"""
+
+
+def extract_saval_ascii(path: str) -> np.ndarray:
+    """Extract ascii file data generated by saval2D.
+
+    Parameters
+    ----------
+    path : str
+        Path to the ascii file.
+
+    Returns
+    -------
+    numpy.ndarray
+        Values in the ascii file.
+    """
+    with open(path, 'r') as f:
+        lines = f.readlines()
+    start_index = 6
+    
+    h_str = lines[start_index:]
+
+    h = [list(map(float, line.split())) for line in h_str if line.strip()]
+    return np.array(h)
+
+
+class Results(tilupy.read.Results):
+    """Results of saval2D simulations.
+
+    This class is the results class for saval2D. Reading results from saval2D outputs 
+    are done in this class.
+    
+    This class has all the global and quick attributes of the parent class. The quick 
+    attributes are only computed if needed and can be deleted to clean memory.
+    
+    In addition to these attributes, there are those necessary for the operation of 
+    reading the saval2D results.
+    
+    Parameters
+    ----------
+    folder : str
+        Path to the folder containing the simulation files.
+    raster_topo : str
+        Topographic raster name.
+            
+    Attributes
+    ----------
+        _simu_inputs : str
+            Path to the input folder of saval2D simulation.
+        _simu_outputs : str
+            Path to the output folder of saval2D simulation.
+        _raster : str
+            Raster file name.
+        _params : dict
+            Dictionary storing all simulation parameters.
+    """
+    def __init__(self, folder, raster_topo="mntsimulation.asc"):
+        super().__init__()
+        self._code = "saval2D"
+        
+        self._folder = folder
+        self._folder_output = folder
+        
+        self._simu_inputs = os.path.join(folder, "inputs") if os.path.exists(os.path.join(folder, "inputs")) else None
+        self._simu_outputs = os.path.join(folder, "outputs") if os.path.exists(os.path.join(folder, "outputs")) else None
+        
+        if not raster_topo.endswith(".asc"):
+            raster_topo = raster_topo + ".asc"
+        self._raster = raster_topo
+
+        self._params = dict()
+
+        if self._simu_inputs is not None:
+            self._x, self._y, self._zinit = tilupy.raster.read_ascii(os.path.join(self._simu_inputs, 
+                                                                                  self._raster))
+        self._nx, self._ny = len(self._x), len(self._y)
+        self._dx = self._x[1] - self._x[0]
+        self._dy = self._y[1] - self._y[0]
+
+        self._params["nx"] = len(self.x)
+        self._params["ny"] = len(self.y)
+
+        # Rheology
+        rheol = self.get_rheological_parameters(os.path.join(self._simu_outputs, "log.txt"))
+        self._params["tau/rho"] = rheol[0]
+        self._params["mu"] = rheol[1]
+        self._params["xi"] = rheol[2]
+
+        # Create self._tim
+        self._extract_output("X")
+
+        
+    def get_rheological_parameters(self, path_to_log: str) -> list[str]:
+        """Get rheological parameters of a saval2D simulation.
+
+        Parameters
+        ----------
+        path_to_log : str
+            Path to the log file containing the value of the rheological parameters.
+
+        Returns
+        -------
+        list[str]
+            List of rheological parameters : tau/rho, mu and xi.
+        """
+        values = None
+        with open(path_to_log, "r") as f:
+            for line in f:
+                line = line.strip()
+                try:
+                    parts = list(map(float, line.split()))
+                    if len(parts) == 3:
+                        values = parts
+                        break
+                except ValueError:
+                    continue
+        return values
+        
+    
+    def get_times(self, path: str) -> list[float]:
+        """Get simulation time steps.
+
+        Parameters
+        ----------
+        path : str
+            Path to the log file.
+
+        Returns
+        -------
+        list[float]
+            List of recorded time steps.
+        """
+        t_list = []
+        with open(path, 'r') as f:
+            lines = f.readlines()
+        
+        start_index = 16
+        for line in lines[start_index:]:
+            if line.strip() == '':
+                continue
+            else:
+                _, t, _, _, _ = line.split()
+                t_list.append(float(t))
+        
+        return t_list            
+    
+    
+    def _extract_output(self, 
+                        name: str, 
+                        **kwargs
+                        ) -> tilupy.read.TemporalResults2D | tilupy.read.AbstractResults:
+        """Result extraction for saval2D files.
+
+        Parameters
+        ----------
+        name : str
+            Wanted output. Can access to variables in :data:`AVAILABLE_OUTPUT`. 
+
+        Returns
+        -------
+        tilupy.read.TemporalResults2D | tilupy.read.AbstractResults
+            Wanted output. If no output computed, return an object of :class:`tilupy.read.AbstractResults`.
+        """
+        # Read thicknesses or velocity components
+        d = None
+        t = None
+        notation = None
+        
+        tim = [0]
+        t_list = self.get_times(os.path.join(self._simu_outputs, "log.txt"))
+        
+        _, _, h_init = tilupy.raster.read_ascii(os.path.join(self._simu_inputs, "zdepsimulation.asc"))
+        
+        h_list = [h_init]
+        
+        ux_list = []
+        uy_list = []
+        u_list = []
+        ux_list.append(np.zeros_like(h_init))
+        uy_list.append(np.zeros_like(h_init))
+        u_list.append(np.zeros_like(h_init))
+        
+        qx_list = []
+        qy_list = []
+        q_list = []
+        qx_list.append(np.zeros_like(h_init))
+        qy_list.append(np.zeros_like(h_init))
+        q_list.append(np.zeros_like(h_init))
+        
+        for T in range(len(t_list)):
+            h_t = extract_saval_ascii(os.path.join(self._simu_outputs, f"resuh{T+1}.asc"))
+            qu_t = extract_saval_ascii(os.path.join(self._simu_outputs, f"resuqu{T+1}.asc"))
+            qv_t = extract_saval_ascii(os.path.join(self._simu_outputs, f"resuqv{T+1}.asc"))
+
+            # Condition to avoid flow velocity on part with no fluid
+            h_t[h_t<0.0001] = 0
+            
+            ux_t = np.divide(qu_t, h_t, out=np.zeros_like(qu_t), where=h_t != 0)
+            uy_t = np.divide(qv_t, h_t, out=np.zeros_like(qv_t), where=h_t != 0)
+            
+            u_t = np.sqrt(ux_t**2 + uy_t**2)
+            q_t = np.sqrt(qu_t**2 + qv_t**2)
+            
+            h_list.append(h_t)
+            
+            ux_list.append(ux_t)
+            uy_list.append(uy_t)
+            u_list.append(u_t)
+            
+            qx_list.append(qu_t)
+            qy_list.append(qv_t)
+            q_list.append(q_t)
+            
+            tim.append(t_list[T])
+
+        if self._tim is None:
+            self._tim = np.array(tim)
+    
+        extracted_outputs = {"h": np.stack(h_list, axis=-1),
+                             "u": np.stack(u_list, axis=-1),
+                             "hu": np.stack(q_list, axis=-1),
+                             "ux": np.stack(ux_list, axis=-1),
+                             "uy": np.stack(uy_list, axis=-1),
+                             "hux": np.stack(qx_list, axis=-1),
+                             "huy": np.stack(qy_list, axis=-1),
+                             }
+
+        if name in ["h", "u", "hu", "ux", "uy", "hux", "huy"]:
+            d = extracted_outputs[name]
+            t = self._tim
+        
+        if name == "hu2":
+            d = extracted_outputs["hu"] * extracted_outputs["u"]
+            t = self._tim
+        
+        elif name == "hvert":
+            if self._costh is None:
+                self._costh = self.compute_costh()
+            d = extracted_outputs["h"] / self._costh[:, :, np.newaxis]
+            t = self._tim
+        
+        # if name == "ek":
+        #     if self._costh is None:
+        #             self._costh = self.compute_costh()
+            
+        #     d = []
+        #     for i in range(len(self._tim)):
+        #         d.append(np.sum((np.stack(available_outputs["hu"], axis=-1)[:, :, i] * 
+        #                          np.stack(available_outputs["u"], axis=-1)[:, :, i] *
+        #                          self._dx *
+        #                          self._dy)
+        #                         / self._costh[:, :]))
+        #     d = np.array(d)
+        #     t = self._tim
+        
+        if t is None:
+            return tilupy.read.AbstractResults(name, d, notation=notation)
+
+        else:
+            if d.ndim == 3:
+                return tilupy.read.TemporalResults2D(name, 
+                                                     d, 
+                                                     t, 
+                                                     notation=notation, 
+                                                     x=self._x, 
+                                                     y=self._y, 
+                                                     z=self._zinit)
+        return None
+
+
+    def _read_from_file(self, *args, **kwargs):
+        """Not useful"""
+        return "No _read_from_file for Saval2D."