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(*args, **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.

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.

Returns:

ndarray of float

Deflections caused by the loading.

update(n_procs=1)[source]

Update fields with current loading conditions.

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.

Returns:

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.

Returns:

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.

Returns:

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.

Returns:

out : ndarray

Array of deflections.