landlab.components.flexure.flexure_1d¶

Deform the lithosphere with 1D or 2D flexure.

Landlab component that implements a 1D lithospheric flexure.

Examples

Create a grid on which we will run the flexure calculations.

>>> from landlab import RasterModelGrid
>>> from landlab.components.flexure import Flexure1D
>>> grid = RasterModelGrid((3, 4), xy_spacing=(1.0e4, 1.0e4))
>>> lith_press = grid.add_zeros("node", "lithosphere__increment_of_overlying_pressure")

Because Flexure1D is a one-dimensional component, it operates independently on each row of grid nodes. By default, it will calculate deflections on every row but you can also specify which rows to operate on by passing an indexing array to the rows keyword.

In this example, we’ll just calculate deflections along the middle row or nodes (that is, row 1)

>>> flex = Flexure1D(grid, rows=1)

In creating the component, a field (initialized with zeros) was added to the grid that represents the current loading distribution. If the grid already had this field, the component would use the existing field. This can be accessed either through the grid attribute in the same way as other landlab fields,

>>> flex.grid.at_node["lithosphere__increment_of_overlying_pressure"]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

or through the load_at_node attribute of Flexure1D,

>>> flex.load_at_node
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

Notice that load_at_node returns a reshaped view of the array whereas the field returns a flattened array. Change values in this array to add loads to the grid,

>>> flex.load_at_node[1, 2:4] = flex.gamma_mantle
>>> flex.run_one_step()

The output deflections can be retrieved either using landlab fields as,

>>> flex.grid.at_node["lithosphere_surface__increment_of_elevation"]
array([0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0.])

or through the dz_at_node attribute,

>>> flex.dz_at_node
array([[0., 0., 0., 0.],
       [0., 0., 1., 1.],
       [0., 0., 0., 0.]])

class Flexure1D[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.0e4, 1.0e4))
>>> 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.0)
True

>>> np.all(grid.at_node["lithosphere__increment_of_overlying_pressure"] == 0.0)
True
>>> flex.update()
>>> np.all(grid.at_node["lithosphere_surface__increment_of_elevation"] == 0.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.0)
True

>>> flex.update()
>>> np.all(grid.at_node["lithosphere_surface__increment_of_elevation"] == 0.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).

static __new__(cls, *args, **kwds)¶

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

cite_as = ''¶

property coords¶: Return the coordinates of nodes on grid attached to the component.

property current_time¶

Current time.

Some components may keep track of the current time. In this case, the current_time attribute is incremented. Otherwise it is set to None.

Return type:: current_time

definitions = (('lithosphere__increment_of_overlying_pressure', 'Applied pressure to the lithosphere over a time step'), ('lithosphere_surface__increment_of_elevation', 'The change in elevation of the top of the lithosphere (the land surface) in one timestep'))¶

property dz_at_node¶

property eet¶: Effective elastic thickness (m).

classmethod from_path(grid, path)¶

Create a component from an input file.

Parameters:

grid (ModelGrid) – A landlab grid.
path (str or file_like) – Path to a parameter file, contents of a parameter file, or a file-like object.

Returns:

A newly-created component.

Return type:

Component

property gamma_mantle¶: Specific density of mantle (N/m^3).

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

property grid¶: Return the grid attached to the component.

initialize_optional_output_fields()¶

Create fields for a component based on its optional field outputs, if declared in _optional_var_names.

This method will create new fields (without overwrite) for any fields output by the component as optional. New fields are initialized to zero. New fields are created as arrays of floats, unless the component also contains the specifying property _var_type.

initialize_output_fields(values_per_element=None)¶

Create fields for a component based on its input and output var names.

This method will create new fields (without overwrite) for any fields output by, but not supplied to, the component. New fields are initialized to zero. Ignores optional fields. New fields are created as arrays of floats, unless the component specifies the variable type.

Parameters:: values_per_element (int (optional)) – On occasion, it is necessary to create a field that is of size (n_grid_elements, values_per_element) instead of the default size (n_grid_elements,). Use this keyword argument to acomplish this task.

input_var_names = ('lithosphere__increment_of_overlying_pressure',)¶

property load_at_node¶

property method¶: Name of method used to calculate deflections.

name = '1D Flexure Equation'¶

optional_var_names = ()¶

output_var_names = ('lithosphere_surface__increment_of_elevation',)¶

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

property shape¶: Return the grid shape attached to the component, if defined.

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

unit_agnostic = True¶

units = (('lithosphere__increment_of_overlying_pressure', 'Pa'), ('lithosphere_surface__increment_of_elevation', 'm'))¶

update()[source]¶: Update fields with current loading conditions.

classmethod var_definition(name)¶

Get a description of a particular field.

Parameters:: name (str) – A field name.
Returns:: A description of each field.
Return type:: tuple of (name, *description*)

classmethod var_help(name)¶

Print a help message for a particular field.

Parameters:: name (str) – A field name.

classmethod var_loc(name)¶

Location where a particular variable is defined.

Parameters:: name (str) – A field name.
Returns:: The location (‘node’, ‘link’, etc.) where a variable is defined.
Return type:: str

var_mapping = (('lithosphere__increment_of_overlying_pressure', 'node'), ('lithosphere_surface__increment_of_elevation', 'node'))¶

classmethod var_type(name)¶

Returns the dtype of a field (float, int, bool, str…).

Parameters:: name (str) – A field name.
Returns:: The dtype of the field.
Return type:: dtype

classmethod var_units(name)¶

Get the units of a particular field.

Parameters:: name (str) – A field name.
Returns:: Units for the given field.
Return type:: str

property x_at_node¶

property youngs¶: Young’s modulus of lithosphere (Pa).