Flexure: Calculate elastic lithosphere flexure under given loads (assumes uniform flexural rigidity)¶

Code author: Eric Hutton <huttone@colorado.edu>

Section author: Eric Hutton <huttone@colorado.edu>

class Flexure(*args, **kwds)[source]

Deform the lithosphere with 1D or 2D flexure.

Landlab component that implements a 1 and 2D lithospheric flexure model.

Construction:

Flexure(grid, eet=65e3, youngs=7e10, method='airy', rho_mantle=3300.,
gravity=9.80665)

Parameters: grid : RasterModelGrid A grid. eet : float, optional Effective elastic thickness (m). youngs : float, optional Young’s modulus. method : {‘airy’, ‘flexure’}, optional Method to use to calculate deflections. rho_mantle : float, optional Density of the mantle (kg / m^3). gravity : float, optional Acceleration due to gravity (m / s^2).

Examples

>>> from landlab import RasterModelGrid
>>> from landlab.components.flexure import Flexure
>>> grid = RasterModelGrid((5, 4), spacing=(1.e4, 1.e4))

>>> flex = Flexure(grid)
>>> flex.name
'Flexure'
>>> flex.input_var_names
('lithosphere__overlying_pressure_increment',)
>>> flex.output_var_names
('lithosphere_surface__elevation_increment',)
>>> sorted(flex.units)
[('lithosphere__overlying_pressure_increment', 'Pa'),
('lithosphere_surface__elevation_increment', 'm')]

>>> flex.grid.number_of_node_rows
5
>>> flex.grid.number_of_node_columns
4
>>> flex.grid is grid
True

>>> np.all(grid.at_node['lithosphere_surface__elevation_increment'] == 0.)
True

>>> np.all(grid.at_node['lithosphere__overlying_pressure_increment'] == 0.)
True
>>> flex.update()
>>> np.all(grid.at_node['lithosphere_surface__elevation_increment'] == 0.)
True

>>> load = grid.at_node['lithosphere__overlying_pressure_increment']
>>> load[4] = 1e9
>>> dz = grid.at_node['lithosphere_surface__elevation_increment']
>>> np.all(dz == 0.)
True

>>> flex.update()
>>> np.all(grid.at_node['lithosphere_surface__elevation_increment'] == 0.)
False

alpha

Flexure parameter (m).

eet

Effective elastic thickness (m).

gamma_mantle

Specific density of mantle (N/m^3).

gravity

Acceleration due to gravity (m/s^2).

method

Name of method used to calculate deflections.

rho_mantle

Density of mantle (kg/m^3).

subside_loads(loads, deflection=None, n_procs=1)[source]

Subside surface due to multiple loads.

Parameters: loads : ndarray of float Loads applied to each grid node. deflection : ndarray of float, optional Buffer to place resulting deflection values. n_procs : int, optional Number of processors to use for calculations. ndarray of float Deflections caused by the loading.
update(n_procs=1)[source]

Parameters: n_procs : int, optional Number of processors to use for calculations.
youngs

Young’s modulus of lithosphere (Pa).

get_flexure_parameter(h, E, n_dim, gamma_mantle=33000.0)[source]

Calculate the flexure parameter based on some physical constants. h is the Effective elastic thickness of Earth’s crust (m), E is Young’s Modulus, and n_dim is the number of spatial dimensions for which the flexure parameter is used. The number of dimension must be either 1, or 2.

Examples

>>> from __future__ import print_function
>>> from landlab.components.flexure import get_flexure_parameter

>>> eet = 65000.
>>> youngs = 7e10
>>> alpha = get_flexure_parameter(eet, youngs, 1)
>>> print('%.3f' % round(alpha, 3))
119965.926

>>> alpha = get_flexure_parameter(eet, youngs, 2)
>>> print('%.2f' % alpha)
84828.72

subside_point_load(load, loc, coords, params=None, out=None)[source]

Calculate deflection at points due a point load.

Calculate deflections on a grid, defined by the points in the coords tuple, due to a point load of magnitude load applied at loc.

x and y are the x and y coordinates of each node of the solution grid (in meters). The scalars eet and youngs define the crustal properties.

Parameters: load : float Magnitude of the point load. loc : float or tuple Location of the load as either a scalar or as (x, y) coords : ndarray Array of points to calculate deflections at params : dict-like Physical parameters used for deflection calculation. Valid keys are - eet: Effective elastic thickness - youngs: Young’s modulus out : ndarray, optional Array to put deflections into. out : ndarray Array of deflections.

Examples

>>> from landlab.components.flexure import subside_point_load

>>> params = dict(eet=65000., youngs=7e10)
>>> load = 1e9


Define a unifrom rectilinear grid.

>>> x = np.arange(0, 10000, 100.)
>>> y = np.arange(0, 5000, 100.)
>>> (x, y) = np.meshgrid(x, y)
>>> x.shape = (x.size, )
>>> y.shape = (y.size, )


Calculate deflections due to a load applied at position (5000., 2500.).

>>> import six
>>> x = np.arange(0, 10000, 1000.)
>>> y = np.arange(0, 5000, 1000.)
>>> (x, y) = np.meshgrid(x, y)
>>> x.shape = (x.size, )
>>> y.shape = (y.size, )
>>> dz = subside_point_load(load, (5000., 2500.), (x, y), params=params)
>>> print('%.5g' % round(dz.sum(), 9))
2.6267e-05
>>> six.print_(round(dz.min(), 9))
5.24e-07
>>> six.print_(round(dz.max(), 9))
5.26e-07

>>> dz = subside_point_load((1e9, 1e9), ((5000., 5000.), (2500., 2500.)),
...                         (x, y), params=params)
>>> six.print_(round(dz.min(), 9) / 2.)
5.235e-07
>>> six.print_(round(dz.max(), 9) / 2.)
5.265e-07

subside_point_loads(loads, locs, coords, params=None, deflection=None, n_procs=1)[source]

Calculate deflection at points due multiple point loads.

Calculate lithospheric deflections due to loads at coordinates specified by the locs tuple. coords is a tuple that gives the coordinates of each point where deflections are calculated; locs is positions of the applied loads. Since this function calculates the 1D or 2D flexure equation, coords and locs must have either one or two elements.

Parameters: load : array_like Magnitude of the point loads. loc : tuple of (loc_x, loc_y) Load locations. coords : ndarray Array of points to calculate deflections at params : dict-like Physical parameters used for deflection calculation. Valid keys are - eet: Effective elastic thickness - youngs: Young’s modulus - gamma_mantle: Specific weight of the mantle out : ndarray, optional Array to put deflections into. out : ndarray Array of deflections.

Functions used to calculate lithospheric deflection¶

get_flexure_parameter(h, E, n_dim, gamma_mantle=33000.0)[source]

Calculate the flexure parameter based on some physical constants. h is the Effective elastic thickness of Earth’s crust (m), E is Young’s Modulus, and n_dim is the number of spatial dimensions for which the flexure parameter is used. The number of dimension must be either 1, or 2.

Examples

>>> from __future__ import print_function
>>> from landlab.components.flexure import get_flexure_parameter

>>> eet = 65000.
>>> youngs = 7e10
>>> alpha = get_flexure_parameter(eet, youngs, 1)
>>> print('%.3f' % round(alpha, 3))
119965.926

>>> alpha = get_flexure_parameter(eet, youngs, 2)
>>> print('%.2f' % alpha)
84828.72

subside_point_load(load, loc, coords, params=None, out=None)[source]

Calculate deflection at points due a point load.

Calculate deflections on a grid, defined by the points in the coords tuple, due to a point load of magnitude load applied at loc.

x and y are the x and y coordinates of each node of the solution grid (in meters). The scalars eet and youngs define the crustal properties.

Parameters: load : float Magnitude of the point load. loc : float or tuple Location of the load as either a scalar or as (x, y) coords : ndarray Array of points to calculate deflections at params : dict-like Physical parameters used for deflection calculation. Valid keys are - eet: Effective elastic thickness - youngs: Young’s modulus out : ndarray, optional Array to put deflections into. out : ndarray Array of deflections.

Examples

>>> from landlab.components.flexure import subside_point_load

>>> params = dict(eet=65000., youngs=7e10)
>>> load = 1e9


Define a unifrom rectilinear grid.

>>> x = np.arange(0, 10000, 100.)
>>> y = np.arange(0, 5000, 100.)
>>> (x, y) = np.meshgrid(x, y)
>>> x.shape = (x.size, )
>>> y.shape = (y.size, )


Calculate deflections due to a load applied at position (5000., 2500.).

>>> import six
>>> x = np.arange(0, 10000, 1000.)
>>> y = np.arange(0, 5000, 1000.)
>>> (x, y) = np.meshgrid(x, y)
>>> x.shape = (x.size, )
>>> y.shape = (y.size, )
>>> dz = subside_point_load(load, (5000., 2500.), (x, y), params=params)
>>> print('%.5g' % round(dz.sum(), 9))
2.6267e-05
>>> six.print_(round(dz.min(), 9))
5.24e-07
>>> six.print_(round(dz.max(), 9))
5.26e-07

>>> dz = subside_point_load((1e9, 1e9), ((5000., 5000.), (2500., 2500.)),
...                         (x, y), params=params)
>>> six.print_(round(dz.min(), 9) / 2.)
5.235e-07
>>> six.print_(round(dz.max(), 9) / 2.)
5.265e-07

subside_point_loads(loads, locs, coords, params=None, deflection=None, n_procs=1)[source]

Calculate deflection at points due multiple point loads.

Calculate lithospheric deflections due to loads at coordinates specified by the locs tuple. coords is a tuple that gives the coordinates of each point where deflections are calculated; locs is positions of the applied loads. Since this function calculates the 1D or 2D flexure equation, coords and locs must have either one or two elements.

Parameters: load : array_like Magnitude of the point loads. loc : tuple of (loc_x, loc_y) Load locations. coords : ndarray Array of points to calculate deflections at params : dict-like Physical parameters used for deflection calculation. Valid keys are - eet: Effective elastic thickness - youngs: Young’s modulus - gamma_mantle: Specific weight of the mantle out : ndarray, optional Array to put deflections into. out : ndarray Array of deflections.