tilupy 2.0.0__py3-none-any.whl

tilupy/models/lave2D/read.py

@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import numpy as np
+import tilupy.read
+
+from scipy.interpolate import RegularGridInterpolator
+
+
+# Classify results
+AVAILABLE_OUTPUT = ["h", "hvert", "u", "hu", "hu2"]
+"""All output available for a shaltop simulation.
+
+Implemented states:
+
+    - h : Flow thickness (normal to the surface)
+    - u : Norm of the velocity (from ux and uy)
+    
+Output computed from other output:
+    
+    - hvert : True vertical flow thickness
+    - hu : Momentum flux (from h and u)
+    - hu2 : Convective momentum flux (from h and u)
+"""
+
+
+class Results(tilupy.read.Results):
+    """Results of lave2D simulations.
+
+    This class is the results class for lave2D. Reading results from lave2D 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 lave2D results.
+    
+    Parameters
+    ----------
+        folder : str
+            Path to the folder containing the simulation files.
+        name : str
+            Simulation/Project name.
+        raster : str
+            Raster name.
+        grid : str, optional
+            - If grid=="cell", use cell, output nx and ny sizes are the size of topography raster, minus 1.
+            - If grid=="edges" (default), use edges, output will have same dimension as topography raster.
+    
+    Attributes
+    ----------
+        _name : str
+            Name of the lave2D project.
+        _grid : str
+            - If _grid=="cell", use cell, output nx and ny sizes are the size of topography raster, minus 1.
+            - If _grid=="edges", use edges, output will have same dimension as topography raster.
+        _raster : str
+            Path to the raster file.
+        _params : dict
+            Dictionary storing all simulation parameters.
+    """
+    def __init__(self, folder, name, raster, grid="edges"):
+        super().__init__()
+        self._code = "lave2D"
+        
+        if folder is None:
+            folder = os.getcwd()
+        self._folder = folder
+        self._folder_output = folder  
+        # Results are in the same folder than simulation data
+        
+        self._name = name
+        
+        if not raster.endswith(".asc"):
+            raster = raster + ".asc"
+        self._raster = raster
+        
+        self._x, self._y, self._zinit = tilupy.raster.read_ascii(os.path.join(folder, 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]
+                
+        # grid=='edges' -> use edges, output will have same dimension as
+        # topography raster
+        # grid=='cell' -> use cell, output nx and ny sizes are the size of
+        # topography raster, minus 1
+        self._grid = grid
+        if self._grid == "cells":
+            fz = RegularGridInterpolator((self._y, self._x),
+                                         self._zinit,
+                                         method="linear",
+                                         bounds_error=False,
+                                         fill_value=None,
+                                         )
+            self._x = self._x[1:] - self._dx / 2
+            self._y = self._y[1:] - self._dy / 2
+            x_mesh, y_mesh = np.meshgrid(self._x, self._y)
+            self._zinit = fz((y_mesh, x_mesh))
+        
+        self._params = dict()
+    
+        self._params["nx"] = len(self._x)
+        self._params["ny"] = len(self._y)
+
+        # Rheology
+        rheol = np.loadtxt(os.path.join(folder, self._name + ".rhe"))
+        self._params["tau/rho"] = rheol[0]
+        self._params["K/tau"] = rheol[1]
+
+        # Numerical parameters
+        with open(os.path.join(folder, "DONLEDD1.DON"), "r") as fid:
+            for line in fid:
+                name = line[:34].strip(" ")
+                value = line[34:]
+                if len(value) == 1:
+                    value = int(value)
+                else:
+                    value = float(value)
+                self._params[name] = value
+        
+        # Create self._tim
+        self._extract_output("X")
+
+
+    def _extract_output(self, 
+                        name: str, 
+                        **kwargs
+                        ) -> tilupy.read.TemporalResults2D | tilupy.read.AbstractResults:
+        """Result extraction for lave2D files.
+
+        Parameters
+        ----------
+        name : str
+            Wanted output. Can access to variables in :data:`AVAILABLE_OUTPUT`.
+
+        Returns
+        -------
+        tilupy.read.TemporalResults2D | tilupy.read.TemporalResults0D | tilupy.read.AbstractResults
+            Wanted output. If no output computed, return an object of :class:`tilupy.read.AbstractResults`.
+        """
+        d = None
+        t = None
+        notation = None
+        
+        # read initial mass
+        h_init = np.loadtxt(os.path.join(self._folder, self._name + ".cin"), skiprows=1)
+        
+        # Read results
+        file_res = os.path.join(self._folder, self._name + ".asc")
+        n_times = int(self._params["tmax"] / self._params["dtsorties"])
+        tim = [0]
+        
+        if self._grid == "edges":
+            ny_out = self._params["ny"] - 1
+            x_out = self._x[1:] - self._dx / 2
+            y_out = self._y[1:] - self._dy / 2
+            x_mesh, y_mesh = np.meshgrid(self._x, self._y)
+            h_init = h_init.reshape(self._params["ny"] - 1, self._params["nx"] - 1)
+            fh = RegularGridInterpolator((y_out, x_out),
+                                         h_init,
+                                         method="linear",
+                                         bounds_error=False,
+                                         fill_value=None)
+            h_init = fh((y_mesh, x_mesh))
+        else:
+            ny_out = self._params["ny"]
+            h_init = h_init.reshape(self._params["ny"], self._params["nx"])
+        
+        x_mesh_out, y_mesh_out = np.meshgrid(self._x[1:] - self._dx / 2, 
+                                             self._y[1:] - self._dy / 2)
+
+        h = np.zeros((self._params["ny"], self._params["nx"], n_times + 1))
+        h[:, :, 0] = np.flip(h_init, axis=0)
+        u = np.zeros((self._params["ny"], self._params["nx"], n_times + 1))
+        
+        with open(file_res, "r") as fid:
+            lines = fid.readlines()
+            n_lines = 2 * (ny_out) + 8  # Number of lines per time step
+            for i_time in range(n_times):
+                i_start = n_lines * i_time
+                i_start_h = i_start + 7
+                i_stop_h = i_start + ny_out + 7
+                i_start_u = i_start + ny_out + 8
+                i_stop_u = i_start + 2 * ny_out + 8
+                tim.append(float(lines[i_start]))
+                h_out = np.loadtxt(lines[i_start_h:i_stop_h])
+                u_out = np.loadtxt(lines[i_start_u:i_stop_u])
+                
+                if self._grid == "edges":
+                    fh = RegularGridInterpolator((y_out, x_out),
+                                                 h_out,
+                                                 method="linear",
+                                                 bounds_error=False,
+                                                 fill_value=None)
+                    h[:, :, i_time + 1] = fh((y_mesh, x_mesh))
+                    
+                    fu = RegularGridInterpolator((y_out, x_out),
+                                                 u_out,
+                                                 method="linear",
+                                                 bounds_error=False,
+                                                 fill_value=None)
+                    u[:, :, i_time + 1] = fu((y_mesh, x_mesh))
+                else:
+                    h[:, :, i_time + 1] = h_out
+                    u[:, :, i_time + 1] = u_out
+        
+        if self._tim is None: 
+            self._tim = np.array(tim)
+        
+        extracted_outputs = {"h": h[:],
+                             "u": u[:],
+                             }
+
+        if name in ["h", "u"]:
+            d = extracted_outputs[name]
+            t = self._tim
+        
+        if name == "hu":
+            d = extracted_outputs['h'] * extracted_outputs['u']
+            t = self._tim
+
+        elif name == "hu2":
+            d = extracted_outputs['h'] * extracted_outputs['u'] * 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((available_outputs['h'][:, :, i] 
+        #                          * available_outputs['u'][:, :, i] 
+        #                          * available_outputs['u'][:, :, i])
+        #                         / 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 Lave2D."

tilupy/models/ravaflow/initsimus.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 26 11:03:56 2021
+
+@author: peruzzetto
+"""
+
+import os
+import numpy as np
+
+import tilupy.notations
+
+readme_param_match = dict(tmax='tmax',
+                          CFL='cflhyp',
+                          h_min='eps0',
+                          dt_im_output='dt_im')
+
+
+def readme_to_params(folder_data: str) -> dict:
+    """Read a README.txt file and convert it to a parameters dictionary.
+
+    Each line of the README file should contain a key and a value separated
+    by whitespace. The function parses the file and returns a dictionary
+    mapping keys to their corresponding string values.
+    
+    Parameters
+    ----------
+    folder_data : str
+        Path to the folder containing the README.txt file.
+
+    Returns
+    -------
+    dict
+        Dictionary where keys are parameter names (str) and values are
+        their corresponding values (str) read from the file.
+    """
+    params = dict()
+    with open(os.path.join(folder_data, 'README.txt'), 'r') as f:
+        for line in f:
+            (key, val) = line.split()
+            params[key] = val
+    return params
+
+
+def write_params(params: dict) -> str:
+    """Convert a parameters dictionary to a formatted string for RavaFlow input.
+
+    Generates a single string in the form "key1=val1 key2=val2 ...",
+    suitable for passing as command-line arguments to RavaFlow.
+
+    Parameters
+    ----------
+    params : dict
+        Dictionary of parameters, where keys and values are strings.
+
+    Returns
+    -------
+    str
+        Formatted string containing all parameters in "key=value" format,
+        separated by spaces.
+    """
+    txt = ''
+    for key in params:
+        txt += '{:s}={:s} '.format(key, params[key])
+    return txt[:-1]
+
+
+def make_simus(law: str, rheol_params: dict, folder_files: str, folder_out: str, readme_file: str) -> None:
+    """Write ravaflow initial file for simple slope test case
+
+    Reads simulation parameters from a README file and input
+    ASCII rasters, sets topography and mass, prepares numerical and rheological
+    parameters, and generates a shell script to execute simulations. Supports
+    multiple combinations of rheology parameters.
+    
+    Parameters
+    ----------
+    law : str
+        Rheological law to use, e.g., "coulomb" or "voellmy".
+    rheol_params : dict of list
+        Dictionary of rheology parameters, each key maps to a list of values
+        defining multiple simulation runs.
+    folder_files : str
+        Path to folder containing input ASCII files "topo.asc" and "mass.asc".
+    folder_out : str
+        Path to the folder where output simulation folders and run scripts
+        will be created.
+    readme_file : str
+        Path to the README.txt file containing simulation metadata and parameters.
+        
+    Returns
+    -------
+    None
+    """
+    # Parameters from README.txt file
+    params_readme = tilupy.notations.readme_to_params(readme_file)
+    # Parameters for simulation
+    params = dict()
+    # Directory where run script will be created
+    folder_law = os.path.join(folder_out, law)
+    os.makedirs(folder_law, exist_ok=True)
+
+    # Prepare simulation parameters
+
+    # Topography and initial mass
+    params['elevation'] = 'elev'
+    params['hrelease'] = 'minit'
+
+    # Control parameters
+    params["controls"] = '0,0,0,0,0,0'
+
+    # Thresholds parameters
+    # (min thicknees for output, min flow knetic energy for output,
+    # min flow pressure for output, min thickness in simulation)
+    h0 = np.float(params_readme['h_min'])
+    params["thresholds"] = "{:.2E},{:.2E},{:.2E},{:.2E}".format(h0, h0, h0, h0)
+
+    # CFL parameters
+    # (CFL condition, initial time step when CFL not applicable)
+    params['cfl'] = "{:.2E},0.0001".format(np.float(params_readme['CFL']))
+
+    # Output time parameters
+    params['time'] = "{:.3f},{:.2f}".format(np.float(params_readme['dt_im_output']),
+                                            np.float(params_readme['tmax']))
+
+    # Simulation phases
+    params['phases'] = 's'
+
+    # Write bash run file
+    file_txt = ""
+    file_path = os.path.join(folder_law, 'run.avaflow.sh')
+
+    # Set region
+    grid_params = dict()
+    with open(os.path.join(folder_files, 'topo.asc'), 'r') as fid:
+        for i in range(6):
+            tmp = fid.readline().split()
+            grid_params[tmp[0]] = float(tmp[1])
+    e = grid_params['cellsize']*grid_params['ncols']
+    n = grid_params['cellsize']*grid_params['nrows']
+    tmp = 'g.region s=0 w=0 e={:.2f} n={:.2f} res={:.4f}\n'
+    file_txt += tmp.format(e, n, grid_params['cellsize'])
+    file_txt += 'g.region -s\n\n'
+
+    # Read ascii files for mass and topography
+    # Get relative path to topo and mass file, from the fodler
+    # where simulations will be run. Find position of folder_files in
+    # folder_out path. Simulations are run in folder_out/law/
+    path = os.path.normpath(folder_out)
+    ffs = path.split(os.sep)
+    _, folder_topo = os.path.split(folder_files)
+    n_up = len(ffs) - ffs.index(folder_topo)
+    path_up = '../'*n_up
+    zfile = path_up + 'topo.asc'
+    mfile = path_up + 'mass.asc'
+    file_txt += 'r.in.gdal --overwrite input={:s} output=elev\n'.format(zfile)
+    file_txt += 'r.in.gdal --overwrite input={:s} output=minit\n'.format(mfile)
+
+    # prefix for output folder
+    prefixs = tilupy.notations.make_rheol_string(rheol_params, law)
+
+    param_names = [param for param in rheol_params]
+
+    txt_friction = '{:.2f},{:.2f},{:.2f}'
+
+    for i in range(len(rheol_params[param_names[0]])):
+
+        simu_prefix = prefixs[i]
+        if law == 'coulomb':
+            delta1 = rheol_params['delta1'][i]
+            params['friction'] = txt_friction.format(delta1, delta1, 0)
+
+        if law == 'voellmy':
+            delta1 = rheol_params['delta1'][i]
+            ksi = rheol_params['ksi'][i]
+            params['friction'] = txt_friction.format(delta1, delta1,
+                                                     np.log10(ksi))
+
+        params['prefix'] = simu_prefix
+
+        file_txt += '\n'
+        file_txt += 'start_time=`date +%s`\n'
+        file_txt += 'r.avaflow -e ' + write_params(params) + '\n'
+        file_txt += 'end_time=`date +%s`\n'
+        file_txt += 'elapsed_time=$(($end_time - $start_time))\n'
+        file_txt += ('string_time="${start_time} ' +
+                     simu_prefix + ' ${elapsed_time}"\n')
+        file_txt += 'echo ${string_time} >> simulation_duration.txt\n\n'
+
+    with open(file_path, "w") as fid:
+        fid.write(file_txt)