# 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]#

Bases: `Component`

Deform the lithosphere with 1D or 2D flexure.

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

Examples

```>>> from landlab import RasterModelGrid
>>> from landlab.components.flexure import Flexure
>>> grid = RasterModelGrid((5, 4), xy_spacing=(1.e4, 1.e4))
>>> lith_press = grid.add_zeros(
...     "lithosphere__overlying_pressure_increment", at="node"
... )
```
```>>> 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
```

References

Required Software Citation(s) Specific to this Component

Hutton, E., Syvitski, J. (2008). Sedflux 2.0: An advanced process-response model that generates three-dimensional stratigraphy. Computers & Geosciences. 34(10), 1319-1337. https://dx.doi.org/10.1016/j.cageo.2008.02.013

Lambeck, K.: Geophysical Geodesy, The Slow Deformations of the Earth, Clarendon Press, Oxford, UK, 718 pp., 1988.

Initialize the flexure component.

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).

• n_procs (int, optional) – Number of processors to use for calculations.

__init__(grid, eet=65000.0, youngs=70000000000.0, method='airy', rho_mantle=3300.0, gravity=9.80665, n_procs=1)[source]#

Initialize the flexure component.

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).

• n_procs (int, optional) – Number of processors to use for calculations.

property alpha#

Flexure parameter (m).

property eet#

Effective elastic thickness (m).

property gamma_mantle#

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

property gravity#

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

property method#

Name of method used to calculate deflections.

property rho_mantle#

Density of mantle (kg/m^3).

Subside surface due to multiple loads.

Parameters:
• loads (ndarray of float) – Loads applied to each grid node.

• out (ndarray of float, optional) – Buffer to place resulting deflection values.

Returns:

Return type:

ndarray of float

update()[source]#

property youngs#

Young’s modulus of lithosphere (Pa).

class Flexure1D(*args, **kwds)[source]#

Bases: `Component`

Deform the lithosphere with 1D flexure.

Landlab component that implements a 1D lithospheric flexure model.

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).

• rho_water (float, optional) – Density of the sea water (kg / m^3).

• gravity (float, optional) – Acceleration due to gravity (m / s^2).

• rows (int, optional) – Node rows that this component will operate on (default is to operate on all rows).

Examples

```>>> from landlab import RasterModelGrid
>>> from landlab.components.flexure import Flexure1D
>>> grid = RasterModelGrid((5, 4), xy_spacing=(1.e4, 1.e4))
>>> lith_press = grid.add_zeros(
...     "node",
...     "lithosphere__increment_of_overlying_pressure")
>>> flex = Flexure1D(grid)
>>> flex.name
'1D Flexure Equation'
>>> flex.input_var_names
('lithosphere__increment_of_overlying_pressure',)
>>> flex.output_var_names
('lithosphere_surface__increment_of_elevation',)
>>> sorted(flex.units)
[('lithosphere__increment_of_overlying_pressure', 'Pa'),
('lithosphere_surface__increment_of_elevation', '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__increment_of_elevation'] == 0.)
True
```
```>>> np.all(grid.at_node['lithosphere__increment_of_overlying_pressure'] == 0.)
True
>>> flex.update()
>>> np.all(grid.at_node['lithosphere_surface__increment_of_elevation'] == 0.)
True
```
```>>> load = grid.at_node['lithosphere__increment_of_overlying_pressure']
>>> load[4] = 1e9
>>> dz = grid.at_node['lithosphere_surface__increment_of_elevation']
>>> np.all(dz == 0.)
True
```
```>>> flex.update()
>>> np.all(grid.at_node['lithosphere_surface__increment_of_elevation'] == 0.)
False
```

Initialize the flexure component.

Parameters:
• grid (RasterModelGrid) – A grid.

• eet (float, optional) – Effective elastic thickness (m).

• youngs (float, optional (Pa)) – Young’s modulus.

• method ({'airy', 'flexure'}, optional) – Method to use to calculate deflections.

• rho_mantle (float, optional) – Density of the mantle (kg / m^3).

• rho_water (float, optional) – Density of the sea water (kg / m^3).

• gravity (float, optional) – Acceleration due to gravity (m / s^2).

• rows (int, optional) – Node rows that this component will operate on (default is to operate on all rows).

__init__(grid, eet=65000.0, youngs=70000000000.0, method='airy', rho_mantle=3300.0, rho_water=1030.0, gravity=9.80665, rows=None)[source]#

Initialize the flexure component.

Parameters:
• grid (RasterModelGrid) – A grid.

• eet (float, optional) – Effective elastic thickness (m).

• youngs (float, optional (Pa)) – Young’s modulus.

• method ({'airy', 'flexure'}, optional) – Method to use to calculate deflections.

• rho_mantle (float, optional) – Density of the mantle (kg / m^3).

• rho_water (float, optional) – Density of the sea water (kg / m^3).

• gravity (float, optional) – Acceleration due to gravity (m / s^2).

• rows (int, optional) – Node rows that this component will operate on (default is to operate on all rows).

property alpha#

Flexure parameter (m).

static calc_flexure(x, loads, alpha, rigidity, out=None)[source]#

Subside surface due to multiple loads.

Parameters:
• x (ndarray of float) – Position of grid nodes (m).

• loads (ndarray of float) – Loads applied to each grid node (Pa).

• alpha (float) – Flexure parameter of the lithosphere (m).

• rigidity (float) – Flexural rigidity of the lithosphere (N m).

• out (ndarray of float, optional) – Buffer to place resulting deflection values (m).

Returns:

Return type:

ndarray of float

property dz_at_node#
property eet#

Effective elastic thickness (m).

property gamma_mantle#

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

property gravity#

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

property method#

Name of method used to calculate deflections.

property rho_mantle#

Density of mantle (kg/m^3).

property rho_water#

Density of water (kg/m^3).

property rigidity#

Flexural rigidity (N m).

run_one_step()[source]#

Subside surface due to multiple loads.

Parameters:
• loads (ndarray of float) – Loads applied to each grid node (Pa).

• out (ndarray of float, optional) – Buffer to place resulting deflection values (m).

Returns:

Return type:

ndarray of float

update()[source]#

property x_at_node#
property 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 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
```

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.

Returns:

out – Array of deflections.

Return type:

ndarray

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.).

```>>> 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
>>> print(round(dz.min(), 9))
5.24e-07
>>> print(round(dz.max(), 9))
5.26e-07
```
```>>> dz = subside_point_load((1e9, 1e9), ((5000., 5000.), (2500., 2500.)),
...                         (x, y), params=params)
>>> print(round(dz.min(), 9) / 2.)
5.235e-07
>>> print(round(dz.max(), 9) / 2.)
5.265e-07
```

# 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 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
```

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.

Returns:

out – Array of deflections.

Return type:

ndarray

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.).

```>>> 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
>>> print(round(dz.min(), 9))
5.24e-07
>>> print(round(dz.max(), 9))
5.26e-07
```
```>>> dz = subside_point_load((1e9, 1e9), ((5000., 5000.), (2500., 2500.)),
...                         (x, y), params=params)
>>> print(round(dz.min(), 9) / 2.)
5.235e-07
>>> print(round(dz.max(), 9) / 2.)
5.265e-07
```