tilupy 2.0.0__py3-none-any.whl

tilupy/calibration.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pandas as pd
+
+from tilupy import read
+from tilupy import utils
+from tilupy import raster
+
+
+def CSI(simu, observation=None, h_threshs=[1], state="h_final"):
+    res = []
+    assert observation is not None
+
+    if isinstance(observation, str):
+        _, _, observation, _ = raster.read_raster(observation)
+
+    if state == "h_max":
+        d = simu.h_max
+    else:
+        d = simu.get_output(state).d
+    for h_thresh in h_threshs:
+        array = 1 * d > h_thresh
+        res.append(utils.CSI(array, observation))
+
+    return h_threshs, res
+
+
+def diff_runout(
+    simu,
+    point=None,
+    h_threshs=[1],
+    section=None,
+    orientation="W-E",
+    state="h_max",
+    get_contour_kws=None,
+):
+    res = []
+    assert point is not None
+
+    if get_contour_kws is None:
+        get_contour_kws = dict()
+
+    if state == "h_max":
+        d = simu.h_max
+    else:
+        d = simu.get_output(state).d
+    xc, yc = utils.get_contour(simu.x, simu.y, d, h_threshs, **get_contour_kws)
+
+    for h in h_threshs:
+        res.append(
+            utils.diff_runout(
+                xc[h], yc[h], point, section=section, orientation=orientation
+            )
+        )
+
+    return h_threshs, res
+
+
+def eval_simus(
+    simus,
+    methods,
+    calib_parameters,
+    methods_kws,
+    code="shaltop",
+    recorded_params=["delta1"],
+    calib_parameter_name="h_threshs",
+):
+    """
+    Evaluate simulation results with different methods
+
+    Parameters
+    ----------
+    simus : TYPE
+        DESCRIPTION.
+    methods : TYPE
+        DESCRIPTION.
+
+    Returns
+    -------
+    None.
+
+    """
+    if not isinstance(methods, list):
+        methods = [methods]
+    if not isinstance(methods_kws, list):
+        methods_kws = [methods_kws]
+
+    if isinstance(simus, dict):
+        simus = pd.DataFrame(simus)
+    if isinstance(simus, pd.DataFrame):
+        simus_list = []
+        for i in range(simus.shape[0]):
+            simus_list.append(
+                read.get_results(code, **simus.iloc[i, :].to_dict())
+            )
+        simus2 = simus.copy()
+    else:
+        simus_list = simus
+        simus2 = pd.DataFrame()
+
+    for param in recorded_params:
+        simus2[param] = np.nan
+    fn = dict()
+    for method in methods:
+        fn[method] = globals()[method]
+        simus2[method] = np.nan
+    simus2[calib_parameter_name] = np.nan
+
+    ns = len(simus_list)
+    nc = len(calib_parameters)
+    nn = ns * nc
+
+    res = pd.DataFrame(columns=simus2.columns, index=np.arange(nn))
+
+    for i, simu in enumerate(simus_list):
+        # Initiate fields
+        istart = i * nc
+        iend = (i + 1) * nc
+        res.iloc[istart:iend, :] = simus2.loc[i, :].copy()
+        for j, method in enumerate(methods):
+            kws = methods_kws[j]
+            kws[calib_parameter_name] = calib_parameters
+            _, calib_res = fn[method](simu, **kws)
+            for param in recorded_params:
+                res.iloc[
+                    istart:iend, res.columns.get_loc(param)
+                ] = simu.params[param]
+            res.iloc[
+                istart:iend, res.columns.get_loc(calib_parameter_name)
+            ] = calib_parameters
+            res.iloc[istart:iend, res.columns.get_loc(method)] = calib_res
+
+    return res

tilupy/cmd.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+
+import tilupy.read
+# import tilupy.raster
+
+import os
+import argparse
+import glob
+
+
+def process_results(
+    fn_name,
+    model,
+    res_name,
+    folder=None,
+    param_files=None,
+    kwargs_read=None,
+    **kwargs_fn
+):
+    assert model is not None
+
+    if folder is None:
+        folder = os.getcwd()
+
+    if param_files is None:
+        param_files = "*.txt"
+
+    print(folder, param_files)
+
+    param_files = [
+        os.path.basename(x)
+        for x in glob.glob(os.path.join(folder, param_files))
+    ]
+
+    if len(param_files) == 0:
+        print("No parameter file matching param_files pattern was found")
+        return
+
+    if kwargs_read is None:
+        kwargs_read = dict()
+
+    kw_read = dict(folder=folder)
+    kw_read.update(kwargs_read)
+
+    for param_file in param_files:
+        print_str = "Processing simulation {:s}, {:s} {:s} ....."
+        print(print_str.format(param_file, fn_name, res_name))
+        kw_read["file_params"] = param_file
+        res = tilupy.read.get_results(model, **kw_read)
+        getattr(res, fn_name)(res_name, **kwargs_fn)
+
+
+def to_raster(
+    model=None,
+    res_name="h",
+    param_files=None,
+    folder=None,
+    kwargs_read=None,
+    **kwargs
+):
+    kw = dict(fmt="asc")
+    kw.update(kwargs)
+
+    process_results(
+        "save",
+        model,
+        res_name,
+        folder=folder,
+        param_files=param_files,
+        kwargs_read=kwargs_read,
+        **kw
+    )
+
+
+def plot_results(
+    model=None,
+    res_name="h",
+    param_files=None,
+    folder=None,
+    kwargs_read=None,
+    **kwargs
+):
+    kw = dict(save=True)
+    kw.update(kwargs)
+
+    process_results(
+        "plot",
+        model,
+        res_name,
+        folder=folder,
+        param_files=param_files,
+        kwargs_read=kwargs_read,
+        **kwargs
+    )
+
+
+def _get_parser(prog, description):
+    parser = argparse.ArgumentParser(
+        prog=prog,
+        description=description,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("model", help="Model name", type=str)
+    parser.add_argument(
+        "-n",
+        "--res_name",
+        help="Name of output, only for maps",
+        default="h",
+        type=str,
+    )
+    parser.add_argument(
+        "-p",
+        "--param_files",
+        help="Parameter file (globbing)",
+        default="*.txt",
+        type=str,
+    )
+    parser.add_argument(
+        "-f",
+        "--folder",
+        help="Root folder, default is current folder",
+        default=None,
+        type=str,
+    )
+    return parser
+
+
+def _tilupy_plot():
+    parser = _get_parser("tilupy_plot", "Plot thin-layer simulation results")
+    parser.add_argument(
+        "--fmt",
+        help=("Plot output format " "(any accepted by matplotlib.savefig)"),
+        default="png",
+        type=str,
+    )
+    parser.add_argument(
+        "--vmin",
+        help=("Minimum plotted value, " "adapted to data by default"),
+        default=None,
+        type=float,
+    )
+    parser.add_argument(
+        "--vmax",
+        help=("Maximum plotted value, " "adapted to data by default"),
+        default=None,
+        type=float,
+    )
+    parser.add_argument(
+        "--minval_abs",
+        help=("Minimum plotted absolute value," " adapted to data by default"),
+        default=None,
+        type=float,
+    )
+    args = parser.parse_args()
+    plot_results(**vars(args))
+
+
+def _tilupy_to_raster():
+    parser = _get_parser(
+        "tilupy_to_raster", "Convert simulation results to rasters"
+    )
+    parser.add_argument(
+        "--fmt",
+        help=("File output format, " "tif/tiff requires rasterio"),
+        default="asc",
+        type=str,
+        choices=["tif", "tiff", "txt", "asc", "ascii"],
+    )
+    args = parser.parse_args()
+    # plot_results(parser.model, parser.res_name)
+    to_raster(**vars(args))
+
+
+if __name__ == "__main__":
+    # folder = 'd:/Documents/peruzzetto/tmp/test_shaltop/7p30e04_m3/coulomb'
+    # plot_results('shaltop', 'h_max', '*18p00.txt', folder=folder)
+    _tilupy_plot()

tilupy/compare.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jun  2 17:57:31 2021
+
+@author: peruzzetto
+"""
+
+import importlib
+import os
+import string
+import numpy as np
+import matplotlib.pyplot as plt
+import mpl_toolkits.axes_grid1 as mplt
+
+# import tilupy.dem
+import tilupy.plot as plt_fn
+import tilupy.notations
+import tilupy
+
+from tilupy.notations import LABELS
+from tilupy.read import STATIC_DATA_2D
+
+
+def compare_spatial_results(results, name, stat, import_kwargs=None,
+                            x=None, y=None, zinit=None,
+                            nrows_ncols=None, figsize=None,
+                            folder_out=None, file_prefix=None,
+                            fmt='png', dpi=150,
+                            cbar_location='bottom', cbar_size="5%",
+                            cmap_intervals=None, cmap='inferno',
+                            topo_kwargs=None,
+                            title_loc='top right', title_x_offset=0.02,
+                            title_y_offset=0.02):
+    """
+    Compare spatiale results of different simulations
+
+    Parameters
+    ----------
+    results : TYPE
+        DESCRIPTION.
+    name : TYPE
+        DESCRIPTION.
+    import_kwargs : TYPE, optional
+        DESCRIPTION. The default is None.
+    x : TYPE, optional
+        DESCRIPTION. The default is None.
+    y : TYPE, optional
+        DESCRIPTION. The default is None.
+    zinit : TYPE, optional
+        DESCRIPTION. The default is None.
+    figsize : TYPE, optional
+        DESCRIPTION. The default is None.
+    folder_out : TYPE, optional
+        DESCRIPTION. The default is None.
+    cbar_location : TYPE, optional
+        DESCRIPTION. The default is 'bottom'.
+    cbar_size : TYPE, optional
+        DESCRIPTION. The default is "5%".
+    cmap_intervals : TYPE, optional
+        DESCRIPTION. The default is None.
+    cmap : TYPE, optional
+        DESCRIPTION. The default is 'inferno'.
+    topo_kwargs : TYPE, optional
+        DESCRIPTION. The default is None.
+
+    Returns
+    -------
+    None.
+
+    """
+    if x is None or y is None:
+        results[0].set_axes()
+        x = results[0].x
+        y = results[0].y
+
+    if zinit is None:
+        results[0].set_zinit()
+        zinit = results[0].zinit
+
+    topo_kwargs = {} if topo_kwargs is None else topo_kwargs
+    import_kwargs = {} if import_kwargs is None else import_kwargs
+    nplots = len(results)
+    if nrows_ncols is None:
+        nrows_ncols = (1, nplots)
+
+    fig = plt.figure(figsize=figsize)
+    axes = mplt.AxesGrid(fig, 111,
+                         nrows_ncols=nrows_ncols,
+                         axes_pad=0.1,
+                         share_all=True,
+                         aspect='True',
+                         label_mode='L',
+                         cbar_location=cbar_location,
+                         cbar_mode="single",
+                         cbar_pad="12%",
+                         cbar_size=cbar_size)
+
+    # Titles
+    alignments = title_loc.split(' ')
+    ha = alignments[1]
+    va = alignments[0]
+    if va == 'top':
+        xt = 1-title_x_offset
+    elif va == 'center':
+        xt = 0.5
+    elif va == 'bottom':
+        xt = title_x_offset
+    if ha == 'right':
+        yt = 1-title_y_offset
+    elif ha == 'center':
+        yt = 0.5
+    elif ha == 'bottom':
+        yt = title_y_offset
+
+    for i, result in enumerate(results):
+        data = result.get_static_output(name, stat, **import_kwargs)
+        plt_fn.plot_data_on_topo(x, y, zinit, data.d,
+                                 axe=axes[i],
+                                 plot_colorbar=False,
+                                 colorbar_kwargs={'extend': 'max'},
+                                 cmap_intervals=cmap_intervals,
+                                 cmap=cmap,
+                                 topo_kwargs=topo_kwargs)
+        letter = '({:s})'.format(string.ascii_lowercase[i])
+        axes[i].text(xt, yt, '{:s} {:s}'.format(letter, result.code),
+                     ha=ha, va=va,
+                     fontsize=11, zorder=100,
+                     bbox=dict(boxstyle="round",
+                               fc="w", ec="k", pad=0.2),
+                     transform=axes[i].transAxes)
+        axes[i].grid(False)
+
+    # Colorbar
+    axe_cc = axes.cbar_axes[0]
+    if cbar_location in ['right', 'left']:
+        orientation = 'vertical'
+    else:
+        orientation = 'horizontal'
+    fig.colorbar(axes[0].images[-1],
+                 cax=axe_cc,
+                 ax=axes[0],
+                 orientation=orientation,
+                 extend='max')
+    if orientation == 'vertical':
+        axe_cc.set_ylabel(LABELS[name+stat])
+    else:
+        axe_cc.set_xlabel(LABELS[name+stat])
+
+    fig.tight_layout()
+
+    if folder_out is not None:
+        if file_prefix is None:
+            file = name + stat + '.' + fmt
+        else:
+            file = file_prefix + '_' + name + stat + '.' + fmt
+        fig.savefig(os.path.join(folder_out, file),
+                    dpi=dpi)
+
+
+def compare_simus(codes, topo_name, law,
+                  rheol_params, output_name, stat_name,
+                  subfolder_topo='',
+                  folder_benchmark=None, folder_out=None, **kwargs):
+    """Compare simulations with different codes."""
+
+    modules = dict()
+    for c in codes:
+        modules[c] = importlib.import_module('tilupy.models.'+c+'.read')
+
+    if folder_benchmark is None:
+        folder_benchmark = os.getcwd()
+
+    folder_topo = os.path.join(folder_benchmark, topo_name)
+
+    txt_params = tilupy.notations.make_rheol_string(rheol_params, law)
+
+    if folder_out is None:
+        folder_out = os.path.join(folder_topo, subfolder_topo,
+                                  'comparison', law)
+        os.makedirs(folder_out, exist_ok=True)
+
+    file = np.os.path.join(folder_topo, 'topo.asc')
+    x, y, zinit, dx = tilupy.dem.read_ascii(file)
+
+    simus = []
+    for code in codes:
+        folder_simus = os.path.join(folder_topo, subfolder_topo, code, law)
+        simus.append(modules[code].Results(txt_params, folder_simus))
+
+    if output_name+stat_name in STATIC_DATA_2D:
+        compare_spatial_results(simus, output_name, stat_name,
+                                x=x, y=y, zinit=zinit,
+                                folder_out=folder_out, file_prefix=txt_params,
+                                **kwargs)

tilupy/download_data.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+
+import requests
+import os
+
+def import_frankslide_dem(folder_out: str = None, 
+                          file_out: str = None
+                          ) -> str:
+    """Import frankslide topography.
+
+    Parameters
+    ----------
+    folder_out : str, optional
+        Path to the folder output. If None the current folder will be choosed. By default None.
+    file_out : str, optional
+        Name of the file. If None choose "Frankslide_topography.asc". By default None.
+
+    Returns
+    -------
+    str
+        Path to the saved file.
+    """
+    if folder_out is None:
+        folder_out = '.'
+    if file_out is None:
+        file_out = 'Frankslide_topography.asc'
+    
+    file_save = os.path.join(folder_out, file_out)
+    
+    url = ('https://raw.githubusercontent.com/marcperuz/tilupy/main/data/'+
+           'frankslide/rasters/Frankslide_topography.asc')
+    r = requests.get(url)
+    open(file_save, 'w').write(r.text)
+    
+    return file_save
+
+
+def import_frankslide_pile(folder_out: str = None, 
+                           file_out: str = None
+                           ) -> str:
+    """Import frankslide pile.
+
+    Parameters
+    ----------
+    folder_out : str, optional
+        Path to the folder output. If None the current folder will be choosed. By default None.
+    file_out : str, optional
+        Name of the file. If None choose "Frankslide_pile.asc". By default None.
+
+    Returns
+    -------
+    str
+        Path to the saved file.
+    """
+    
+    if folder_out is None:
+        folder_out = '.'
+    if file_out is None:
+        file_out = 'Frankslide_pile.asc'
+    
+    file_save = os.path.join(folder_out, file_out)
+    
+    url = ('https://raw.githubusercontent.com/marcperuz/tilupy/main/data/'+
+           'frankslide/rasters/Frankslide_pile.asc')
+    r = requests.get(url)
+    open(file_save, 'w').write(r.text)
+    
+    return file_save