landlab

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(self, grid, eet=65000.0, youngs=70000000000.0, method='airy', rho_mantle=3300.0, gravity=9.80665, **kwds)[source]

Bases: landlab.core.model_component.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))
>>> 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

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

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_loads(loads, out=None, n_procs=1)[source]

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.

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

Returns

Deflections caused by the loading.

Return type

ndarray of float

update(n_procs=1)[source]

Update fields with current loading conditions.

Parameters

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

property youngs

Young’s modulus of lithosphere (Pa).

class Flexure1D(self, grid, eet=65000.0, youngs=70000000000.0, method='airy', rho_mantle=3300.0, rho_water=1030.0, gravity=9.80665, rows=None, **kwds)[source]

Bases: landlab.core.model_component.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 Flexure
>>> grid = RasterModelGrid((5, 4), xy_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

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

POISSON = 0.25
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

Deflections caused by the loading.

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 load_at_node
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(dt=None)[source]
subside_loads(loads, out=None)[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

Deflections caused by the loading.

Return type

ndarray of float

update()[source]

Update fields with current loading conditions.

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

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

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

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.

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

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