def test_raise_kwargs_error():
mg = RasterModelGrid((5, 5))
soilTh = mg.add_zeros('node', 'soil__depth')
z = mg.add_zeros('node', 'topographic__elevation')
BRz = mg.add_zeros('node', 'bedrock__elevation')
z += mg.node_x.copy()
BRz += mg.node_x / 2.
soilTh[:] = z - BRz
expweath = ExponentialWeatherer(mg)
with pytest.raises(TypeError):
DepthDependentDiffuser(mg, diffusivity=1)
DDdiff = DepthDependentDiffuser(mg)
with pytest.raises(TypeError):
DDdiff.soilflux(2., bad_var=1)
def __init__(self, input_file=None, params=None,
BaselevelHandlerClass=None):
"""Initialize the BasicSa."""
# Call ErosionModel's init
super(BasicSa, self).__init__(input_file=input_file,
params=params,
BaselevelHandlerClass=BaselevelHandlerClass)
# Get Parameters and convert units if necessary:
self.K_sp = self.get_parameter_from_exponent('K_sp')
linear_diffusivity = (self._length_factor**2.)*self.get_parameter_from_exponent('linear_diffusivity') # has units length^2/time
try:
initial_soil_thickness = (self._length_factor)*self.params['initial_soil_thickness'] # has units length
except KeyError:
initial_soil_thickness = 1.0 # default value
soil_transport_decay_depth = (self._length_factor)*self.params['soil_transport_decay_depth'] # has units length
max_soil_production_rate = (self._length_factor)*self.params['max_soil_production_rate'] # has units length per time
soil_production_decay_depth = (self._length_factor)*self.params['soil_production_decay_depth'] # has units length
# Instantiate a FlowAccumulator with DepressionFinderAndRouter using D8 method
self.flow_router = FlowAccumulator(self.grid,
flow_director='D8',
depression_finder = DepressionFinderAndRouter)
# Instantiate a FastscapeEroder component
self.eroder = FastscapeEroder(self.grid,
K_sp=self.K_sp,
m_sp=self.params['m_sp'],
n_sp=self.params['n_sp'])
# Create soil thickness (a.k.a. depth) field
if 'soil__depth' in self.grid.at_node:
soil_thickness = self.grid.at_node['soil__depth']
else:
soil_thickness = self.grid.add_zeros('node', 'soil__depth')
# Create bedrock elevation field
if 'bedrock__elevation' in self.grid.at_node:
bedrock_elev = self.grid.at_node['bedrock__elevation']
else:
bedrock_elev = self.grid.add_zeros('node', 'bedrock__elevation')
# Set soil thickness and bedrock elevation
soil_thickness[:] = initial_soil_thickness
bedrock_elev[:] = self.z - initial_soil_thickness
# Instantiate diffusion and weathering components
self.diffuser = DepthDependentDiffuser(self.grid,
linear_diffusivity=linear_diffusivity,
soil_transport_decay_depth=soil_transport_decay_depth)
self.weatherer = ExponentialWeatherer(self.grid,
max_soil_production_rate=max_soil_production_rate,
soil_production_decay_depth=soil_production_decay_depth)
def __init__(self,
input_file=None,
params=None,
BaselevelHandlerClass=None):
"""Initialize the BasicSa."""
# Call ErosionModel's init
super(BasicHySa,
self).__init__(input_file=input_file,
params=params,
BaselevelHandlerClass=BaselevelHandlerClass)
self.K_br = self.get_parameter_from_exponent('K_rock_sp')
self.K_sed = self.get_parameter_from_exponent('K_sed_sp')
linear_diffusivity = (
self._length_factor**2.) * self.get_parameter_from_exponent(
'linear_diffusivity') # has units length^2/time
v_sc = self.get_parameter_from_exponent(
'v_sc') # normalized settling velocity. Unitless.
linear_diffusivity = (
self._length_factor**2.) * self.get_parameter_from_exponent(
'linear_diffusivity') # has units length^2/time
try:
initial_soil_thickness = (self._length_factor) * self.params[
'initial_soil_thickness'] # has units length
except KeyError:
initial_soil_thickness = 1.0 # default value
soil_transport_decay_depth = (self._length_factor) * self.params[
'soil_transport_decay_depth'] # has units length
max_soil_production_rate = (self._length_factor) * self.params[
'max_soil_production_rate'] # has units length per time
soil_production_decay_depth = (self._length_factor) * self.params[
'soil_production_decay_depth'] # has units length
# Instantiate a FlowAccumulator with DepressionFinderAndRouter using D8 method
self.flow_router = FlowAccumulator(
self.grid,
flow_director='D8',
depression_finder=DepressionFinderAndRouter)
#set methods and fields. K's and sp_crits need to be field names
method = 'simple_stream_power'
discharge_method = 'discharge_field'
area_field = None
discharge_field = 'surface_water__discharge'
# Instantiate a SPACE component
self.eroder = Space(self.grid,
K_sed=self.K_sed,
K_br=self.K_br,
F_f=self.params['F_f'],
phi=self.params['phi'],
H_star=self.params['H_star'],
v_s=v_sc,
m_sp=self.params['m_sp'],
n_sp=self.params['n_sp'],
method=method,
discharge_method=discharge_method,
area_field=area_field,
discharge_field=discharge_field,
solver=self.params['solver'])
# Create soil thickness (a.k.a. depth) field
if 'soil__depth' in self.grid.at_node:
soil_thickness = self.grid.at_node['soil__depth']
else:
soil_thickness = self.grid.add_zeros('node', 'soil__depth')
# Create bedrock elevation field
if 'bedrock__elevation' in self.grid.at_node:
bedrock_elev = self.grid.at_node['bedrock__elevation']
else:
bedrock_elev = self.grid.add_zeros('node', 'bedrock__elevation')
# Set soil thickness and bedrock elevation
try:
initial_soil_thickness = self.params['initial_soil_thickness']
except KeyError:
initial_soil_thickness = 1.0 # default value
soil_thickness[:] = initial_soil_thickness
bedrock_elev[:] = self.z - initial_soil_thickness
# Instantiate diffusion and weathering components
self.diffuser = DepthDependentDiffuser(
self.grid,
linear_diffusivity=linear_diffusivity,
soil_transport_decay_depth=soil_transport_decay_depth)
self.weatherer = ExponentialWeatherer(
self.grid,
max_soil_production_rate=max_soil_production_rate,
soil_production_decay_depth=soil_production_decay_depth)
self.grid.at_node['soil__depth'][:] = \
self.grid.at_node['topographic__elevation'] - \
self.grid.at_node['bedrock__elevation']
boundary_remove = np.where(second_boundary_layer == channel_nodes[0])
second_boundary_layer = np.delete(second_boundary_layer, boundary_remove)
mg.status_at_node[second_boundary_layer] = CLOSED_BOUNDARY
#inititalize resistant layer
starting_point = max(mg.node_x) - (2 * dx)
#route flow
fr = FlowDirectorD8(mg, 'topographic__elevation')
#instantiate BRaKE, the collection of functions governing river evolution
blocks = bl.BrakeLandlab()
#instantiate hillslope diffusion model component, from Landlab
hillslopeflux = DepthDependentDiffuser(
mg,
linear_diffusivity=linear_diffusivity,
soil_transport_decay_depth=soil_transport_decay_depth)
#instantiate exponential weathering component, from Landlab
weatheringrate = ExponentialWeatherer(
mg,
soil_production__maximum_rate=max_soil_production_rate,
soil_production__decay_depth=soil_production_decay_depth)
#set boundary elevations to enable easier data visualization in Paraview
mg.at_node['topographic__elevation'][mg.boundary_nodes] -= (bl_drop *
time_to_run)
mg.at_node['bedrock__elevation'][mg.boundary_nodes] -= (bl_drop * time_to_run)
mg.at_node['bedrock__elevation'][baselevel_node] = min(
mg.at_node['bedrock__elevation'][channel_nodes]) - 0.0001
mg.at_node['topographic__elevation'][baselevel_node] = mg.at_node[
def __init__(self,
clock,
grid,
m_sp=0.5,
n_sp=1.0,
water_erodibility=0.0001,
regolith_transport_parameter=0.1,
soil_production__maximum_rate=0.001,
soil_production__decay_depth=0.5,
soil_transport_decay_depth=0.5,
**kwargs):
"""
Parameters
----------
clock : terrainbento Clock instance
grid : landlab model grid instance
The grid must have all required fields.
m_sp : float, optional
Drainage area exponent (:math:`m`). Default is 0.5.
n_sp : float, optional
Slope exponent (:math:`n`). Default is 1.0.
water_erodibility : float, optional
Water erodibility (:math:`K`). Default is 0.0001.
regolith_transport_parameter : float, optional
Regolith transport efficiency (:math:`D`). Default is 0.1.
soil_production__maximum_rate : float, optional
Maximum rate of soil production (:math:`P_{0}`). Default is 0.001.
soil_production__decay_depth : float, optional
Decay depth for soil production (:math:`H_{s}`). Default is 0.5.
soil_transport_decay_depth : float, optional
Decay depth for soil transport (:math:`H_{0}`). Default is 0.5.
**kwargs :
Keyword arguments to pass to :py:class:`ErosionModel`. Importantly
these arguments specify the precipitator and the runoff generator
that control the generation of surface water discharge (:math:`Q`).
Returns
-------
BasicSa : model object
Examples
--------
This is a minimal example to demonstrate how to construct an instance
of model **BasicSa**. For more detailed examples, including
steady-state test examples, see the terrainbento tutorials.
To begin, import the model class.
>>> from landlab import RasterModelGrid
>>> from landlab.values import random
>>> from terrainbento import Clock, BasicSa
>>> clock = Clock(start=0, stop=100, step=1)
>>> grid = RasterModelGrid((5,5))
>>> _ = random(grid, "topographic__elevation")
>>> _ = random(grid, "soil__depth")
Construct the model.
>>> model = BasicSa(clock, grid)
Running the model with ``model.run()`` would create output, so here we
will just run it one step.
>>> model.run_one_step(1.)
>>> model.model_time
1.0
"""
# Call ErosionModel"s init
super().__init__(clock, grid, **kwargs)
# verify correct fields are present.
self._verify_fields(self._required_fields)
# Get Parameters and convert units if necessary:
self.m = m_sp
self.n = n_sp
self.K = water_erodibility
# Instantiate a FastscapeEroder component
self.eroder = FastscapeEroder(
self.grid,
K_sp=self.K,
m_sp=self.m,
n_sp=self.n,
discharge_field="surface_water__discharge",
erode_flooded_nodes=self._erode_flooded_nodes,
)
soil_thickness = self.grid.at_node["soil__depth"]
bedrock_elev = self.grid.add_zeros("node", "bedrock__elevation")
bedrock_elev[:] = self.z - soil_thickness
# Instantiate diffusion and weathering components
self.weatherer = ExponentialWeatherer(
self.grid,
soil_production__maximum_rate=soil_production__maximum_rate,
soil_production__decay_depth=soil_production__decay_depth,
)
self.diffuser = DepthDependentDiffuser(
self.grid,
linear_diffusivity=regolith_transport_parameter,
soil_transport_decay_depth=soil_transport_decay_depth,
)
def __init__(
self,
clock,
grid,
m_sp=0.5,
n_sp=1.0,
water_erodibility_sediment=0.001,
water_erodibility_rock=0.0001,
regolith_transport_parameter=0.1,
settling_velocity=0.001,
sediment_porosity=0.3,
fraction_fines=0.5,
roughness__length_scale=0.5,
solver="basic",
soil_production__maximum_rate=0.001,
soil_production__decay_depth=0.5,
soil_transport_decay_depth=0.5,
sp_crit_br=0,
sp_crit_sed=0,
**kwargs
):
"""
Parameters
----------
clock : terrainbento Clock instance
grid : landlab model grid instance
The grid must have all required fields.
m_sp : float, optional
Drainage area exponent (:math:`m`). Default is 0.5.
n_sp : float, optional
Slope exponent (:math:`n`). Default is 1.0.
water_erodibility : float, optional
Water erodibility (:math:`K`). Default is 0.0001.
regolith_transport_parameter : float, optional
Regolith transport efficiency (:math:`D`). Default is 0.1.
settling_velocity : float, optional
Normalized settling velocity of entrained sediment (:math:`V_s`).
Default is 0.001.
sediment_porosity : float, optional
Sediment porosity (:math:`\phi`). Default is 0.3.
fraction_fines : float, optional
Fraction of fine sediment that is permanently detached
(:math:`F_f`). Default is 0.5.
roughness__length_scale : float, optional
Bedrock roughness length scale. Default is 0.5.
solver : str, optional
Solver option to pass to the Landlab
`Space <https://landlab.readthedocs.io/en/master/reference/components/space.html>`_
component. Default is "basic".
soil_production__maximum_rate : float, optional
Maximum rate of soil production (:math:`P_{0}`). Default is 0.001.
soil_production__decay_depth : float, optional
Decay depth for soil production (:math:`H_{s}`). Default is 0.5.
soil_transport_decay_depth : float, optional
Decay depth for soil transport (:math:`H_{0}`). Default is 0.5.
**kwargs :
Keyword arguments to pass to :py:class:`ErosionModel`. Importantly
these arguments specify the precipitator and the runoff generator
that control the generation of surface water discharge (:math:`Q`).
Returns
-------
BasicHySa : model object
Examples
--------
This is a minimal example to demonstrate how to construct an instance
of model **BasicHySa**. For more detailed examples, including
steady-state test examples, see the terrainbento tutorials.
To begin, import the model class.
>>> from landlab import RasterModelGrid
>>> from landlab.values import random
>>> from terrainbento import Clock, BasicHySa
>>> clock = Clock(start=0, stop=100, step=1)
>>> grid = RasterModelGrid((5,5))
>>> _ = random(grid, "topographic__elevation")
>>> _ = random(grid, "soil__depth")
Construct the model.
>>> model = BasicHySa(clock, grid)
Running the model with ``model.run()`` would create output, so here we
will just run it one step.
>>> model.run_one_step(1.)
>>> model.model_time
1.0
"""
# Call ErosionModel"s init
super().__init__(clock, grid, **kwargs)
# verify correct fields are present.
self._verify_fields(self._required_fields)
soil_thickness = self.grid.at_node["soil__depth"]
bedrock_elev = self.grid.add_zeros("node", "bedrock__elevation")
bedrock_elev[:] = self.z - soil_thickness
self.m = m_sp
self.n = n_sp
self.K_br = water_erodibility_rock
self.K_sed = water_erodibility_sediment
# Instantiate a SPACE component
self.eroder = Space(
self.grid,
K_sed=self.K_sed,
K_br=self.K_br,
sp_crit_br=sp_crit_br,
sp_crit_sed=sp_crit_sed,
F_f=fraction_fines,
phi=sediment_porosity,
H_star=roughness__length_scale,
v_s=settling_velocity,
m_sp=self.m,
n_sp=self.n,
discharge_field="surface_water__discharge",
solver=solver,
)
# Instantiate diffusion and weathering components
self.weatherer = ExponentialWeatherer(
self.grid,
soil_production__maximum_rate=soil_production__maximum_rate,
soil_production__decay_depth=soil_production__decay_depth,
)
self.diffuser = DepthDependentDiffuser(
self.grid,
linear_diffusivity=regolith_transport_parameter,
soil_transport_decay_depth=soil_transport_decay_depth,
)
self.grid.at_node["soil__depth"][:] = (
self.grid.at_node["topographic__elevation"]
- self.grid.at_node["bedrock__elevation"]
)
K_sp=Kv,
m_sp=msp,
n_sp=nsp,
threshold_sp=0,
rainfall_intensity=1)
fr = FlowRouter(mg)
lm = DepressionFinderAndRouter(mg)
expw = ExponentialWeatherer(mg,
max_soil_production_rate=maxSoilProductionRate,
soil_production_decay_depth=soilProductionDepth)
dld = DepthDependentDiffuser(mg,
linear_diffusivity=linDiff,
soil_transport_decay_depth=soilTransportDepth)
ld = LinearDiffuser(mg, linear_diffusivity=linDiff)
print("finished with the initialization of the erosion components")
print("---------------------")
##---------------------------------Main Loop------------------------------------#
t0 = time.time()
elapsed_time = 0
print("starting with main loop.")
print("---------------------")
#Create incremental counter for controlling progress of mainloop
counter = 0
#Create Limits for DHDT plot. Move this somewhere else later..
K_sed=Kvs,
K_br=Kvb,
F_f=Ff,
phi=phi,
H_star=Hstar,
v_s=vs,
m_sp=m,
n_sp=n,
sp_crit_sed=sp_crit_sedi,
sp_crit_br=sp_crit_bedrock,
solver=solver)
lc = landformClassifier(mg)
DDdiff = DepthDependentDiffuser(mg,
linear_diffusivity=linDiff,
soil_transport_decay_depth=2)
lpj = DynVeg_LpjGuess(LPJGUESS_INPUT_PATH, LPJGUESS_TEMPLATE_PATH,
LPJGUESS_FORCINGS_PATH, LPJGUESS_INS_FILE_TPL,
LPJGUESS_BIN, LPJGUESS_CO2FILE, LPJGUESS_FORCINGS_STRING)
print("finished with the initialization of the erosion components")
print("---------------------")
elapsed_time = 0
counter = 0
while elapsed_time < totalT:
#create copy of "old" topography
z0 = mg.at_node['topographic__elevation'].copy()