tilupy 0.1.3__tar.gz → 0.1.5__tar.gz

{tilupy-0.1.3/src/tilupy.egg-info → tilupy-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tilupy
-Version: 0.1.3
+Version: 0.1.5
 Summary: Thin-layer models unified processing tool
 Author-email: Marc Peruzzetto <m.peruzzetto@brgm.fr>
 License: CeCILL-C FREE SOFTWARE LICENSE AGREEMENT
@@ -524,12 +524,19 @@ Keywords: thin-layer,shallow-water,display,simulation,model,processing,benchmark
 Classifier: License :: CeCILL-C Free Software License Agreement (CECILL-C)
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
+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.3 → tilupy-0.1.5}/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.3 → tilupy-0.1.5}/pyproject.toml

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

{tilupy-0.1.3 → tilupy-0.1.5}/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-0.1.3 → tilupy-0.1.5}/src/tilupy/cmd.py

@@ -11,60 +11,63 @@ 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(param_files, root_dir=folder)
-    
+
+    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 = 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, 
+
+
+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, 
+
+
+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,
@@ -80,6 +83,7 @@ def _get_parser(prog, description):
                         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 "
@@ -100,7 +104,8 @@ def _tilupy_plot():
                         )
     args = parser.parse_args()
     plot_results(**vars(args))
-    
+
+
 def _tilupy_to_raster():
     parser = _get_parser('tilupy_to_raster',
                          'Convert simulation results to rasters')
@@ -111,11 +116,10 @@ def _tilupy_to_raster():
     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.3 → tilupy-0.1.5}/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-0.1.5/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

tilupy-0.1.5/src/tilupy/make_topo.py

@@ -0,0 +1,415 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug  4 12:09:41 2023
+
+@author: peruzzetto
+"""
+
+import numpy as np
+import scipy
+
+import tilupy.plot
+
+
+def gray99(nx=None, ny=None, xmin=-0.4, x1=1.75, x2=2.15,
+           xmax=3.2, ymax=0.5, R=1.1,
+           theta1=40, theta2=0, maxz=None, dx=0.01, dy=0.01, plot=False):
+    """
+    Construct channel as in Gray et all 99.
+
+    Input coordinates are in curvilinear coordinates along the reference
+    topography following the channel bottom. Output coordinates are in the
+    fixed cartesian frame.
+    Parameters
+    ----------
+    nx : int
+        Size of the grid in x direction
+    ny : int
+        Size of the y direction
+    dx : float, optional
+        Cell size of the x axis. if specified, nx is recomputed. Default: 0.01
+    dy : float, optional
+        Cell size of the y axis. if specified, ny is recomputed. Default: 0.01
+    xmin : float, optional
+        Minimum x coordinate. The default is -0.4.
+    x1 : float, optional
+        Min coordinate of the channel outlet (transition zone).
+        The default is 1.75.
+    x2 : float, optional
+        Max coordinate of the channel outlet (transition zone).
+        The default is 2.15.
+    xmax : float, optional
+        Maximum x coordinate. The default is 3.2.
+    ymax : float, optional
+        Maximum y coordinate the final yxais spans from -ymax to xmax.
+        The default is 0.5.
+    R : float, optional
+        Radius of curvature of the channel. The default is 1.1.
+    theta1 : float, optional
+        Slope of the channel in degree. The default is 40.
+    theta2 : float, optional
+        Slope after the channel. The default is 0.
+    maxz : float, optional
+        Maximum z coordinate. The default is None.
+    plot : boolean, optional
+        Plot result. The default is False.
+
+
+    Returns
+    -------
+    Xout : float nx*ny array
+        Mesh of X coordinates in the cartesian frame
+    Yout : float nx*ny array
+        Mesh of Y coordinates in the cartesian frame.
+    Zout : float nx*ny array
+        Mesh of Z coordinates in the cartesian frame.
+
+    """
+    theta1 = np.deg2rad(theta1)
+    theta2 = np.deg2rad(theta2)
+
+    if nx is None:
+        x = np.arange(xmin, xmax+dx/2, dx)
+        nx = len(x)
+    else:
+        x = np.linspace(xmin, xmax, nx)
+
+    if ny is None:
+        y = np.arange(-ymax, ymax+dy/2, dy)
+        ny = len(y)
+    else:
+        y = np.linspace(-ymax, ymax, ny)
+
+    ycurv = np.tile(y.reshape((1, ny)), (nx, 1))
+
+    # Superficial topography : channel
+    # alpha=1/(2*R)*np.sin(0.5*np.pi*(x-x2)/(x1-x2))**2
+    # alpha=1/(2*R)*np.abs(x-x2)**1/np.abs(x1-x2)**1
+    alpha = 1/(2*R)*(3*((x-x2)/(x1-x2))**2-2*((x-x2)/(x1-x2))**3)
+    alpha[x > x2] = 0
+    alpha[x < x1] = 1/(2*R)
+    alpha = np.tile(alpha.reshape((nx, 1)), (1, ny))
+
+    zchannel = alpha*np.abs(ycurv)**2
+    # plt.figure()
+    # plt.imshow(zchannel)
+
+    # del alpha
+
+    if not maxz:
+        maxz = R/2
+
+    zchannel[zchannel > maxz] = maxz
+
+    # Base topography in curvilinear system.
+    # The transition zone between x1 and x2 is a cylindre
+    zbase = -np.sin(theta2)*(x-xmax)
+
+    ind = (x <= x2) & (x >= x1)
+    angle = (x[ind]-x1)/(x2-x1)*(theta2-theta1)+theta1
+    R2 = (x2-x1)/(theta1-theta2)
+    z2 = -np.sin(theta2)*(x2-xmax)
+    zbase[ind] = R2*(1-np.cos(angle))-R2*(1-np.cos(theta2))+z2
+
+    ind = x <= x1
+    z1 = R2*(1-np.cos(theta1))-R2*(1-np.cos(theta2))+z2
+    zbase[ind] = -np.sin(theta1)*(x[ind]-x1)+z1
+    zbase = np.tile(zbase.reshape((nx, 1)), (1, ny))
+
+    # Conversion in fixed cartesian frame
+    zd = np.gradient(zbase, x[1]-x[0], edge_order=2, axis=0)
+    Xd = np.sqrt(1-zd**2)
+    X = scipy.integrate.cumtrapz(Xd, x, axis=0, initial=0)
+    X = X+xmin*np.cos(theta1)
+
+    # plt.figure()
+    # plt.plot(X[:,0])
+
+    del Xd
+
+    # Topography conversion in fixed cartesian frame
+    [Fx, Fy] = np.gradient(zbase, X[:, 0], ycurv[0, :], edge_order=2)
+    Fz = np.ones(zbase.shape)
+    costh = 1/np.sqrt(Fx**2+Fy**2+1)  # Slope angle
+    Fx = -Fx*costh
+    Fy = -Fy*costh
+    Fz = Fz*costh
+    Z = zbase+zchannel*Fz
+    Xmesh = X+zchannel*Fx
+    Ymesh = ycurv+zchannel*Fy
+
+    # Reconstruction of regular cartesian mesh
+    Xout = np.linspace(Xmesh.min(), Xmesh.max(), nx)
+    Xout = np.tile(Xout.reshape((nx, 1)), (1, ny))
+    Yout = np.linspace(Ymesh.min(), Ymesh.max(), ny)
+    Yout = np.tile(Yout.reshape((1, ny)), (nx, 1))
+    Zout = scipy.interpolate.griddata((Xmesh.reshape(nx*ny),
+                                       Ymesh.reshape(nx*ny)),
+                                      Z.reshape(nx*ny),
+                                      (Xout, Yout), method='cubic')
+    Ztmp = scipy.interpolate.griddata((Xmesh.reshape(nx*ny),
+                                       Ymesh.reshape(nx*ny)),
+                                      Z.reshape(nx*ny),
+                                      (Xout, Yout), method='nearest')
+    ind = np.isnan(Zout)
+    Zout[ind] = Ztmp[ind]
+
+    del Ztmp
+    # fz=scipy.interpolate.Rbf(Xmesh,Ymesh,Z)
+    # Zout=fz(Xout,Yout)
+
+    if plot:
+        if theta2 == 0:
+            blod, thin = tilupy.plot.get_contour_intervals(np.nanmin(Zout),
+                                                           np.nanmax(Zout))
+            level_min = thin
+        else:
+            level_min = None
+        tilupy.plot.plot_topo(Zout.T, Xout[:, 1], Yout[1, :],
+                              level_min=level_min)
+
+    return Xout[:, 1], Yout[1, :], Zout.T
+
+
+def channel(nx=None, ny=None, dx=None, dy=None,
+            xmin=-0.4, xmax=3.6, ymax=0.5, xstart_channel=0.65, xend_channel=2.3,
+            xstart_trans=0.4, xend_trans=2.75,
+            R=1.1, bend=0.2, nbends=1,
+            theta_start=40, theta_channel=40, theta_end=0,
+            plot=False, maxh=None, interp_method='linear'):
+    """
+    Generate channel with potential multiple bends. Input coordinates are 
+    curvilinear along the flattened topography.
+
+    Parameters
+    ----------
+    nx : int
+        Size of the grid in x direction
+    ny : int
+        Size of the y direction
+    dx : float, optional
+        Cell size of the x axis. if specified, nx is recomputed. Default: 0.01
+    dy : float, optional
+        Cell size of the y axis. if specified, ny is recomputed. Default: 0.01
+    xmin : float, optional
+        Minimum x coordinate. The default is -0.4.
+    xmax : float, optional
+        Maximum x coordinate. The default is 3.2.
+    ymax : float, optional
+        Maximum y coordinate the final yxais spans from -ymax to xmax.
+        The default is 0.5.
+    xstart_channel : float, optional
+        Start of the channel. The default is 0.65.
+    xend_channel : float, optional
+        end of the channel. The default is 2.3.
+    xstart_trans : TYPE, optional
+        start of the transition zone before the channel start.
+        The default is 0.4.
+    xend_trans : TYPE, optional
+        End of the transition zone after the channel end. The default is 2.75.
+    R : float, optional
+        Radius of curvature of the channel. The default is 1.1.
+    bend : float, optional
+        Width of the channel bend. The default is 0.2.
+    nbends : ind, optional
+        Number of bends. The default is 1.
+    theta_start : float, optional
+        Slope before the channel. The default is 40.
+    theta_channel : float, optional
+        Slope of the channel. The default is 40.
+    theta_end : float, optional
+        Slope after the channel. The default is 0.
+    plot : bool, optional
+        Plot generated topography. The default is False.
+    maxh : float, optional
+        Depth of the channel. The default is None.
+    interp_method : string, optional
+        Interpolation method for converting the topography from curvilinear
+        coordinates to cartesian coordinates. The default is 'linear'.
+
+    Returns
+    -------
+    TYPE
+        DESCRIPTION.
+
+    """
+
+    theta_start = np.deg2rad(theta_start)
+    theta_channel = np.deg2rad(theta_channel)
+    theta_end = np.deg2rad(theta_end)
+
+    if ny is None and dy is None:
+        dy = ymax/100
+
+    if nx is None and dx is None:
+        if dy is not None:
+            dx = dy
+        else:
+            raise ValueError('nx or dx must be specified as input')
+
+    # x and y coordinates in the flattened topography
+    if nx is None:
+        xtopo = np.arange(xmin, xmax+dx/2, dx)
+        nx = len(xtopo)
+    else:
+        xtopo = np.linspace(xmin, xmax, nx)
+
+    if ny is None:
+        ytopo = np.arange(-ymax, ymax+dy/2, dy)
+        ny = len(ytopo)
+    else:
+        ytopo = np.linspace(-ymax, ymax, ny)
+
+    xtopo = np.tile(xtopo[:, np.newaxis], (1, ny))
+    ytopo = np.tile(ytopo[np.newaxis, :], (nx, 1))
+
+    # Height above flattened topography is a channel
+    # in alpha(x)*(y-thalweg(x))**2,
+
+    # alpha(x) is 1/2R in the channel, and depends on a transition
+    # function in the transition zones
+    def trans_function(x, x1, x2):
+        xx = 3*((x-x2)/(x1-x2))**2-2*((x-x2)/(x1-x2))**3
+        return xx
+    alpha = np.zeros((nx, ny))
+    ind = (xtopo > xstart_channel) & (xtopo < xend_channel)
+    alpha[ind] = 1/(2*R)
+    ind = (xtopo > xstart_trans) & (xtopo <= xstart_channel)
+    alpha[ind] = 1/(2*R)*trans_function(xtopo[ind],
+                                        xstart_channel, xstart_trans)
+    ind = (xtopo > xend_channel) & (xtopo <= xend_trans)
+    alpha[ind] = 1/(2*R)*trans_function(xtopo[ind], xend_channel, xend_trans)
+
+    # the thalweg is centered on y=0 outside [xstart_channel,xend_channel]. Inbetween,
+    # it is given by a cos**2
+    def end_bend(x, x1, x2):
+        yy = (bend/2)*(1+np.cos(np.pi*(x-x2)/(x1-x2)))
+        return yy
+
+    def mid_bend(x, x1, x2):
+        yy = bend*np.cos(np.pi*(x-x1)/(x2-x1))
+        return yy
+    thalweg = np.zeros((nx, ny))
+
+    if nbends > 0:
+        step = (xend_channel-xstart_channel)/nbends
+
+        ind = (xtopo > xstart_channel) & (xtopo < xstart_channel+step/2)
+        thalweg[ind] = end_bend(
+            xtopo[ind], xstart_channel, xstart_channel+step/2)
+        ind = (xtopo >= xend_channel-step/2) & (xtopo < xend_channel)
+        thalweg[ind] = (-1)**(nbends+1)*end_bend(xtopo[ind],
+                                                 xend_channel, xend_channel-step/2)
+        if nbends > 1:
+            ind = (xtopo >= xstart_channel+step /
+                   2) & (xtopo < xend_channel-step/2)
+            thalweg[ind] = mid_bend(
+                xtopo[ind], xstart_channel+step/2, xstart_channel+(3/2)*step)
+
+    htopo = alpha*(ytopo-thalweg)**2
+
+    if not maxh:
+        maxh = R/2
+
+    htopo[htopo > maxh] = maxh
+
+    # Reconstruction of bz the basal topography. The real topo is given by
+    # bz+\vec{n}*htopo. Slopes of bz are given by theta_* outside the transition
+    # zones. We use a cylinder shape inbetween. This is done by computing the slope
+    # angle of bz, and using then -sin(slope_angle)=d(bz)/d(xtopo)
+
+    slope_angle = np.zeros((nx, ny))
+    ind = xtopo < xstart_trans
+    slope_angle[ind] = theta_start
+    ind = xtopo >= xend_trans
+    slope_angle[ind] = theta_end
+    ind = (xtopo >= xstart_channel) & (xtopo < xend_channel)
+    slope_angle[ind] = theta_channel
+
+    ind = (xtopo >= xstart_trans) & (xtopo < xstart_channel)
+    slope_angle[ind] = (xtopo[ind]-xstart_trans)/(xstart_channel -
+                                                  xstart_trans)
+    slope_angle[ind] = slope_angle[ind]*(theta_channel-theta_start)+theta_start
+
+    ind = (xtopo >= xend_channel) & (xtopo < xend_trans)
+    slope_angle[ind] = (xtopo[ind]-xend_trans)/(xend_channel -
+                                                xend_trans)
+    slope_angle[ind] = slope_angle[ind]*(theta_channel-theta_end)+theta_end
+
+    bz = scipy.integrate.cumtrapz(-np.sin(slope_angle),
+                                  xtopo, axis=0, initial=0)
+    bz = bz-np.min(bz)
+
+    # Get the coordinates of (xtopo,ytopo) in the cartesian reference frame
+    # by=ytopo
+    bx = scipy.integrate.cumtrapz(
+        np.cos(slope_angle), xtopo, axis=0, initial=0)
+    bx = bx+xmin*np.cos(theta_start)
+
+    # Vector normal to topography in cartesian coordinates
+    # (nx,ny,nz)=(-sin(theta),0,cos(theta))
+    # as the topography does vary in the y direction
+    # The real topography is thus given in cartesian coordinates by
+    # (xcart,ycart,zcart)=(bx,by,bz)+htopo(nx,ny,nz)
+    xcart = bx+htopo*np.sin(slope_angle)
+    zcart = bz+htopo*np.cos(slope_angle)
+
+    # Reconstruct regular mesh for interpolation
+    Xout = np.linspace(xcart[0, 0], xcart[-1, 0], nx)
+    Yout = ytopo
+    Xout = np.tile(Xout[:, np.newaxis], (1, ny))
+    Zout = scipy.interpolate.griddata((xcart.reshape(nx*ny),
+                                       ytopo.reshape(nx*ny)),
+                                      zcart.reshape(nx*ny),
+                                      (Xout, Yout), method=interp_method)
+    Ztmp = scipy.interpolate.griddata((xcart.reshape(nx*ny),
+                                       ytopo.reshape(nx*ny)),
+                                      zcart.reshape(nx*ny),
+                                      (Xout, Yout), method='nearest')
+    ind = np.isnan(Zout)
+    Zout[ind] = Ztmp[ind]
+
+    if plot:
+        if theta_end == 0:
+            blod, thin = tilupy.plot.get_contour_intervals(np.nanmin(Zout),
+                                                           np.nanmax(Zout))
+            level_min = thin
+        else:
+            level_min = None
+        tilupy.plot.plot_topo(Zout.T, Xout[:, 1], Yout[1, :],
+                              level_min=level_min)
+
+    return Xout[:, 1], Yout[1, :], Zout.T, thalweg
+
+
+if __name__ == '__main__':
+
+    # %% Test gray99
+    X, Y, Z = gray99(plot=True)
+
+    # %% Test synthetic channel
+    bend = 0.25
+    R = 0.2
+
+    nx = 600
+    ny = 300
+
+    xmin = 0.1
+    xmax = 4.5
+    xstart_trans = -0.3
+    xstart_channel = 0.2
+    xend_channel = 2.3
+    xend_trans = 2.75
+    ymax = 1
+
+    theta_start = 10
+    theta_channel = 10
+    theta_end = 0
+    x, y, z, t = channel(nx, ny, xmin=xmin, xmax=xmax, ymax=ymax,
+                         xstart_channel=xstart_channel,
+                         xend_channel=xend_channel,
+                         xstart_trans=xstart_trans,
+                         theta_start=theta_start,
+                         theta_end=theta_end,
+                         theta_channel=theta_channel,
+                         R=R, bend=bend, maxh=R, plot=True)

{tilupy-0.1.3 → tilupy-0.1.5}/src/tilupy/models/shaltop/initsimus.py

@@ -50,26 +50,27 @@ def write_params_file(params, directory=None,
     with open(os.path.join(directory, file_name), 'w') as file_params:
         for name in params:
             val = params[name]
-            if type(val) == int or type(val) == np.int64:
+            if isinstance(val, int) or isinstance(val, np.int64):
                 file_params.write('{:s} {:d}\n'.format(name, val))
-            if type(val) == float or type(val) == np.float64:
+            if isinstance(val, float) or isinstance(val, np.float64):
                 file_params.write('{:s} {:.8G}\n'.format(name, val))
-            if type(val) == str:
+            if isinstance(val, str):
                 file_params.write('{:s} {:s}\n'.format(name, val))
 
+
 def raster_to_shaltop_txtfile(file_in, file_out, folder_out=None):
-    
+
     if folder_out is not None:
         file_out = os.path.join(folder_out, file_out)
-        
+
     x, y, rast = tilupy.raster.read_raster(file_in)
     np.savetxt(file_out,
                np.reshape(np.flip(rast, axis=0), (rast.size, 1)),
                fmt='%.12G')
-    
+
     res = dict(x0=x[0], y0=y[0], dx=x[1]-x[0], dy=y[1]-y[0],
                nx=len(x), ny=len(y))
-    
+
     return res
 
 

{tilupy-0.1.3 → tilupy-0.1.5}/src/tilupy/plot.py

@@ -17,6 +17,10 @@ import seaborn as sns
 
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
+BOLD_CONTOURS_INTV = [0.1, 0.2, 0.5, 1, 2., 5, 10, 20, 50, 100, 200, 500, 1000]
+NB_THIN_CONTOURS = 10
+NB_BOLD_CONTOURS = 3
+
 
 def centered_map(cmap, vmin, vmax, ncolors=256):
     """
@@ -55,11 +59,37 @@ def centered_map(cmap, vmin, vmax, ncolors=256):
     return new_map
 
 
-def plot_topo(z, x, y, contour_step=None, nlevels=25, level_min=None,
-              step_contour_bold=0, contour_labels_properties=None,
+def get_contour_intervals(zmin, zmax, nb_bold_contours=None,
+                          nb_thin_contours=None):
+
+    if nb_thin_contours is None:
+        nb_thin_contours = NB_THIN_CONTOURS
+    if nb_bold_contours is None:
+        nb_bold_contours = NB_BOLD_CONTOURS
+
+    intv = (zmax - zmin) / nb_bold_contours
+    i = np.argmin(np.abs(np.array(BOLD_CONTOURS_INTV) - intv))
+
+    bold_intv = BOLD_CONTOURS_INTV[i]
+    if BOLD_CONTOURS_INTV[i] != BOLD_CONTOURS_INTV[0]:
+        if bold_intv - intv > 0:
+            bold_intv = BOLD_CONTOURS_INTV[i-1]
+
+    if nb_thin_contours is None:
+        thin_intv = bold_intv / NB_THIN_CONTOURS
+        if (zmax - zmin)/bold_intv > 5:
+            thin_intv = thin_intv*2
+    else:
+        thin_intv = bold_intv / nb_thin_contours
+
+    return bold_intv, thin_intv
+
+
+def plot_topo(z, x, y, contour_step=None, nlevels=None, level_min=None,
+              step_contour_bold='auto', contour_labels_properties=None,
               label_contour=True, contour_label_effect=None,
               axe=None,
-              vert_exag=1, fraction=1, ndv=0, uniform_grey=None,
+              vert_exag=1, fraction=1, ndv=-9999, uniform_grey=None,
               contours_prop=None, contours_bold_prop=None,
               figsize=None,
               interpolation=None,
@@ -111,7 +141,7 @@ def plot_topo(z, x, y, contour_step=None, nlevels=25, level_min=None,
     fraction : TYPE, optional
         DESCRIPTION. The default is 1.
     ndv : TYPE, optional
-        DESCRIPTION. The default is 0.
+        DESCRIPTION. The default is -9999.
 
     Returns
     -------
@@ -126,6 +156,12 @@ def plot_topo(z, x, y, contour_step=None, nlevels=25, level_min=None,
                  y[-1]+dy/2]
     ls = mcolors.LightSource(azdeg=azdeg, altdeg=altdeg)
 
+    auto_bold_intv = None
+
+    if nlevels is None and contour_step is None:
+        auto_bold_intv, contour_step = get_contour_intervals(np.nanmin(z),
+                                                             np.nanmax(z))
+
     if level_min is None:
         if contour_step is not None:
             level_min = np.ceil(np.nanmin(z)/contour_step)*contour_step
@@ -166,8 +202,16 @@ def plot_topo(z, x, y, contour_step=None, nlevels=25, level_min=None,
         contours_bold_prop = dict(alpha=0.8, colors='k',
                                   linewidths=0.8)
 
+    if step_contour_bold == 'auto':
+        if auto_bold_intv is None:
+            auto_bold_intv, _ = get_contour_intervals(np.nanmin(z),
+                                                      np.nanmax(z))
+        step_contour_bold = auto_bold_intv
+
     if step_contour_bold > 0:
         lmin = np.ceil(np.nanmin(z)/step_contour_bold)*step_contour_bold
+        if lmin < level_min:
+            lmin = lmin + step_contour_bold
         levels = np.arange(lmin, np.nanmax(z), step_contour_bold)
         cs = axe.contour(x, y, np.flip(z, axis=0),
                          extent=im_extent,

{tilupy-0.1.3 → tilupy-0.1.5/src/tilupy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tilupy
-Version: 0.1.3
+Version: 0.1.5
 Summary: Thin-layer models unified processing tool
 Author-email: Marc Peruzzetto <m.peruzzetto@brgm.fr>
 License: CeCILL-C FREE SOFTWARE LICENSE AGREEMENT
@@ -524,12 +524,19 @@ Keywords: thin-layer,shallow-water,display,simulation,model,processing,benchmark
 Classifier: License :: CeCILL-C Free Software License Agreement (CECILL-C)
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
+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.3 → tilupy-0.1.5}/src/tilupy.egg-info/SOURCES.txt

@@ -10,6 +10,8 @@ src/tilupy/cmd.py
 src/tilupy/compare.py
 src/tilupy/download_data.py
 src/tilupy/initdata.py
+src/tilupy/make_mass.py
+src/tilupy/make_topo.py
 src/tilupy/notations.py
 src/tilupy/plot.py
 src/tilupy/raster.py
@@ -28,4 +30,5 @@ src/tilupy/models/ravaflow/read.py
 src/tilupy/models/shaltop/__init__.py
 src/tilupy/models/shaltop/initsimus.py
 src/tilupy/models/shaltop/read.py
+tests/test_generated_data.py
 tests/test_shaltop.py

{tilupy-0.1.3 → tilupy-0.1.5}/src/tilupy.egg-info/requires.txt

@@ -1,5 +1,6 @@
 seaborn
 requests
+scipy
 
 [dev]
 pipreqs

tilupy-0.1.5/tests/test_generated_data.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Aug  4 12:45:15 2023
+
+@author: peruzzetto
+"""
+
+import numpy as np
+
+import tilupy.make_topo
+
+
+def test_topo_gray():
+
+    x, y, z = tilupy.make_topo.gray99()
+
+    assert (np.abs(y[-1] - 0.5) < 1e-6) & (len(x) == 361)

tilupy-0.1.5/tests/test_shaltop.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jul 19 15:39:38 2023
+
+@author: peruzzetto
+"""
+
+import os
+import shutil
+
+import tilupy.models.shaltop.initsimus as shinit
+import tilupy.cmd
+
+
+def test_shaltop_raster_to_input(folder_data):
+
+    folder_simus = os.path.join(folder_data, 'frankslide', 'shaltop')
+
+    raster_topo = os.path.join(folder_data, 'frankslide', 'rasters',
+                               'Frankslide_topography.asc')
+
+    file_topo_sh = os.path.join(folder_simus, 'topography.d')
+
+    if os.path.isfile(file_topo_sh):
+        os.remove(file_topo_sh)
+
+    shinit.raster_to_shaltop_txtfile(raster_topo, file_topo_sh)
+
+    raster_pile = os.path.join(folder_data, 'frankslide', 'rasters',
+                               'Frankslide_pile.asc')
+    file_mass_sh = os.path.join(folder_simus, 'init_mass.d')
+
+    if os.path.isfile(file_mass_sh):
+        os.remove(file_mass_sh)
+
+    shinit.raster_to_shaltop_txtfile(raster_pile, file_mass_sh)
+
+    assert os.path.isfile(file_topo_sh) & os.path.isfile(file_mass_sh)
+
+
+def test_shaltop_make_read_param_file(folder_data):
+
+    params = dict(nx=201, ny=201,
+                  per=201*20,
+                  pery=201*20,
+                  # Simulation maximum time in seconds (not comutation time)
+                  tmax=20,
+                  dt_im=10,  # Time interval (s) between snapshots recordings
+                  file_z_init='topography.d',  # Name of topography input file
+                  file_m_init='init_mass.d',  # name of init mass input file
+                  initz=0,  # Topography is read from file
+                  ipr=0,  # Initial mass is read from file
+                  hinit_vert=1,  # Initial is given as vertical thicknesses and
+                  # must be converted to thicknesses normal to topography
+                  eps0=1e-13,  # Minimum value for thicknesses and velocities
+                  # choice of rheology (Coulomb with constant basal friction)
+                  icomp=1,
+                  # Min x value (used for plots after simulation is over)
+                  x0=1000,
+                  y0=2000)  # Min y value (used for plots after simulation is over)
+
+    deltas = [15, 20, 25]
+    folder_simus = os.path.join(folder_data, 'frankslide', 'shaltop')
+    files_created = True
+
+    for delta in deltas:
+        params_txt = 'delta_{:05.2f}'.format(delta).replace('.', 'p')
+        param_file_path = os.path.join(folder_simus, params_txt + '.txt')
+        if os.path.isfile(param_file_path):
+            os.remove(param_file_path)
+        # Specify folder where outputs are stored
+        params['folder_output'] = params_txt
+        params['delta1'] = delta  # Specify the friction coefficient
+        # Write parameter file
+        shinit.write_params_file(params, directory=folder_simus,
+                                 file_name=params_txt + '.txt')
+
+        files_created = files_created & os.path.isfile(param_file_path)
+        if not files_created:
+            break
+
+    assert files_created
+
+
+def test_shaltop_plot_results(folder_data):
+
+    folder_simus = os.path.join(folder_data, 'frankslide', 'shaltop')
+    params_files = 'delta_*p00.txt'
+    folder_ress = [os.path.join(folder_data, 'frankslide', 'shaltop',
+                                'delta_{:d}p00'.format(delta), 'plots')
+                   for delta in [15, 20, 25]]
+    for folder in folder_ress:
+        if os.path.isdir(folder):
+            shutil.rmtree(folder)
+    tilupy.cmd.plot_results('shaltop', 'h', params_files, folder_simus,
+                            save=True, display_plot=False,
+                            figsize=(10/2.54, 10/2.54))
+    files_plots = ['h_0000.png', 'h_0001.png', 'h_0002.png']
+
+    all_files_created = True
+    for folder in folder_ress:
+        for file in files_plots:
+            file_path = os.path.join(folder, file)
+            all_files_created = all_files_created & os.path.isfile(file_path)
+
+    assert all_files_created

tilupy-0.1.3/tests/test_shaltop.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Wed Jul 19 15:39:38 2023
-
-@author: peruzzetto
-"""
-
-import os
-
-import tilupy.models.shaltop.initsimus as shinit
-
-
-def test_shaltop_raster_to_input(folder_data):
-    
-    raster_topo = os.path.join(folder_data, 'frankslide', 'rasters', 
-                               'Frankslide_topography.asc')
-    
-    folder_simus = os.path.join(folder_data, 'frankslide', 'shaltop')
-    
-    file_topo_sh = os.path.join(folder_simus, 'topography.d')
-    
-    if os.path.isfile(file_topo_sh):
-        os.remove(file_topo_sh)
-    
-    shinit.raster_to_shaltop_txtfile(raster_topo, file_topo_sh)
-    
-    assert os.path.isfile(file_topo_sh)    
-
-def test_shaltop_make_read_param_file(folder_data):
-    
-    params = dict(nx=201, ny=201,
-                  per=201*20,
-                  pery=201*20,
-                  tmax=100, # Simulation maximum time in seconds (not comutation time)
-                  dt_im=10, # Time interval (s) between snapshots recordings
-                  file_z_init = 'topography.d', # Name of topography input file
-                  file_m_init = 'init_mass.d',# name of init mass input file
-                  initz=0, # Topography is read from file
-                  ipr=0, # Initial mass is read from file
-                  hinit_vert=1, # Initial is given as vertical thicknesses and 
-                  # must be converted to thicknesses normal to topography
-                  eps0=1e-13, #Minimum value for thicknesses and velocities
-                  icomp=1, # choice of rheology (Coulomb with constant basal friction)
-                  x0=1000, # Min x value (used for plots after simulation is over)
-                  y0=2000) # Min y value (used for plots after simulation is over)
-    
-    deltas = [15, 20, 25]
-    folder_simus = os.path.join(folder_data, 'frankslide', 'shaltop')
-    files_created = True
-    
-    for delta in deltas:
-        params_txt = 'delta_{:05.2f}'.format(delta).replace('.', 'p')
-        param_file_path = os.path.join(folder_simus,params_txt + '.txt')
-        if os.path.isfile(param_file_path):
-            os.remove(param_file_path)
-        params['folder_output'] = params_txt # Specify folder where outputs are stored
-        params['delta1'] = delta # Specify the friction coefficient
-        #Write parameter file
-        shinit.write_params_file(params, directory=folder_simus,
-                                 file_name=params_txt + '.txt')
-        
-        files_created = files_created & os.path.isfile(param_file_path)
-        if not files_created:
-            break
-        
-        assert files_created