def get_params_from_input_file(filename):
"""Fetch parameter values from input file."""
from landlab.core import load_params
mpd_params = load_params(filename)
return mpd_params
def get_params_from_input_file(filename):
"""Fetch parameter values from input file."""
from landlab.core import load_params
mpd_params = load_params(filename)
return mpd_params
def test_from_yaml_path(tmpdir):
"""Load parameters from YAML-formatted string."""
with tmpdir.as_cwd():
with open('params.txt', 'w') as fp:
fp.write(MPD_PARAMS_STR)
params = load_params('./params.txt')
assert params == MPD_PARAMS
assert isinstance(params['x'], float)
assert isinstance(params['y'], int)
def test_from_yaml_path():
"""Load parameters from YAML-formatted string."""
with cdtemp() as dir:
with open('params.txt', 'w') as fp:
fp.write(MPD_PARAMS_STR)
params = load_params('./params.txt')
assert_dict_equal(params, MPD_PARAMS)
assert_is_instance(params['x'], float)
assert_is_instance(params['y'], int)
def test_from_yaml_path():
"""Load parameters from YAML-formatted string."""
with cdtemp() as dir:
with open('params.txt', 'w') as fp:
fp.write(MPD_PARAMS_STR)
params = load_params('./params.txt')
assert_dict_equal(params, MPD_PARAMS)
assert_is_instance(params['x'], float)
assert_is_instance(params['y'], int)
def test_from_mpd_path(tmpdir):
"""Load parameters from YAML-formatted string."""
with tmpdir.as_cwd():
with open("params.txt", "w") as fp:
fp.write(MPD_PARAMS_STR)
params = load_params("./params.txt")
assert params == MPD_PARAMS
assert isinstance(params["x"], float)
assert isinstance(params["y"], int)
def test_marmara(tmpdir, datadir):
with tmpdir.as_cwd():
for fname in datadir.iterdir():
shutil.copy(str(datadir / fname), ".")
params = load_params("marmara.yaml")
model = SequenceModel(**params)
model.run()
assert os.path.isfile("marmara.nc")
def load_model_params(param_file=None, defaults=None, dotted_params=()):
params = defaults or {}
if param_file:
params_from_file = load_params(param_file)
dotted_params += dict_to_dots(params_from_file) + dotted_params
for group in params.keys():
params[group].update(params_from_file.get(group, {}))
params_from_cl = load_params_from_strings(dotted_params)
for group in params.keys():
params[group].update(params_from_cl.get(group, {}))
return params
def test_from_mpd_file_like():
"""Load parameters from YAML-formatted string."""
params = load_params(StringIO(MPD_PARAMS_STR))
assert params == MPD_PARAMS
assert isinstance(params["x"], float)
assert isinstance(params["y"], int)
def test_from_yaml_string():
"""Load parameters from YAML-formatted string."""
params = load_params(YAML_PARAMS_STR)
assert params == YAML_PARAMS
assert isinstance(params["x"], float)
assert isinstance(params["y"], int)
def initialize(self, input_file_name):
"""Initialize by reading parameters from input file."""
params = load_params(input_file_name)
settling_rate = np.sqrt(
params['cell_size'] * params['grav_accel'] / 2.0) * SEC_PER_YEAR
self.run_duration = params['run_duration']
self.output_name = params['output_name']
if 'uplift_duration' in params:
self.uplift_duration = params['uplift_duration']
else:
self.uplift_duration = self.run_duration
if 'include_blocks' in params and params['include_blocks']:
if 'y0_top' in params:
y0_top = params['y0_top']
else:
y0_top = 0.0
if 'layer_left_x' in params:
layer_left_x = params['layer_left_x']
else:
layer_left_x = 0.0
self.model = BlockHill(
(params['number_of_node_rows'],
params['number_of_node_columns']),
report_interval=params['report_interval'],
run_duration=self.run_duration,
output_interval=params['output_interval'],
settling_rate=settling_rate,
disturbance_rate=params['disturbance_rate'],
weathering_rate=params['weathering_rate'],
uplift_interval=params['uplift_interval'],
plot_interval=params['plot_interval'],
friction_coef=params['friction_coef'],
rock_state_for_uplift=params['rock_state_for_uplift'],
opt_rock_collapse=params['opt_rock_collapse'],
show_plots=params['show_plots'],
initial_state_grid=None,
opt_track_grains=params['opt_track_grains'],
block_layer_dip_angle=params['block_layer_dip_angle'],
block_layer_thickness=params['block_layer_thickness'],
y0_top=y0_top,
layer_left_x=layer_left_x,
cmap=get_block_hill_colormap())
self.cmap = get_block_hill_colormap() # use special colormap
else:
self.model = GrainHill(
(params['number_of_node_rows'],
params['number_of_node_columns']),
report_interval=params['report_interval'],
run_duration=self.run_duration,
output_interval=params['output_interval'],
settling_rate=settling_rate,
disturbance_rate=params['disturbance_rate'],
weathering_rate=params['weathering_rate'],
uplift_interval=params['uplift_interval'],
plot_interval=params['plot_interval'],
friction_coef=params['friction_coef'],
rock_state_for_uplift=params['rock_state_for_uplift'],
opt_rock_collapse=params['opt_rock_collapse'],
show_plots=params['show_plots'],
initial_state_grid=None,
opt_track_grains=params['opt_track_grains'])
self.cmap = None # use default GrainHill colormap
if params['plot_to_file']:
self.file_plot_interval = params['plot_interval']
else:
self.file_plot_interval = self.run_duration
self.plot_number = 0
self.find_or_create_output_folder()
self.initialized = True
def test_from_yaml_file_like():
"""Load parameters from YAML-formatted string."""
params = load_params(StringIO(MPD_PARAMS_STR))
assert_dict_equal(params, MPD_PARAMS)
assert_is_instance(params['x'], float)
assert_is_instance(params['y'], int)
def test_from_yaml_file_like():
"""Load parameters from YAML-formatted string."""
params = load_params(StringIO(YAML_PARAMS_STR))
assert params == YAML_PARAMS
assert isinstance(params['x'], float)
assert isinstance(params['y'], int)
def two_node_diff(a):
"""Calculate and return diffs over two nodes instead of one."""
N = len(a)
return a[2:] - a[:(N - 2)]
dx = 0.1 # assumed node spacing, m
input_file_template = '../my_inputs.template'
input_file = 'my_inputs.txt'
# Run dprepro to get right value into the file my_inputs.txt
call(['dprepro', sys.argv[1], input_file_template, input_file])
# Read parameters from the input file
params = load_params(input_file)
domain_length = 10.0**params['number_of_node_columns']
num_cols = int(np.round(domain_length / (dx * 0.866) + 1))
num_rows = int(np.round(0.5 * domain_length / dx))
params['number_of_node_columns'] = num_cols
params['number_of_node_rows'] = num_rows
params['disturbance_rate'] = 10.0**params['disturbance_rate']
params['uplift_interval'] = 10.0**params['uplift_interval']
params['run_duration'] = 0.5 * domain_length * params['uplift_interval'] / dx
params['plot_interval'] = 1.1 * params['run_duration']
params['output_interval'] = params['run_duration']
print params
# Run the model
def test_from_yaml_file_like():
"""Load parameters from YAML-formatted string."""
params = load_params(StringIO(MPD_PARAMS_STR))
assert_dict_equal(params, MPD_PARAMS)
assert_is_instance(params['x'], float)
assert_is_instance(params['y'], int)
def test_from_mpd_string():
"""Load parameters from YAML-formatted string."""
params = load_params(MPD_PARAMS_STR)
assert_dict_equal(params, MPD_PARAMS)
assert_is_instance(params['x'], float)
assert_is_instance(params['y'], int)
def test_from_mpd_string():
"""Load parameters from YAML-formatted string."""
params = load_params(MPD_PARAMS_STR)
assert params == MPD_PARAMS
assert isinstance(params['x'], float)
assert isinstance(params['y'], int)
def create_grid(file_like):
"""Create grid, initialize fields, and set boundary conditions.
**create_grid** expects a dictionary with three keys: "grid", "fields", and
"boundary_conditions".
**Dictionary Section "grid"**
The value associated with the "grid" key should itself be a dictionary
containing the name of a Landlab model grid type as its only key. The
following grid types are valid:
- :py:class:`~landlab.grid.raster.RasterModelGrid`
- :py:class:`~landlab.grid.voronoi.VoronoiDelaunayGrid`
- :py:class:`~landlab.grid.hex.HexModelGrid`
- :py:class:`~landlab.grid.radial.RadialModelGrid`
- :py:class:`~landlab.grid.network.NetworkModelGrid`
The value associated with the grid name key is a list containing the
arguments. If any keyword arguments are passed, they should be passed as
the last element of the list. For example the following code block is a
yaml file indicating a RasterModelGrid with shape (4, 5) and xy-spacing of
(3, 4).
.. code-block:: yaml
grid:
RasterModelGrid:
- [4, 5]
- xy_spacing: [3, 4]
These arguments and keyword arguments will be passed to the ``__init__``
constructor of the specified model grid. Refer to the documentation for
each grid to determine its requirements.
**Dictionary Section "fields"**
Fields can be created by reading from files or by creating synthetic
values.
The value associated with the "fields" key is a nested set of dictionaries
indicating where the fields are created, what the field names are, and how
to create the fields. At the highest hierachical level, the value
associated with the "fields" key must be a dictionary with keys indicating
at which grid elements fields should be created (e.g. to create fields at
node, use "at_node").
The value associated with each "at_xxx" value is itself a dictionary
indicating the name of the field an how it should be created. A field can
either be created by reading from a file or creating synthetic values. The
:py:func:`~landlab.io.netcdf.read.read_netcdf` and
:py:func:`~landlab.io.esri_ascii.read_esri_ascii` functions, and the
:py:mod:`synthetic fields <landlab.values.synthetic>`
package are currently supported methods to create fields. These may be
chained together (as is shown in the Example section below). If these
functions do not meet your needs, we welcome contributions that extend the
capabilities of this function.
The following example would uses the
:py:func:`~landlab.values.synthetic.plane` function from the synthetic
values package to create an at_node value for the field
topographic__elevation. The plane function adds values to a Landlab model
grid field that lie on a plane specified by a point and a normal vector. In
the below example the plane goes through the point (1.0, 1.0, 1.0) and has
a normal of (-2.0, -1.0, 1.0).
.. code-block:: yaml
fields:
at_node:
topographic__elevation:
plane:
- point: [1, 1, 1]
normal: [-2, -1, 1]
**Dictionary Section "boundary_conditions"**
The final portion of the input dictionary calls bound functions of the
model grid to set boundary conditions. Any valid bound function can be
called. The specified functions are provided in a list, and called in
order. If required, multiple functions may be called.
Each entry to the list is a dictionary with a single key, the name of the
bound function. The value associated with that key is a list of arguments
and keyword arguments, similar in structure to those described above.
For example, the following sets closed boundaries at all sides of the grid.
.. code-block:: yaml
boundary_conditions:
- set_closed_boundaries_at_grid_edges:
- True
- True
- True
- True
Parameters
----------
file_like : file_like or str
Dictionary, contents of a dictionary as a string, a file-like object,
or the path to a file containing a YAML dictionary.
Examples
--------
>>> import numpy as np
>>> np.random.seed(42)
>>> from landlab import create_grid
>>> p = {'grid': {'RasterModelGrid': [(4,5),
... {'xy_spacing': (3, 4)}]
... },
... 'fields': {'at_node': {'spam': {'plane': [{'point': (1, 1, 1),
... 'normal': (-2, -1, 1)}],
... 'random': [{'distribution': 'uniform',
... 'low': 1,
... 'high': 4}]
... },
... },
... 'at_link': {'eggs': {'constant': [{'where': 'ACTIVE_LINK',
... 'constant': 12}],
... },
... },
... },
... 'boundary_conditions': [
... {'set_closed_boundaries_at_grid_edges':
... [True, True, True, True]
... }]
... }
>>> mg = create_grid(p)
>>> mg.number_of_nodes
20
>>> "spam" in mg.at_node
True
>>> "eggs" in mg.at_link
True
>>> mg.x_of_node
array([ 0., 3., 6., 9., 12.,
0., 3., 6., 9., 12.,
0., 3., 6., 9., 12.,
0., 3., 6., 9., 12.])
>>> mg.status_at_node
array([4, 4, 4, 4, 4,
4, 0, 0, 0, 4,
4, 0, 0, 0, 4,
4, 4, 4, 4, 4], dtype=uint8)
>>> np.round(mg.at_node['spam'].reshape(mg.shape), decimals=2)
array([[ 0.12, 7.85, 13.2 , 18.8 , 23.47],
[ 3.47, 9.17, 17.6 , 22.8 , 29.12],
[ 7.06, 15.91, 21.5 , 25.64, 31.55],
[ 11.55, 17.91, 24.57, 30.3 , 35.87]])
"""
# part 0, parse input
if isinstance(file_like, dict):
dict_like = file_like
else:
dict_like = load_params(file_like)
# part 1 create grid
grid_dict = dict_like.pop("grid", None)
if grid_dict is None:
msg = "create_grid: no grid dictionary provided. This is required."
raise ValueError(msg)
for grid_type in grid_dict:
if grid_type in _MODEL_GRIDS:
grid_class = _MODEL_GRIDS[grid_type]
else:
msg = "create_grid: provided grid type not supported."
raise ValueError
if len(grid_dict) != 1:
msg = ("create_grid: two entries to grid dictionary provided. "
"This is not supported.")
raise ValueError
args, kwargs = _parse_args_kwargs(grid_dict.pop(grid_type))
grid = grid_class(*args, **kwargs)
# part two, create fields
fields_dict = dict_like.pop("fields", {})
# for each grid element:
for at_group in fields_dict:
at = at_group[3:]
if at not in grid.groups:
msg = (
"create_grid: No field location ",
"{at} ".format(at=at),
"exists for grid types",
"{grid}. ".format(grid=grid_type),
)
raise ValueError(msg)
at_dict = fields_dict[at_group]
# for field at grid element
for name in at_dict:
name_dict = at_dict[name]
# for each function, add values.
for func in name_dict:
args, kwargs = _parse_args_kwargs(name_dict[func])
if func in _SYNTHETIC_FIELD_CONSTRUCTORS:
# if any args, raise an error, there shouldn't be any.
synth_function = _SYNTHETIC_FIELD_CONSTRUCTORS[func]
synth_function(grid, name, at=at, **kwargs)
elif func == "read_esri_ascii":
read_esri_ascii(*args, grid=grid, name=name, **kwargs)
elif func == "read_netcdf":
read_netcdf(*args, grid=grid, name=name, **kwargs)
else:
msg = (
"create_grid: Bad function ",
"{func} ".format(func=func),
"for creating a field.",
)
raise ValueError(msg)
# part three, set boundary conditions
bc_list = dict_like.pop("boundary_conditions", [])
for bc_function_dict in bc_list:
if len(bc_function_dict) != 1:
msg = ("create_grid: two entries to a boundary condition function "
"dictionary were provided. This is not supported.")
raise ValueError(msg)
for bc_function in bc_function_dict:
args, kwargs = _parse_args_kwargs(bc_function_dict[bc_function])
methods = dict(inspect.getmembers(grid, inspect.ismethod))
if bc_function in methods:
methods[bc_function](*args, **kwargs)
else:
msg = (
"create_grid: No function ",
"{func} ".format(func=bc_function),
"exists for grid types ",
"{grid}. ".format(grid=grid_type),
"If you think this type of grid should have such a ",
"function. Please create a GitHub Issue to discuss ",
"contributing it to the Landlab codebase.",
)
raise ValueError(msg)
return grid
def test_from_mpd_string():
"""Load parameters from YAML-formatted string."""
params = load_params(MPD_PARAMS_STR)
assert_dict_equal(params, MPD_PARAMS)
assert_is_instance(params['x'], float)
assert_is_instance(params['y'], int)
