tilupy 0.1.4__tar.gz → 1.0.0__tar.gz

{tilupy-0.1.4/src/tilupy.egg-info → tilupy-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tilupy
-Version: 0.1.4
+Version: 1.0.0
 Summary: Thin-layer models unified processing tool
 Author-email: Marc Peruzzetto <m.peruzzetto@brgm.fr>
 License: CeCILL-C FREE SOFTWARE LICENSE AGREEMENT
@@ -526,10 +526,17 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: seaborn
+Requires-Dist: requests
+Requires-Dist: scipy
 Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
 Provides-Extra: dev
+Requires-Dist: pipreqs; extra == "dev"
 Provides-Extra: gis
-License-File: LICENSE
+Requires-Dist: rasterio; extra == "gis"
+Requires-Dist: shapely; extra == "gis"
 
 # tilupy
 
@@ -553,7 +560,7 @@ It contains one submodule per thin-layer model for writing and reading raw input
 Outputs are then easily compared between different simulations / models. The models themselves are not part of this package and must
 be installed separately.
 
-Note that `tilupy` is still under development, thus only minimal documentation is available at the moment and testing is underway.
+Note that `tilupy` is still under development, thus only minimal documentation is available at the moment, and testing is underway.
 Contributions are feedback are most welcome. Reading and writing is available for the `SHALTOP` model (most commonly used by the author) and `r.avaflow`
 (only partly maintained).
 

{tilupy-0.1.4 → tilupy-1.0.0}/README.md

@@ -20,7 +20,7 @@ It contains one submodule per thin-layer model for writing and reading raw input
 Outputs are then easily compared between different simulations / models. The models themselves are not part of this package and must
 be installed separately.
 
-Note that `tilupy` is still under development, thus only minimal documentation is available at the moment and testing is underway.
+Note that `tilupy` is still under development, thus only minimal documentation is available at the moment, and testing is underway.
 Contributions are feedback are most welcome. Reading and writing is available for the `SHALTOP` model (most commonly used by the author) and `r.avaflow`
 (only partly maintained).
 

{tilupy-0.1.4 → tilupy-1.0.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilupy"
-version = "0.1.4"
+version = "v1.0.0"
 description = "Thin-layer models unified processing tool"
 readme = "README.md"
 authors = [{ name = "Marc Peruzzetto", email = "m.peruzzetto@brgm.fr" }]
@@ -18,7 +18,7 @@ classifiers = [
 ]
 keywords = ["thin-layer", "shallow-water", "display", "simulation", "model", "processing", "benchmark"]
 dependencies = [
-    "seaborn", "requests",
+    "seaborn", "requests", "scipy"
 ]
 requires-python = ">=3.8"
 

{tilupy-0.1.4 → tilupy-1.0.0}/src/tilupy/calibration.py

@@ -10,51 +10,54 @@ import pandas as pd
 
 from tilupy import read
 from tilupy import utils
-from tilupy import dem
+from tilupy import raster
+
 
 def CSI(simu, observation=None, h_threshs=[1], state='h_final'):
-    
-    res=[]
+
+    res = []
     assert(observation is not None)
-    
+
     if isinstance(observation, str):
-        _, _, observation, _ = dem.read_raster(observation)
-        
+        _, _, observation, _ = raster.read_raster(observation)
+
     strs = state.split('_')
     if state == 'h_max':
         d = simu.h_max
     else:
         d = simu.get_static_output(strs[0], strs[1]).d
     for h_thresh in h_threshs:
-        array = 1*d>h_thresh
+        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
+        d = simu.h_max
     else:
         strs = state.split('_')
         d = simu.get_static_output(strs[0], strs[1]).d
-    xc, yc = utils.get_contour(simu.x,simu.y,d,h_threshs, **get_contour_kws)
-    
+    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'],
@@ -80,16 +83,17 @@ def eval_simus(simus, methods, calib_parameters, methods_kws,
         methods_kws = [methods_kws]
 
     if isinstance(simus, dict):
-        simus=pd.DataFrame(simus)
+        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()))
+            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()
@@ -97,13 +101,13 @@ def eval_simus(simus, methods, calib_parameters, methods_kws,
         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))    
-        
+
+    res = pd.DataFrame(columns=simus2.columns, index=np.arange(nn))
+
     for i, simu in enumerate(simus_list):
         # Initiate fields
         istart = i*nc
@@ -117,12 +121,5 @@ def eval_simus(simus, methods, calib_parameters, methods_kws,
                 res.loc[:, param].iloc[istart:iend] = simu.params[param]
             res.loc[:, calib_parameter_name].iloc[istart:iend] = calib_parameters
             res.loc[:, method].iloc[istart:iend] = calib_res
-            
-    return res
 
-
-            
-    
-    
-        
-    
+    return res

tilupy-1.0.0/src/tilupy/cmd.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jun 14 18:16:45 2023
+
+@author: peruzzetto
+"""
+
+import tilupy.raster
+import tilupy.read
+
+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 = 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_base=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-0.1.4 → tilupy-1.0.0}/src/tilupy/initdata.py

@@ -8,6 +8,10 @@ Created on Fri May 21 12:10:46 2021
 import os
 import numpy as np
 
+import tilupy.make_topo
+import tilupy.make_mass
+import tilupy.plot
+
 
 def make_constant_slope(folder_out, theta=10, m_radius=50, m_height=50,
                         m_x=None, m_y=None,
@@ -43,3 +47,35 @@ def make_constant_slope(folder_out, theta=10, m_radius=50, m_height=50,
         np.savetxt(os.path.join(folder_out, name+'.asc'), a,
                    header=header_txt,
                    comments='')
+
+
+def gray99_topo_mass(dx=0.1, dy=0.1, save=False, folder_out=None):
+
+    # Initiate topography
+    X, Y, Z = tilupy.make_topo.gray99(dx=dx, dy=dy)
+
+    # Initiate initial mass. It is a spherical calotte above the topography,
+    # in Gray et al 99 (p. 1859) the resulting mass has a height of 0.22 m and a radius
+    # of 0.32 m (more precisely it is the length in the downslope direction)
+    # The correspondig radius of the sphere, and the offset from the topography
+    # in the topography normal direction (norm_offset) are deduced from these
+    # parameters
+
+    x0 = 0.06*np.cos(np.deg2rad(40))
+    hmass = 0.22
+    wmass = 0.32
+    radius = (wmass**2+hmass**2)/(2*hmass)
+    norm_offset = (hmass**2-wmass**2)/(2*hmass)
+    # Z = -np.tile(X, [len(Y), 1])*np.tan(np.deg2rad(20))
+    M = tilupy.make_mass.calotte(X, Y, Z, x0, 0,
+                                 radius, norm_offset=norm_offset,
+                                 res_type='true_normal')
+
+    return X, Y, Z, M
+
+
+if __name__ == '__main__':
+
+    x, y, z, m = gray99_topo_mass(dx=0.01, dy=0.01)
+    tilupy.plot.plot_data_on_topo(x, y, z, m,
+                                  topo_kwargs=dict(level_min=0.1))

tilupy-1.0.0/src/tilupy/make_mass.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug  4 19:27:09 2023
+
+@author: peruzzetto
+"""
+
+import numpy as np
+
+
+def calotte(x, y, z, x0, y0, radius, norm_offset=0, res_type='projected_normal'):
+    """
+    Construct mass on topography as volume between sphere and topography.
+
+    Parameters
+    ----------
+    x : np.array
+        xaxis array, with length nx
+    y : np.array
+        yaxis array, with length ny
+    z : np.array
+        array of altitudes, of size (ny, nx). z[0, 0] has coordinates
+        (x[0], y[-1])
+    x0 : float
+        x position of the calotte
+    y0 : float
+        y position of the calotte
+    radius : float
+        radius of the shpere
+    norm_offset : float, optional
+        downwards offset between the sphere center and the topography, in the
+        direction normal to the topography. The default is 0.
+    res_type : string, optional
+        Type of thickness output. 'true_normal': real thickness in the
+        direction normal to the topography. 'vertical': Thickness in the
+        vertical direction. 'projected_normal': Thickness normal to the
+        topography is computed from the vertical thickness projected on 
+        the axe normal to the topography. The default is 'projected_normal'.
+
+    Returns
+    -------
+    m : np.array
+        array of mass height, in the direction normal to topography
+
+    """
+    z = np.flip(z, axis=0).T
+
+    xmesh, ymesh = np.meshgrid(x, y, indexing='ij')
+    nx = len(x)
+    ny = len(y)
+
+    # Get altitude of mass center on topography
+    i0 = np.unravel_index(np.argmin(np.abs(x-x0), axis=None), (nx,))
+    j0 = np.unravel_index(np.argmin(np.abs(y-y0), axis=None), (ny,))
+    z0 = z[i0, j0]
+    # Topography gradient
+    [Fx, Fy] = np.gradient(z, x, y, edge_order=2)
+    Fz = np.ones((nx, ny))
+    c = 1/np.sqrt(1+Fx**2+Fy**2)
+    Fx = -Fx*c
+    Fy = -Fy*c
+    Fz = Fz*c
+    # Correct position from offset (shpere is moved downward,
+    # perpendicular to topography)
+    x0 = x0-norm_offset*Fx[i0, j0]
+    y0 = y0-norm_offset*Fy[i0, j0]
+    z0 = z0-norm_offset*Fz[i0, j0]
+
+    # Compute mass height only where relevant (ie around the mass center)
+    dist_to_mass = (xmesh-x0)**2+(ymesh-y0)**2
+    ind = (dist_to_mass <= radius**2)
+
+    B = 2*(Fx*(xmesh-x0)+Fy *
+           (ymesh-y0)+Fz*(z-z0))
+    C = (xmesh-x0)**2+(ymesh-y0)**2+(z-z0)**2-radius**2
+    D = B**2-4*C
+
+    # Intersection between shpere and normal to the topography, solution of
+    # t**2+B*t+C=0
+    m = np.zeros((nx, ny))
+
+    if res_type == 'true_normal':
+        # B = 2*(Fx[ind]*(xmesh[ind]-x0)+Fy[ind] *
+        #        (ymesh[ind]-y0)+Fz[ind]*(z[ind]-z0))
+        # C = (xmesh[ind]-x0)**2+(ymesh[ind]-y0)**2+(z[ind]-z0)**2-radius**2
+        # D = B**2-4*C
+        B = 2*(Fx*(xmesh-x0)+Fy *
+               (ymesh-y0)+Fz*(z-z0))
+        C = (xmesh-x0)**2+(ymesh-y0)**2+(z-z0)**2-radius**2
+        D = B**2-4*C
+        ind = D > 0
+        t1 = (-B-np.sqrt(D))/2
+        t2 = (-B+np.sqrt(D))/2
+        ind2 = t1*t2 < 0
+        m[ind2] = np.maximum(t1[ind2], t2[ind2])
+
+    # Vertical thickness of calotte.
+    if res_type in ['vertical', 'projected_normal']:
+        zs = z0 + np.sqrt(radius**2 - (xmesh - x0)**2 - (ymesh - y0)**2)
+        zi = z0 - np.sqrt(radius**2 - (xmesh - x0)**2 - (ymesh - y0)**2)
+        ind = (z < zs) & (z > zi)
+        m[ind] = zs[ind] - z[ind]
+        if res_type == 'projected_normal':
+            m = m * c
+
+    m = np.flip(m.T, axis=0)
+
+    return m