diff --git a/landlab/components/__init__.py b/landlab/components/__init__.py
index e9c3396245..7a607f4edd 100644
--- a/landlab/components/__init__.py
+++ b/landlab/components/__init__.py
@@ -60,6 +60,7 @@
from .priority_flood_flow_router import PriorityFloodFlowRouter
from .profiler import ChannelProfiler, Profiler, TrickleDownProfiler
from .radiation import Radiation
+from .river_flow_dynamics import river_flow_dynamics
from .sink_fill import SinkFiller, SinkFillerBarnes
from .soil_moisture import SoilInfiltrationGreenAmpt, SoilMoisture
from .space import Space, SpaceLargeScaleEroder
@@ -138,6 +139,7 @@
PrecipitationDistribution,
Profiler,
Radiation,
+ river_flow_dynamics,
SedDepEroder,
SedimentPulserAtLinks,
SedimentPulserEachParcel,
diff --git a/landlab/components/river_flow_dynamics/__init__.py b/landlab/components/river_flow_dynamics/__init__.py
new file mode 100644
index 0000000000..ba4d1f1711
--- /dev/null
+++ b/landlab/components/river_flow_dynamics/__init__.py
@@ -0,0 +1,3 @@
+from .river_flow_dynamics import river_flow_dynamics
+
+__all__ = ["river_flow_dynamics"]
diff --git a/landlab/components/river_flow_dynamics/river_flow_dynamics.py b/landlab/components/river_flow_dynamics/river_flow_dynamics.py
new file mode 100644
index 0000000000..3d83bc3c63
--- /dev/null
+++ b/landlab/components/river_flow_dynamics/river_flow_dynamics.py
@@ -0,0 +1,1906 @@
+"""river_flow_dynamics.py
+
+This component runs a semi-implicit, semi-Lagrangian
+finite-volume approximation to the depth-averaged shallow
+water equations of Casulli and Cheng (1992) and related work.
+
+Written by Sebastian Bernal and Angel Monsalve.
+
+Last updated: August 11, 2023
+
+Examples
+--------
+
+Simulation of River Flow Dynamics
+
+This example demonstrates how to simulate river flow dynamics using the Landlab library.
+
+First, let's import necessary libraries such as NumPy, Matplotlib, and Landlab components.
+
+>>> import numpy as np
+>>> import matplotlib.pyplot as plt
+>>> from landlab import RasterModelGrid
+>>> from landlab.components import river_flow_dynamics
+>>> from landlab.io import read_esri_ascii
+>>> from landlab.plot.imshow import imshow_grid
+
+Now, create a rectangular grid for flow dynamics calculations with specified dimensions and cell size.
+
+>>> nRows = 20
+>>> nCols = 60
+>>> cellSize = 0.1
+>>> grid = RasterModelGrid((nRows,nCols), xy_spacing=(cellSize,cellSize))
+
+Defining the Topography: Set up the initial topographic elevation for the grid, creating a basic rectangular channel with a slope of 0.01.
+
+>>> te = grid.add_zeros("topographic__elevation", at="node")
+>>> te += 0.059 - 0.01*grid.x_of_node
+>>> te[grid.y_of_node > 1.5] = 1.0
+>>> te[grid.y_of_node < 0.5] = 1.0
+
+We can use `imshow_grid` to visualize the elevation profile.
+Let's take a look at the grid's middle longitudinal section.
+
+>>> middleBedProfile = np.reshape(te,(nRows,nCols))[10,:]
+>>> np.round(middleBedProfile,3)
+array([ 0.059, 0.058, 0.057, 0.056, 0.055, 0.054, 0.053, 0.052,
+ 0.051, 0.05 , 0.049, 0.048, 0.047, 0.046, 0.045, 0.044,
+ 0.043, 0.042, 0.041, 0.04 , 0.039, 0.038, 0.037, 0.036,
+ 0.035, 0.034, 0.033, 0.032, 0.031, 0.03 , 0.029, 0.028,
+ 0.027, 0.026, 0.025, 0.024, 0.023, 0.022, 0.021, 0.02 ,
+ 0.019, 0.018, 0.017, 0.016, 0.015, 0.014, 0.013, 0.012,
+ 0.011, 0.01 , 0.009, 0.008, 0.007, 0.006, 0.005, 0.004,
+ 0.003, 0.002, 0.001, -0. ])
+
+Instantiating the component: Initialize the river_flow_dynamics component with specified parameters, including time step and Manning's roughness coefficient.
+
+The grid will need some data to run the river_flow_dynamics component.
+To check the names of the required inputs use the *input_var_names*
+class property.
+
+>>> river_flow_dynamics.input_var_names
+('surface_water__depth',
+ 'surface_water__elevation',
+ 'surface_water__velocity',
+ 'topographic__elevation')
+
+Also, if we want to know where these fields are mapped use:
+
+>>> river_flow_dynamics.var_mapping
+(('surface_water__depth', 'node'),
+ ('surface_water__elevation', 'node'),
+ ('surface_water__velocity', 'link'),
+ ('topographic__elevation', 'node'))
+
+Create fields of data for each of these input variables. The channel is
+empty at the beginning of the simulation, so we create the water depth field.
+
+>>> h = grid.add_zeros("surface_water__depth", at="node")
+
+Water velocity is zero everywhere since there is no water yet.
+
+>>> vel = grid.add_zeros("surface_water__velocity", at="link")
+
+Calculating the initial water surface elevation from water depth and topographic elevation.
+
+>>> wse = grid.add_zeros("surface_water__elevation", at="node")
+>>> wse += h + te
+
+Then, we specify the nodes at which water is entering into the domain, and also the associated links.
+These will be the inlet boundary conditions for water depth and velocity.
+In this case, water flows from left to right at 0.5 m depth, with a velocity of 0.45 m/s.
+
+>>> fixed_entry_nodes = np.arange(300,910,60)
+>>> fixed_entry_links = grid.links_at_node[fixed_entry_nodes][:,0]
+
+And we set the fixed values in these entry nodes/links.
+
+>>> entry_nodes_h_values = np.full(11, 0.5)
+>>> entry_links_vel_values = np.full(11, 0.45)
+
+We instantiate river_flow_dynamics with the arguments we defined previously:
+
+>>> rfd = river_flow_dynamics(grid, dt=0.1, mannings_n=0.012, fixed_entry_nodes=fixed_entry_nodes,
+... fixed_entry_links=fixed_entry_links,entry_nodes_h_values=entry_nodes_h_values,
+... entry_links_vel_values=entry_links_vel_values)
+
+And we run the simulation for 100 timesteps (10 seconds):
+
+>>> n_timesteps = 100
+>>> for timestep in range(n_timesteps):
+... rfd.run_one_step()
+
+Let's see what the flow depth at the center of the channel is after 10 seconds.
+
+>>> np.reshape(grid['node']["surface_water__depth"],(nRows,nCols))[10,:]
+array([ 0.5 , 0.49119496, 0.48070117, 0.47309464, 0.46764464,
+ 0.46370528, 0.46076177, 0.45840315, 0.45619896, 0.45419369,
+ 0.45250159, 0.45106348, 0.44972981, 0.4484113 , 0.44702824,
+ 0.445566 , 0.44414898, 0.44279566, 0.44144646, 0.44007219,
+ 0.43868299, 0.43726816, 0.43582451, 0.4344022 , 0.43300387,
+ 0.43159008, 0.43012984, 0.42867334, 0.42723278, 0.42577057,
+ 0.42426757, 0.42277662, 0.42127323, 0.41977445, 0.41825745,
+ 0.41674194, 0.41522539, 0.41368181, 0.41214349, 0.41060916,
+ 0.40905859, 0.40748906, 0.40591859, 0.40435914, 0.40275767,
+ 0.40113684, 0.39954249, 0.39795401, 0.39635525, 0.39474439,
+ 0.39313631, 0.39155279, 0.38993334, 0.38828883, 0.38664499,
+ 0.3849828 , 0.38333126, 0.381655 , 0.37977436, 0.37881807])
+
+And the velocity at links laong the center of the channel
+
+>>> linksAtCenter = grid.links_at_node[np.array(np.arange(600,660))][:-1,0]
+>>> grid['link']["surface_water__velocity"][linksAtCenter]
+array([ 0.45 , 0.59396861, 0.69574417, 0.75731793, 0.79261482,
+ 0.8123394 , 0.82700801, 0.84314289, 0.85567049, 0.85979031,
+ 0.85838515, 0.85658338, 0.85716582, 0.85944389, 0.86308335,
+ 0.86497462, 0.86463743, 0.86367451, 0.86314567, 0.86565779,
+ 0.86981418, 0.8726041 , 0.87338014, 0.87403681, 0.87494614,
+ 0.87549414, 0.87571505, 0.87786193, 0.87953196, 0.8794075 ,
+ 0.88030366, 0.88296806, 0.88376619, 0.88519116, 0.88610576,
+ 0.88744898, 0.88909536, 0.8898242 , 0.89135825, 0.89318975,
+ 0.89358086, 0.89405077, 0.89630327, 0.89764043, 0.8976985 ,
+ 0.89895516, 0.90065785, 0.90219923, 0.90227029, 0.90168375,
+ 0.90460332, 0.90538973, 0.9036968 , 0.90546049, 0.90666316,
+ 0.90682276, 0.90754984, 0.90761995, 0.91305765])
+
+"""
+
+import numpy as np
+import scipy as sp
+
+from landlab import Component, FieldError
+
+
+class river_flow_dynamics(Component):
+ """Simulate surface fluid flow based on Casulli and Cheng (1992).
+
+ Landlab component that simulates surface fluid flow using the Casulli and Cheng (1992)
+ approximations of the 2D shallow water equations.
+
+ This components calculates water depth and velocity across the raster grid, given
+ a certain input discharge.
+
+ References
+ ----------
+ **Required Software Citation(s) Specific to this Component**
+
+ None Listed
+
+ **Additional References**
+
+ Casulli, V., Cheng, R.T. (1992). “Semi-implicit finite difference methods for
+ three-dimensional shallow water flow”. International Journal for Numerical Methods
+ in Fluids. 15: 629-648.
+ https://doi.org/10.1002/fld.1650150602
+
+ """
+
+ _name = "river_flow_dynamics"
+
+ _unit_agnostic = False
+
+ _info = {
+ "surface_water__depth": {
+ "dtype": float,
+ "intent": "inout",
+ "optional": False,
+ "units": "m",
+ "mapping": "node",
+ "doc": "Depth of water on the surface",
+ },
+ "surface_water__velocity": {
+ "dtype": float,
+ "intent": "inout",
+ "optional": False,
+ "units": "m/s",
+ "mapping": "link",
+ "doc": "Speed of water flow above the surface",
+ },
+ "surface_water__elevation": {
+ "dtype": float,
+ "intent": "inout",
+ "optional": False,
+ "units": "m",
+ "mapping": "node",
+ "doc": "Water surface elevation at time N",
+ },
+ "topographic__elevation": {
+ "dtype": float,
+ "intent": "in",
+ "optional": False,
+ "units": "m",
+ "mapping": "node",
+ "doc": "Land surface topographic elevation",
+ },
+ }
+
+ def __init__(
+ self,
+ grid,
+ dt=0.01, # Sets the time step (s)
+ eddy_viscosity=1e-4, # ddy viscosity coefficient
+ mannings_n=0.012, # Manning's n
+ threshold_depth=0.01, # Sets the wet/dry threshold
+ theta=0.5, # Degree of 'implicitness' of the solution
+ fixed_entry_nodes=[], # Node IDs where flow enters the domain
+ fixed_entry_links=[], # Link IDs where flow enters the domain
+ entry_nodes_h_values=[], # Water depth at nodes where flow enters the domain
+ entry_links_vel_values=[], # Water velocity at links where flow enters the domain
+ pcg_tolerance=1e-05, # Preconditioned Conjugate Gradient convergence tolerance
+ pcg_max_iterations=None, # Preconditioned Conjugate Gradient max iterations
+ surface_water__elevation_at_N_1=None, # Sets the surface water elevation at previous time
+ surface_water__elevation_at_N_2=None, # Sets the surface water elevation at previous previous time
+ surface_water__velocity_at_N_1=None, # Sets the speed of water flow above the surface at time N-1
+ ):
+ """Simulate the vertical-averaged surface fluid flow
+
+ Landlab component that simulates surface fluid flow using the Casulli and Cheng (1992)
+ approximations of the 2D shallow water equations.
+
+ This components calculates water depth and velocity across the raster grid, given
+ a certain input discharge.
+
+ Parameters
+ ----------
+ grid : RasterModelGrid
+ A grid.
+ dt : float, optional
+ Time step in seconds. If not given, it is calculated from CFL condition.
+ eddy_viscosity : float, optional
+ Eddy viscosity coefficient. Default = 1e-4 :math:`m^2 / s`
+ mannings_n : float or array_like, optional
+ Manning's roughness coefficient. Default = 0.012 :math:`s / m^1/3`
+ threshold_depth : float, optional
+ Threshold at which a cell is considered wet. Default = 0.01 m
+ theta : float, optional
+ Degree of 'implicitness' of the solution, ranging between 0.5 and 1.0. Default = 0.5.
+ When it is equal to 0.5, the approximation is centered in time.
+ When it is equal to 1.0, the approximation is fully implicit.
+ fixed_entry_nodes : array_like or None, optional
+ Node IDs where flow enters the domain (Dirichlet boundary condition).
+ If not provided, the water already present in the domain is not renewed.
+ fixed_entry_links : array_like or None, optional
+ Link IDs where flow enters the domain (Dirichlet boundary condition).
+ If not provided, the water already present in the domain is not renewed.
+ entry_nodes_h_values : array_like, optional
+ Water depth values at nodes where flow enters the domain (Dirichlet boundary condition).
+ If not provided, the water already present in the domain is not renewed.
+ entry_links_vel_values : array_like, optional
+ Water velocity values at links where flow enters the domain (Dirichlet boundary condition).
+ If not provided, the water already present in the domain is not renewed.
+ pcg_tolerance : float, optional
+ Preconditioned Conjugate Gradient method argument. Tolerance for convergence.
+ Default = 1e-05
+ pcg_max_iterations : integer, optional
+ Preconditioned Conjugate Gradient method argument. Maximum number of iterations.
+ Iteration will stop after maxiter steps even if the specified tolerance has not been achieved.
+ Default = None
+ surface_water__elevation_at_N_1: float, optional
+ Water surface elevation at time N-1.
+ units: m, mapping: node
+ surface_water__elevation_at_N_2: float, optional
+ Water surface elevation at time N-2.
+ units: m, mapping: node
+ surface_water__velocity_at_N_1: float, optional
+ Speed of water flow above the surface at time N-1",
+ units: m/2, mapping: link
+ """
+ super().__init__(grid)
+
+ # User inputs
+ self._dt = dt
+ self._eddy_viscosity = eddy_viscosity
+ self._g = sp.constants.g
+ self._mannings_n = mannings_n
+ self._threshold_depth = threshold_depth
+ self._theta = theta
+ self._fixed_entry_nodes = fixed_entry_nodes
+ self._fixed_entry_links = fixed_entry_links
+ self._entry_nodes_h_values = entry_nodes_h_values
+ self._entry_links_vel_values = entry_links_vel_values
+ self._pcg_tolerance = pcg_tolerance
+ self._pcg_max_iterations = pcg_max_iterations
+
+ # Getting topography for further calculations
+ self._additional_z = 10 # To set the virtual reference elevation (z=0)
+ self._max_elevation = self._grid["node"]["topographic__elevation"].max()
+ self._z = self._grid["node"]["topographic__elevation"]
+ self._z = (self._z.max() + self._additional_z) - self._z
+
+ # Creating fields if they don't exist
+ try:
+ self._grid["node"]["surface_water__depth"] = grid.add_zeros(
+ "surface_water__depth",
+ at="node",
+ units=self._info["surface_water__depth"]["units"],
+ )
+ except FieldError:
+ self._grid["node"]["surface_water__depth"] = grid.at_node[
+ "surface_water__depth"
+ ]
+
+ try:
+ self._grid["link"]["surface_water__velocity"] = grid.add_zeros(
+ "surface_water__velocity",
+ at="link",
+ units=self._info["surface_water__velocity"]["units"],
+ )
+ except FieldError:
+ self._grid["link"]["surface_water__velocity"] = grid.at_link[
+ "surface_water__velocity"
+ ]
+
+ try:
+ self._grid["node"]["surface_water__elevation"] = grid.add_zeros(
+ "surface_water__elevation",
+ at="node",
+ units=self._info["surface_water__elevation"]["units"],
+ )
+ self._grid["node"]["surface_water__elevation"] = (
+ self._grid["node"]["surface_water__depth"] - self._z
+ )
+ except FieldError:
+ self._grid["node"]["surface_water__elevation"] = grid.at_node[
+ "surface_water__elevation"
+ ]
+
+ if surface_water__elevation_at_N_1 is None:
+ self._surface_water__elevation_at_N_1 = np.zeros(self._grid.number_of_nodes)
+ else:
+ if surface_water__elevation_at_N_1.size > 0:
+ if (
+ surface_water__elevation_at_N_1.shape[0]
+ == self._grid.number_of_nodes
+ ):
+ self._surface_water__elevation_at_N_1 = (
+ surface_water__elevation_at_N_1
+ )
+ else:
+ raise ValueError(
+ "surface_water__elevation_at_N_1 \
+ does not have the same dimensions of the grid's nodes"
+ )
+
+ if surface_water__elevation_at_N_2 is None:
+ self._surface_water__elevation_at_N_2 = np.zeros(self._grid.number_of_nodes)
+ else:
+ if surface_water__elevation_at_N_2.size > 0:
+ if (
+ surface_water__elevation_at_N_2.shape[0]
+ == self._grid.number_of_nodes
+ ):
+ self._surface_water__elevation_at_N_2 = (
+ surface_water__elevation_at_N_2
+ )
+ else:
+ raise ValueError(
+ "surface_water__elevation_at_N_2 \
+ does not have the same dimensions of the grid's nodes"
+ )
+
+ if surface_water__velocity_at_N_1 is None:
+ self._surface_water__velocity_at_N_1 = np.zeros(self._grid.number_of_links)
+ else:
+ if surface_water__velocity_at_N_1.size > 0:
+ if (
+ surface_water__velocity_at_N_1.shape[0]
+ == self._grid.number_of_links
+ ):
+ self._surface_water__velocity_at_N_1 = (
+ surface_water__velocity_at_N_1
+ )
+ else:
+ raise ValueError(
+ "surface_water__velocity_at_N_1 \
+ does not have the same dimensions of the grid's links"
+ )
+
+ # Assigning a class variable to the fields
+ self._h = self._grid["node"]["surface_water__depth"]
+ self._vel = self._grid["link"]["surface_water__velocity"]
+ self._vel_at_N_1 = self._surface_water__velocity_at_N_1
+ self._eta = self._grid["node"]["surface_water__elevation"] - (
+ self._max_elevation + self._additional_z
+ )
+ self._eta_at_N_1 = self._surface_water__elevation_at_N_1 - (
+ self._max_elevation + self._additional_z
+ )
+ self._eta_at_N_2 = self._surface_water__elevation_at_N_2 - (
+ self._max_elevation + self._additional_z
+ )
+
+ # Getting nodes and links at each edge
+ self._nodes_at_right_edge = self._grid.nodes_at_right_edge
+ self._nodes_at_top_edge = self._grid.nodes_at_top_edge
+ self._nodes_at_left_edge = self._grid.nodes_at_left_edge
+ self._nodes_at_bottom_edge = self._grid.nodes_at_bottom_edge
+
+ # links_at_right_edge = self._grid.links_at_node[self._nodes_at_right_edge][:, 2]
+ # links_at_top_edge = self._grid.links_at_node[self._nodes_at_top_edge][:, 3]
+ # links_at_left_edge = self._grid.links_at_node[self._nodes_at_left_edge][:, 0]
+ # links_at_bottom_edge = self._grid.links_at_node[self._nodes_at_bottom_edge][:, 1]
+
+ self._nx = len(self._nodes_at_top_edge)
+ self._ny = len(self._nodes_at_left_edge)
+
+ self._dx = self._grid.dx
+ self._dy = self._grid.dy
+
+ # Open boundary conditions (water can leave the domain at everywhere, only limited by topography)
+ self._grid.status_at_node[
+ self._nodes_at_left_edge
+ ] = self._grid.BC_NODE_IS_FIXED_VALUE
+ self._grid.status_at_node[
+ self._nodes_at_right_edge
+ ] = self._grid.BC_NODE_IS_FIXED_VALUE
+ self._grid.status_at_node[
+ self._nodes_at_bottom_edge
+ ] = self._grid.BC_NODE_IS_FIXED_VALUE
+ self._grid.status_at_node[
+ self._nodes_at_top_edge
+ ] = self._grid.BC_NODE_IS_FIXED_VALUE
+
+ # Identifying node and link ids for later use.
+ self._core_nodes = self._grid.core_nodes
+ self._corner_nodes = self._grid.corner_nodes
+ self._active_links = self._grid.active_links
+ self._horizontal_links = self._grid.horizontal_links
+ self._vertical_links = self._grid.vertical_links
+ self._number_of_nodes = self._grid.number_of_nodes
+
+ self._adjacent_nodes_at_corner_nodes = np.array(
+ [
+ [
+ self._nodes_at_top_edge[-2],
+ self._nodes_at_right_edge[-2],
+ ], # Top right
+ [self._nodes_at_top_edge[1], self._nodes_at_left_edge[-2]], # Top left
+ [
+ self._nodes_at_left_edge[1],
+ self._nodes_at_bottom_edge[1],
+ ], # Bottom left
+ [
+ self._nodes_at_right_edge[1],
+ self._nodes_at_bottom_edge[-2],
+ ], # Bottom right
+ ]
+ )
+
+ # Updating open boundary nodes/links
+ self._open_boundary_nodes = self._grid.boundary_nodes
+ self._open_boundary_links = np.unique(
+ self._grid.links_at_node[self._open_boundary_nodes]
+ )
+
+ self._open_boundary_nodes = np.setdiff1d(
+ self._open_boundary_nodes, self._fixed_entry_nodes
+ )
+ self._open_boundary_links = np.setdiff1d(
+ self._open_boundary_links, self._fixed_entry_links
+ )
+
+ self._fixed_corner_nodes = np.setdiff1d(
+ self._corner_nodes, self._open_boundary_nodes
+ )
+ self._open_corner_nodes = np.setdiff1d(
+ self._corner_nodes, self._fixed_corner_nodes
+ )
+
+ self._open_boundary_nodes = np.setdiff1d(
+ self._open_boundary_nodes, self._open_corner_nodes
+ )
+
+ # Using fixed entry nodes/links only when they exist
+ if len(self._fixed_entry_nodes) > 0:
+ self._fixed_nodes_exist = True
+ else:
+ self._fixed_nodes_exist = False
+
+ if len(self._fixed_entry_links) > 0:
+ self._fixed_links_exist = True
+ else:
+ self._fixed_links_exist = False
+
+ # Updating grid fixed values according to the user input
+ if self._fixed_nodes_exist is True:
+ self._h[self._fixed_entry_nodes] = entry_nodes_h_values
+ self._eta[self._fixed_entry_nodes] = (
+ entry_nodes_h_values - self._z[self._fixed_entry_nodes]
+ )
+ if self._fixed_links_exist is True:
+ self._vel[self._fixed_entry_links] = entry_links_vel_values
+
+ # Mapping node values at links
+ self._z_at_links = self._grid.map_mean_of_link_nodes_to_link(self._z)
+ self._h_at_links = self._grid.map_mean_of_link_nodes_to_link(self._h)
+ self._eta_at_links = self._h_at_links - self._z_at_links
+
+ # Passing values to the time step N
+ self._h_at_N = self._h.copy()
+ self._h_at_N_at_links = self._grid.map_mean_of_link_nodes_to_link(self._h_at_N)
+
+ self._vel_at_N = self._vel.copy()
+ self._eta_at_N = self._eta.copy()
+
+ # Boolean for wet nodes/links
+ self._wet_nodes = np.where(self._h_at_N >= self._threshold_depth, True, False)
+ self._wet_links = np.where(
+ self._h_at_N_at_links >= self._threshold_depth, True, False
+ )
+
+ # Defining some functions
+ def find_nearest_link(self, x_coordinates, y_coordinates, objective_links="all"):
+ """Link nearest a point.
+
+ Find the index to the link nearest the given x, y coordinates.
+ Returns the indices of the links nearest the given coordinates.
+
+ """
+ # Defining the set of links that are going to be used
+ if objective_links == "all":
+ objective_links = np.arange(self._grid.number_of_links)
+ elif objective_links == "horizontal":
+ objective_links = self._horizontal_links
+ elif objective_links == "vertical":
+ objective_links = self._vertical_links
+ # if (objective_links == "all") END
+
+ # Coordinates of all the RasterModelGrid links
+ x_of_objective_links = np.unique(self._grid.xy_of_link[objective_links][:, 0])
+ y_of_objective_links = np.unique(self._grid.xy_of_link[objective_links][:, 1])
+
+ # Getting the closest link-coordinate to the exit point
+ tempCalc1 = np.repeat(x_coordinates, len(x_of_objective_links)).reshape(
+ len(x_coordinates), len(x_of_objective_links)
+ )
+ tempCalc2 = np.tile(x_of_objective_links, len(x_coordinates)).reshape(
+ len(x_coordinates), len(x_of_objective_links)
+ )
+ indices = abs(tempCalc2 - tempCalc1).argmin(axis=1)
+ nearest_x = x_of_objective_links[indices]
+
+ tempCalc1 = np.repeat(y_coordinates, len(y_of_objective_links)).reshape(
+ len(y_coordinates), len(y_of_objective_links)
+ )
+ tempCalc2 = np.tile(y_of_objective_links, len(y_coordinates)).reshape(
+ len(y_coordinates), len(y_of_objective_links)
+ )
+ indices = abs(tempCalc2 - tempCalc1).argmin(axis=1)
+ nearest_y = y_of_objective_links[indices]
+
+ # Getting the closest link to link
+ tempCalc1 = np.repeat(
+ nearest_x, len(self._grid.xy_of_link[objective_links][:, 0])
+ ).reshape(len(nearest_x), len(self._grid.xy_of_link[objective_links][:, 0]))
+ tempCalc2 = np.tile(
+ self._grid.xy_of_link[objective_links][:, 0], len(x_coordinates)
+ ).reshape(len(x_coordinates), len(self._grid.xy_of_link[objective_links][:, 0]))
+ tempB1 = tempCalc1 == tempCalc2
+
+ tempCalc1 = np.repeat(
+ nearest_y, len(self._grid.xy_of_link[objective_links][:, 1])
+ ).reshape(len(nearest_y), len(self._grid.xy_of_link[objective_links][:, 1]))
+ tempCalc2 = np.tile(
+ self._grid.xy_of_link[objective_links][:, 1], len(y_coordinates)
+ ).reshape(len(y_coordinates), len(self._grid.xy_of_link[objective_links][:, 1]))
+ tempB2 = tempCalc1 == tempCalc2
+
+ tempCalc3 = (
+ np.repeat(objective_links, len(x_coordinates))
+ .reshape((len(objective_links), len(y_coordinates)))
+ .T
+ )
+ nearest_link = tempCalc3[tempB1 * tempB2]
+
+ return nearest_link.astype(int)
+
+ def find_adjacent_links_at_link(self, current_link, objective_links="horizontal"):
+ """Get adjacent links to the link.
+
+ This function finds the links at right, above, left and below the given link.
+ Similar purpose to the "adjacent_nodes_at_node" function.
+ Return the adjacent links in as many rows as given links.
+ Link IDs are returned as columns in clock-wise order starting from East (E, N, W, S).
+
+ """
+
+ # Defining the set of links that are going to be used
+ if objective_links == "horizontal":
+ objective_links = self._horizontal_links
+ reshape_pair = (self._ny, self._nx - 1)
+ elif objective_links == "vertical":
+ objective_links = self._vertical_links
+ reshape_pair = (self._ny - 1, self._nx)
+ # if (objective_links == "horizontal") END
+
+ # Coordinates of the current link
+ x_of_current_links = self._grid.xy_of_link[current_link][:, 0]
+ y_of_current_links = self._grid.xy_of_link[current_link][:, 1]
+
+ # Coordinates of all the RasterModelGrid links
+ x_of_objective_links = np.unique(self._grid.xy_of_link[objective_links][:, 0])
+ y_of_objective_links = np.unique(self._grid.xy_of_link[objective_links][:, 1])
+
+ # Getting links that share the same y-coordinates
+ # The following matrices are built to be compared to each other.
+ # tempCalc1 repeats "y_of_current_links" for every x-coordinate in "objective_links": cols = "y_of_current_links"
+ # tempCalc2 repeats "y_of_objective_links" for every x-coordinate in the "current_link": rows = "y_of_objective_links"
+ # tempCalc3 give us the index to extract all the objective links that are located in the same row than the current link: rows = [0, 1, 2, ...]
+ tempCalc1 = np.repeat(y_of_current_links, len(y_of_objective_links)).reshape(
+ len(y_of_current_links), len(y_of_objective_links)
+ )
+ tempCalc2 = np.tile(y_of_objective_links, len(y_of_current_links)).reshape(
+ len(y_of_current_links), len(y_of_objective_links)
+ )
+ tempCalc3 = (
+ np.repeat(np.arange(len(y_of_objective_links)), len(y_of_current_links))
+ .reshape(len(y_of_objective_links), len(y_of_current_links))
+ .T
+ )
+
+ indices = tempCalc3[tempCalc1 == tempCalc2]
+ links_at_same_rows = objective_links.reshape(reshape_pair)[indices, :]
+ links_at_same_rows = np.append(
+ np.array([-np.ones_like(current_link)]).T, links_at_same_rows, axis=1
+ )
+ links_at_same_rows = np.append(
+ links_at_same_rows, np.array([-np.ones_like(current_link)]).T, axis=1
+ )
+
+ # Getting links that share the same x-coordinates
+ # The following matrices are built to be compared to each other.
+ # tempCalc1 repeats "x_of_current_links" for every x-coordinate in "objective_links": cols = "x_of_current_links"
+ # tempCalc2 repeats "x_of_objective_links" for every x-coordinate in the "current_link": rows = "x_of_objective_links"
+ # tempCalc3 give us the index to extract all the objective links that are located in the same row than the current link: rows = [0, 1, 2, ...]
+ tempCalc1 = np.repeat(x_of_current_links, len(x_of_objective_links)).reshape(
+ len(x_of_current_links), len(x_of_objective_links)
+ )
+ tempCalc2 = np.tile(x_of_objective_links, len(x_of_current_links)).reshape(
+ len(x_of_current_links), len(x_of_objective_links)
+ )
+ tempCalc3 = (
+ np.repeat(np.arange(len(x_of_objective_links)), len(x_of_current_links))
+ .reshape(len(x_of_objective_links), len(x_of_current_links))
+ .T
+ )
+
+ indices = tempCalc3[tempCalc1 == tempCalc2]
+ links_at_same_cols = objective_links.reshape(reshape_pair)[:, indices].T
+ links_at_same_cols = np.append(
+ np.array([-np.ones_like(current_link)]).T, links_at_same_cols, axis=1
+ )
+ links_at_same_cols = np.append(
+ links_at_same_cols, np.array([-np.ones_like(current_link)]).T, axis=1
+ )
+
+ # Extracing the adjacent links to current link (E,N,W,S)
+ adjacent_links_at_link = np.zeros((current_link.shape[0], 4))
+
+ # Rows (E,W)
+ tempCalc1 = np.repeat(current_link, links_at_same_rows.shape[1]).reshape(
+ current_link.shape[0], links_at_same_rows.shape[1]
+ )
+ tempCalc2 = (
+ np.repeat(np.arange(links_at_same_rows.shape[1]), current_link.shape[0])
+ .reshape(links_at_same_rows.shape[1], current_link.shape[0])
+ .T
+ )
+ tempCalc3 = tempCalc2[tempCalc1 == links_at_same_rows]
+
+ adjacent_links_at_link[:, 0] = links_at_same_rows[
+ (range(links_at_same_rows.shape[0])), (tempCalc3 + 1)
+ ]
+ adjacent_links_at_link[:, 2] = links_at_same_rows[
+ (range(links_at_same_rows.shape[0])), (tempCalc3 - 1)
+ ]
+
+ # Cols (N,S)
+ tempCalc1 = np.repeat(current_link, links_at_same_cols.shape[1]).reshape(
+ current_link.shape[0], links_at_same_cols.shape[1]
+ )
+ tempCalc2 = (
+ np.repeat(np.arange(links_at_same_cols.shape[1]), current_link.shape[0])
+ .reshape(links_at_same_cols.shape[1], current_link.shape[0])
+ .T
+ )
+ tempCalc3 = tempCalc2[tempCalc1 == links_at_same_cols]
+
+ adjacent_links_at_link[:, 1] = links_at_same_cols[
+ (range(links_at_same_cols.shape[0])), (tempCalc3 + 1)
+ ]
+ adjacent_links_at_link[:, 3] = links_at_same_cols[
+ (range(links_at_same_cols.shape[0])), (tempCalc3 - 1)
+ ]
+
+ return adjacent_links_at_link.astype(int)
+
+ def path_line_tracing(self):
+ """ " Path line tracing algorithm.
+
+ This function implements the semi-analytical path line tracing method of Pollock (1988).
+
+ The semi-analytical path line tracing method was developed for particle tracking in ground
+ water flow models. The assumption that each directional velocity component varies linearly
+ in its coordinate directions within each computational volume or cell underlies the method.
+ Linear variation allows the derivation of an analytical expression for the path line of a
+ particle across a volume.
+
+ Given an initial point located at each volume faces of the domain, particle trayectories are
+ traced backwards on time. Then, this function returns the departure point of the particle at
+ the beginning of the time step.
+
+ """
+
+ # Calculating the partial time-step TAUx, TAUy, dt - sum_partial_times
+ sum_partial_times = np.zeros_like(self._u_vel_of_particle)
+ remaining_time = self._dt - sum_partial_times
+ keep_tracing = np.where(remaining_time > 0, True, False)
+
+ while np.any(remaining_time > 0):
+ # Using the previous exit point as the new entry point
+ self._x_of_particle = np.where(keep_tracing, self._x_at_exit_point, self._x_of_particle)
+ self._y_of_particle = np.where(
+ keep_tracing , self._y_at_exit_point, self._y_of_particle
+ )
+
+ # Checking if the particles departs (backwards) from a link position (True)
+ tempBx = np.isin(
+ self._x_of_particle, self._grid.xy_of_link[self._active_links][:, 0]
+ ) # Particles located on horizontal-links/vertical-faces
+ tempBy = np.isin(
+ self._y_of_particle, self._grid.xy_of_link[self._active_links][:, 1]
+ ) # Particles located on vertical-links/horizontal-faces
+
+ # True, particles depart from link positions.
+ # False, particles depart from random locations inside a cell
+ tempBxy = tempBx + tempBy
+
+ # Getting surrounding links for particles located inside a cell
+ tempCalc1 = np.append(
+ np.array([self._x_of_particle]), np.array([self._y_of_particle]), axis=0
+ )
+ tempCalc2 = self._grid.find_nearest_node(tempCalc1, mode="raise")
+ temp_links_from_node = self._grid.links_at_node[tempCalc2]
+ nodes_from_particle = tempCalc2
+
+ # Getting surrounding links for particles located at link positions
+ tempCalc1 = np.where(
+ self._u_vel_of_particle >= 0,
+ np.array([self._x_of_particle]) - self._dx / 10,
+ np.array([self._x_of_particle]) + self._dx / 10,
+ )
+ tempCalc2 = np.where(
+ self._v_vel_of_particle >= 0,
+ np.array([self._y_of_particle]) - self._dy / 10,
+ np.array([self._y_of_particle]) + self._dy / 10,
+ )
+ tempCalc3 = np.append(tempCalc1, tempCalc2, axis=0)
+ tempCalc4 = self._grid.find_nearest_node(tempCalc3, mode="raise")
+ temp_links_from_link = self._grid.links_at_node[tempCalc4]
+ nodes_from_particle = np.where(
+ tempBxy , tempCalc4, nodes_from_particle
+ )
+
+ # Getting links around particle
+ tempBxy = np.tile(tempBxy, 4).reshape(4, len(tempBxy)).T
+ links_at_particle = np.where(
+ tempBxy , temp_links_from_link, temp_links_from_node
+ )
+
+ # Defining links based on velocity direction
+ link_at_x2 = np.where(
+ self._u_vel_of_particle >= 0,
+ links_at_particle[:, 0],
+ links_at_particle[:, 2],
+ )
+ link_at_x1 = np.where(
+ self._u_vel_of_particle >= 0,
+ links_at_particle[:, 2],
+ links_at_particle[:, 0],
+ )
+ link_at_y2 = np.where(
+ self._v_vel_of_particle >= 0,
+ links_at_particle[:, 1],
+ links_at_particle[:, 3],
+ )
+ link_at_y1 = np.where(
+ self._v_vel_of_particle >= 0,
+ links_at_particle[:, 3],
+ links_at_particle[:, 1],
+ )
+
+ x_at_x2 = np.where(
+ self._u_vel_of_particle >= 0,
+ self._grid.x_of_node[nodes_from_particle] + self._dx / 2,
+ self._grid.x_of_node[nodes_from_particle] - self._dx / 2,
+ )
+ x_at_x1 = np.where(
+ self._u_vel_of_particle >= 0,
+ self._grid.x_of_node[nodes_from_particle] - self._dx / 2,
+ self._grid.x_of_node[nodes_from_particle] + self._dx / 2,
+ )
+ y_at_y2 = np.where(
+ self._v_vel_of_particle >= 0,
+ self._grid.y_of_node[nodes_from_particle] + self._dy / 2,
+ self._grid.y_of_node[nodes_from_particle] - self._dy / 2,
+ )
+ y_at_y1 = np.where(
+ self._v_vel_of_particle >= 0,
+ self._grid.y_of_node[nodes_from_particle] - self._dy / 2,
+ self._grid.y_of_node[nodes_from_particle] + self._dy / 2,
+ )
+
+ # Getting velocity around the particle
+ u_vel_at_x2 = np.where(
+ link_at_x2 >= 0, self._vel_at_N[link_at_x2], self._vel_at_N[link_at_x1]
+ )
+ u_vel_at_x1 = np.where(
+ link_at_x1 >= 0, self._vel_at_N[link_at_x1], self._vel_at_N[link_at_x2]
+ )
+ v_vel_at_y2 = np.where(
+ link_at_y2 >= 0, self._vel_at_N[link_at_y2], self._vel_at_N[link_at_y1]
+ )
+ v_vel_at_y1 = np.where(
+ link_at_y1 >= 0, self._vel_at_N[link_at_y1], self._vel_at_N[link_at_y2]
+ )
+
+ # Calculating gradients for path line tracing
+ gradient_x_direction = (u_vel_at_x2 - u_vel_at_x1) / self._dx
+ gradient_y_direction = (v_vel_at_y2 - v_vel_at_y1) / self._dy
+
+ # Calculating entry velocity for each particle
+ self._u_vel_of_particle = u_vel_at_x2 - gradient_x_direction * (
+ x_at_x2 - self._x_of_particle
+ )
+ self._v_vel_of_particle = v_vel_at_y2 - gradient_y_direction * (
+ y_at_y2 - self._y_of_particle
+ )
+ self._u_vel_of_particle = np.where(
+ self._u_vel_of_particle < 1e-10, 0, self._u_vel_of_particle
+ )
+ self._v_vel_of_particle = np.where(
+ self._v_vel_of_particle < 1e-10, 0, self._v_vel_of_particle
+ )
+
+ ### Calculation accoss x-direction
+ # Avoiding divisions by zero
+ tempCalc1 = np.where(
+ self._u_vel_of_particle == 0, 9999, self._u_vel_of_particle
+ )
+ tempCalc2 = np.where(u_vel_at_x1 == 0, 9999, u_vel_at_x1)
+ tempCalc3 = np.where(gradient_x_direction == 0, 9999, gradient_x_direction)
+ TAUx = (1 / tempCalc3) * np.log(abs(tempCalc1 / tempCalc2))
+
+ # Calculation when gradient is equal to zero
+ tempCalc4 = abs((self._x_of_particle - x_at_x1) / tempCalc2)
+ TAUx = np.where(gradient_x_direction == 0, tempCalc4, TAUx)
+
+ # Calculation when:
+ # a) Uxp/Ux1 = 1,
+ # b) Uxp,Vyp = 0,
+ # c) Ux1,Vy1 = 0, and
+ # d) Uxp/Ux1, Vxp/Vy1 = -1
+ tempCalc5 = self._u_vel_of_particle / tempCalc2
+ TAUx = np.where(tempCalc5 == 1, tempCalc4, TAUx)
+ TAUx = np.where(self._u_vel_of_particle == 0, remaining_time, TAUx)
+ TAUx = np.where(u_vel_at_x1 == 0, remaining_time, TAUx)
+ TAUx = np.where(tempCalc5 < 0, remaining_time, TAUx)
+ TAUx = np.where(TAUx > self._dt, self._dt, TAUx)
+ TAUx = np.where(TAUx < 0, 0, TAUx)
+
+ ### Calculation across y-direction
+ # Avoiding divisions by zero
+ tempCalc1 = np.where(
+ self._v_vel_of_particle == 0, 9999, self._v_vel_of_particle
+ )
+ tempCalc2 = np.where(v_vel_at_y1 == 0, 9999, v_vel_at_y1)
+ tempCalc3 = np.where(gradient_y_direction == 0, 9999, gradient_y_direction)
+ TAUy = (1 / tempCalc3) * np.log(abs(tempCalc1 / tempCalc2))
+
+ # Calculation when gradient is equal to zero
+ tempCalc4 = abs((self._y_of_particle - y_at_y1) / tempCalc2)
+ TAUy = np.where(gradient_y_direction == 0, tempCalc4, TAUy)
+
+ # Calculation when
+ # a) Vyp/Vy1 = 1,
+ # b) Uxp,Vyp = 0,
+ # c) Ux1,Vy1 = 0, and
+ # d) Uxp/Ux1, Vxp/Vy1 = -1
+ tempCalc5 = self._v_vel_of_particle / tempCalc2
+ TAUy = np.where(tempCalc5 == 1, tempCalc4, TAUy)
+ TAUy = np.where(self._v_vel_of_particle == 0, remaining_time, TAUy)
+ TAUy = np.where(v_vel_at_y1 == 0, remaining_time, TAUy)
+ TAUy = np.where(tempCalc5 < 0, remaining_time, TAUy)
+ TAUy = np.where(TAUy > self._dt, self._dt, TAUy)
+ TAUy = np.where(TAUy < 0, 0, TAUy)
+
+ # Obtaining TAU = min(TAUx, TAUy, (dt - sum_partial_times))
+ TAUx = abs(TAUx)
+ TAUy = abs(TAUy)
+ TAU = np.array((TAUx, TAUy, remaining_time)).min(axis=0)
+ # TAU = np.where(TAU < 1e-10, 0, TAU)
+
+ # Calculating exit point Xe, Ye
+ tempCalc1 = np.where(gradient_x_direction == 0, 9999, gradient_x_direction)
+ tempCalc2 = np.where(gradient_y_direction == 0, 9999, gradient_y_direction)
+
+ # Exit point Xe (tempCalc3) and Ye (tempCalc4)
+ tempCalc3 = x_at_x2 - (1 / tempCalc1) * (
+ u_vel_at_x2
+ - self._u_vel_of_particle / np.exp(gradient_x_direction * TAU)
+ )
+ tempCalc4 = y_at_y2 - (1 / tempCalc2) * (
+ v_vel_at_y2
+ - self._v_vel_of_particle / np.exp(gradient_y_direction * TAU)
+ )
+
+ tempCalc3 = np.where(
+ gradient_x_direction == 0,
+ self._x_of_particle - u_vel_at_x2 * TAU,
+ tempCalc3,
+ )
+ tempCalc4 = np.where(
+ gradient_y_direction == 0,
+ self._y_of_particle - v_vel_at_y2 * TAU,
+ tempCalc4,
+ )
+
+ tempCalc3 = np.where(
+ self._u_vel_of_particle == 0, self._x_of_particle, tempCalc3
+ )
+ tempCalc4 = np.where(
+ self._v_vel_of_particle == 0, self._y_of_particle, tempCalc4
+ )
+
+ self._x_at_exit_point = np.where(
+ keep_tracing , tempCalc3, self._x_at_exit_point
+ )
+ self._y_at_exit_point = np.where(
+ keep_tracing , tempCalc4, self._y_at_exit_point
+ )
+
+ # Updating sum of partial time-steps, TAU
+ sum_partial_times = np.where(
+ keep_tracing , sum_partial_times + TAU, self._dt
+ )
+
+ # Checking remaining_time == 0 (dt = sum_partial_times)
+ remaining_time = np.where(
+ remaining_time == 0, 0, self._dt - sum_partial_times
+ )
+
+ # Correcting entry velocity
+ tempCalc1 = np.where(self._u_vel_of_particle == 0, 1, 0)
+ tempCalc2 = np.where(self._v_vel_of_particle == 0, 1, 0)
+ remaining_time = np.where((tempCalc1 * tempCalc2) == 1, 0, remaining_time)
+
+ # Correction for static particles
+ remaining_time = np.where(
+ abs(self._x_of_particle - self._x_at_exit_point) < 1e-7,
+ 0,
+ remaining_time,
+ )
+ remaining_time = np.where(
+ abs(self._y_of_particle - self._y_at_exit_point) < 1e-7,
+ 0,
+ remaining_time,
+ )
+
+ # Stop tracing if a particle hits the boundary
+ # Keep tracing for all particles
+ tempCalc1 = np.repeat(True, len(keep_tracing))
+ # Particle hits the left edge?
+ tempCalc2 = np.isin(
+ self._x_at_exit_point, self._grid.x_of_node[self._nodes_at_left_edge]
+ )
+ # If above True, stop tracing for that particle
+ tempCalc1 = np.where(tempCalc2 , False, tempCalc1)
+ # Particle hits the right edge?
+ tempCalc2 = np.isin(
+ self._x_at_exit_point, self._grid.x_of_node[self._nodes_at_right_edge]
+ )
+ # If above True, stop tracing for that particle
+ tempCalc1 = np.where(tempCalc2 , False, tempCalc1)
+ # Particle hits the top edge?
+ tempCalc2 = np.isin(
+ self._y_at_exit_point, self._grid.y_of_node[self._nodes_at_top_edge]
+ )
+ # If above True, stop tracing for that particle
+ tempCalc1 = np.where(tempCalc2 , False, tempCalc1)
+ # Particle hits the bottom edge?
+ tempCalc2 = np.isin(
+ self._y_at_exit_point, self._grid.y_of_node[self._nodes_at_bottom_edge]
+ )
+ # If above True, stop tracing for that particle
+ tempCalc1 = np.where(tempCalc2 , False, tempCalc1)
+ # Where particles reach the boundary, remaining time is equal to zero
+ #remaining_time = np.where(not tempCalc1, 0, remaining_time)
+ remaining_time = np.where(~tempCalc1, 0, remaining_time)
+
+
+ # Updating on particles that need to traced backwards
+ keep_tracing = np.where(remaining_time > 0, True, False)
+
+ # WHILE "np.any(remaining_time > 0)" END
+ # DEF "path_line_tracing(self)" END
+
+ def run_one_step(self):
+ """Calculate water depth and water velocity for a time period dt."""
+
+ # Getting velocity as U,V components
+ self._u_vel = self._vel_at_N[self._horizontal_links]
+ self._v_vel = self._vel_at_N[self._vertical_links]
+
+ # Calculating Chezy coefficient
+ self._chezy_at_nodes = self._h_at_N ** (1 / 6) / self._mannings_n
+ self._chezy_at_links = self._h_at_N_at_links ** (1 / 6) / self._mannings_n
+
+ # Computing V-velocity (vertical links) at U-velocity positions (horizontal links)
+ tempCalc1 = self._grid.map_mean_of_horizontal_links_to_node(self._vel_at_N)
+ self._u_vel_at_v_links = np.mean(
+ tempCalc1[self._grid.nodes_at_link[self._vertical_links]], axis=1
+ )
+
+ # Computing U-velocity (horizontal links) at V-velocity positions (vertical links)
+ tempCalc1 = self._grid.map_mean_of_vertical_links_to_node(self._vel_at_N)
+ self._v_vel_at_u_links = np.mean(
+ tempCalc1[self._grid.nodes_at_link[self._horizontal_links]], axis=1
+ )
+
+ """ Setting A-faces """
+ # Setting A-faces
+ self._a_links = np.zeros_like(self._vel_at_N)
+
+ # Setting dry links equal to 1 to avoid divisions by zero
+ tempCalc1 = np.where(self._wet_links , self._chezy_at_links, 1)
+
+ # Computing A-faces
+ self._a_links[self._horizontal_links] = (
+ self._h_at_N_at_links[self._horizontal_links]
+ + self._g
+ * self._dt
+ * (
+ self._vel_at_N[self._horizontal_links] ** 2
+ + self._v_vel_at_u_links**2
+ )
+ ** (1 / 2)
+ / tempCalc1[self._horizontal_links]
+ )
+ self._a_links[self._vertical_links] = (
+ self._h_at_N_at_links[self._vertical_links]
+ + self._g
+ * self._dt
+ * (self._vel_at_N[self._vertical_links] ** 2 + self._u_vel_at_v_links**2)
+ ** (1 / 2)
+ / tempCalc1[self._vertical_links]
+ )
+
+ # Using only wet-link values, and setting dry links equal to 1 to avoid divisions by zero
+ self._a_links = np.where(self._wet_links , self._a_links, 1)
+
+ """ Path line tracing
+ U-velocity, x-direction, horizontal links
+ """
+ # Getting the initial particle location at each volume faces
+ tempB1 = [i in self._horizontal_links for i in self._active_links]
+ self._x_of_particle = self._grid.xy_of_link[:, 0][self._active_links][tempB1]
+ self._y_of_particle = self._grid.xy_of_link[:, 1][self._active_links][tempB1]
+
+ # Getting the initial particle velocity
+ tempB2 = [i in self._active_links for i in self._horizontal_links]
+ self._u_vel_of_particle = self._u_vel[tempB2]
+ self._v_vel_of_particle = self._v_vel_at_u_links[tempB2]
+
+ # Getting a first 'exit' point to begin the loop
+ self._x_at_exit_point = self._x_of_particle
+ self._y_at_exit_point = self._y_of_particle
+
+ # Calculating path line backwards on time
+ self.path_line_tracing()
+
+ """ Bicuatradic interpolation
+ U-velocity, x-direction, around (p,q) location
+ """
+ self._UsL = np.zeros_like(self._u_vel)
+
+ # Getting V-velocity at U-links
+ temp_Vvel = np.zeros_like(self._vel_at_N)
+ temp_Vvel[self._horizontal_links] = self._v_vel_at_u_links
+
+ # Getting links around the particle and defining downstream direction based on velocity
+ nearest_link_to_particle = self.find_nearest_link(
+ self._x_at_exit_point, self._y_at_exit_point, objective_links="horizontal"
+ )
+ adjacent_links_to_particle = self.find_adjacent_links_at_link(
+ nearest_link_to_particle, objective_links="horizontal"
+ )
+
+ link_at_B2 = nearest_link_to_particle
+ link_at_A2 = adjacent_links_to_particle[:, 1] # 1: N, top
+ link_at_C2 = adjacent_links_to_particle[:, 3] # 3: S, bottom
+ link_at_A2 = np.where(temp_Vvel[link_at_B2] >= 0, link_at_A2, link_at_C2)
+ link_at_C2 = np.where(temp_Vvel[link_at_B2] >= 0, link_at_C2, link_at_A2)
+ # We avoid "-1" links close to the boundary
+ link_at_A2 = np.where(link_at_A2 >= 0, link_at_A2, link_at_B2)
+ link_at_C2 = np.where(link_at_C2 >= 0, link_at_C2, link_at_B2)
+
+ # Getting the surrounding links to every particle from closest link
+ # 0: E, Right
+ # 2: W, Left
+ link_at_A1 = self.find_adjacent_links_at_link(
+ link_at_A2, objective_links="horizontal"
+ )[:, 0]
+ link_at_A3 = self.find_adjacent_links_at_link(
+ link_at_A2, objective_links="horizontal"
+ )[:, 2]
+
+ # Selecting downstream link based on velocity direction
+ link_at_A1 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_A1, link_at_A3)
+ link_at_A3 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_A3, link_at_A1)
+
+ link_at_B1 = self.find_adjacent_links_at_link(
+ link_at_B2, objective_links="horizontal"
+ )[
+ :, 0
+ ] # 0: E, Right
+ link_at_B3 = self.find_adjacent_links_at_link(
+ link_at_B2, objective_links="horizontal"
+ )[
+ :, 2
+ ] # 2: W, Left
+
+ # Selecting downstream link based on velocity direction
+ link_at_B1 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_B1, link_at_B3)
+ link_at_B3 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_B3, link_at_B1)
+
+ link_at_C1 = self.find_adjacent_links_at_link(
+ link_at_C2, objective_links="horizontal"
+ )[
+ :, 0
+ ] # 0: E, Right
+ link_at_C3 = self.find_adjacent_links_at_link(
+ link_at_C2, objective_links="horizontal"
+ )[
+ :, 2
+ ] # 2: W, Left
+
+ # Selecting downstream link based on velocity direction
+ link_at_C1 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_C1, link_at_C3)
+ link_at_C3 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_C3, link_at_C1)
+
+ # Getting velocity around the particle
+ vel_at_A1 = np.where(
+ link_at_A1 >= 0, self._vel_at_N[link_at_A1], self._vel_at_N[link_at_A2]
+ )
+ vel_at_A2 = self._vel_at_N[link_at_A2]
+ vel_at_A3 = np.where(
+ link_at_A3 >= 0, self._vel_at_N[link_at_A3], self._vel_at_N[link_at_A2]
+ )
+
+ vel_at_B1 = np.where(
+ link_at_B1 >= 0, self._vel_at_N[link_at_B1], self._vel_at_N[link_at_B2]
+ )
+ vel_at_B2 = self._vel_at_N[link_at_B2]
+ vel_at_B3 = np.where(
+ link_at_B3 >= 0, self._vel_at_N[link_at_B3], self._vel_at_N[link_at_B2]
+ )
+
+ vel_at_C1 = np.where(
+ link_at_C1 >= 0, self._vel_at_N[link_at_C1], self._vel_at_N[link_at_C2]
+ )
+ vel_at_C2 = self._vel_at_N[link_at_C2]
+ vel_at_C3 = np.where(
+ link_at_C3 >= 0, self._vel_at_N[link_at_C3], self._vel_at_N[link_at_C2]
+ )
+
+ # Getting coordinates around the particle
+ x_at_2 = self._grid.xy_of_link[link_at_B2][:, 0]
+ x_at_1 = np.where(
+ self._vel_at_N[link_at_B2] >= 0, x_at_2 + self._dx, x_at_2 - self._dx
+ )
+ x_at_3 = np.where(
+ self._vel_at_N[link_at_B2] >= 0, x_at_2 - self._dx, x_at_2 + self._dx
+ )
+
+ y_at_B = self._grid.xy_of_link[link_at_B2][:, 1]
+ y_at_A = np.where(
+ temp_Vvel[link_at_B2] >= 0, y_at_B + self._dy, y_at_B - self._dy
+ )
+ y_at_C = np.where(
+ temp_Vvel[link_at_B2] >= 0, y_at_B - self._dy, y_at_B + self._dy
+ )
+
+ # Calculating the weights W(i,j) for k around x-direction
+ W1 = (
+ (self._x_at_exit_point - x_at_2)
+ * (self._x_at_exit_point - x_at_3)
+ / ((x_at_1 - x_at_2) * (x_at_1 - x_at_3))
+ )
+ W2 = (
+ (self._x_at_exit_point - x_at_1)
+ * (self._x_at_exit_point - x_at_3)
+ / ((x_at_2 - x_at_1) * (x_at_2 - x_at_3))
+ )
+ W3 = (
+ (self._x_at_exit_point - x_at_1)
+ * (self._x_at_exit_point - x_at_2)
+ / ((x_at_3 - x_at_1) * (x_at_3 - x_at_2))
+ )
+
+ # Interpolation by row around 'x_at_exit_point'
+ A = W1 * vel_at_A1 + W2 * vel_at_A2 + W3 * vel_at_A3
+ B = W1 * vel_at_B1 + W2 * vel_at_B2 + W3 * vel_at_B3
+ C = W1 * vel_at_C1 + W2 * vel_at_C2 + W3 * vel_at_C3
+
+ # Calculating the weghts W(i,j) for l around y-direction
+ W1 = (
+ (self._y_at_exit_point - y_at_B)
+ * (self._y_at_exit_point - y_at_C)
+ / ((y_at_A - y_at_B) * (y_at_A - y_at_C))
+ )
+ W2 = (
+ (self._y_at_exit_point - y_at_A)
+ * (self._y_at_exit_point - y_at_C)
+ / ((y_at_B - y_at_A) * (y_at_B - y_at_C))
+ )
+ W3 = (
+ (self._y_at_exit_point - y_at_A)
+ * (self._y_at_exit_point - y_at_B)
+ / ((y_at_C - y_at_A) * (y_at_C - y_at_B))
+ )
+
+ # Calculating UsL by bicuadratic interpolation
+ self._UsL[tempB2] = W1 * A + W2 * B + W3 * C
+
+ """ Computing viscous terms
+ U-located particles
+ """
+ # Central difference scheme around x- and y- direction for U-located particles
+ self._Uvis = np.zeros_like(self._u_vel)
+
+ tempCalc1 = (
+ self._eddy_viscosity
+ * self._dt
+ * (vel_at_B3 - 2 * vel_at_B2 + vel_at_B1)
+ / (self._dx**2)
+ )
+ tempCalc2 = (
+ self._eddy_viscosity
+ * self._dt
+ * (vel_at_C2 - 2 * vel_at_B2 + vel_at_A2)
+ / (self._dy**2)
+ )
+
+ self._Uvis[tempB2] = tempCalc1 + tempCalc2
+
+ """ Path line tracing
+ V-velocity, y-direction, vertical links
+ """
+ # Getting the initial particle location at each volume faces
+ tempB1 = [j in self._vertical_links for j in self._active_links]
+ self._x_of_particle = self._grid.xy_of_link[:, 0][self._active_links][tempB1]
+ self._y_of_particle = self._grid.xy_of_link[:, 1][self._active_links][tempB1]
+
+ # Getting the initial particle velocity
+ tempB2 = [j in self._active_links for j in self._vertical_links]
+ self._v_vel_of_particle = self._v_vel[tempB2]
+ self._u_vel_of_particle = self._u_vel_at_v_links[tempB2]
+
+ # Getting a first 'exit' point to begin the loop
+ self._x_at_exit_point = self._x_of_particle
+ self._y_at_exit_point = self._y_of_particle
+
+ # Calculating path line backwards on time
+ self.path_line_tracing()
+
+ """ Bicuatradic interpolation
+ V-velocity, y-direction, around (p,q) location
+ """
+ self._VsL = np.zeros_like(self._v_vel)
+
+ # Getting V-velocity at U-links
+ temp_Uvel = np.zeros_like(self._vel_at_N)
+ temp_Uvel[self._vertical_links] = self._u_vel_at_v_links
+
+ # Getting links around the particle and defining downstream direction based on velocity
+ nearest_link_to_particle = self.find_nearest_link(
+ self._x_at_exit_point, self._y_at_exit_point, objective_links="vertical"
+ )
+ adjacent_links_to_particle = self.find_adjacent_links_at_link(
+ nearest_link_to_particle, objective_links="vertical"
+ )
+
+ link_at_B2 = nearest_link_to_particle
+ link_at_A2 = adjacent_links_to_particle[:, 1] # 1: N, top
+ link_at_C2 = adjacent_links_to_particle[:, 3] # 3: S, bottom
+ link_at_A2 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_A2, link_at_C2)
+ link_at_C2 = np.where(self._vel_at_N[link_at_B2] >= 0, link_at_C2, link_at_A2)
+ link_at_A2 = np.where(link_at_A2 >= 0, link_at_A2, link_at_B2)
+ link_at_C2 = np.where(link_at_C2 >= 0, link_at_C2, link_at_B2)
+ # We avoid "-1" links close to the boundary
+
+ # Getting the surrounding links to every particle from closest link
+ link_at_A1 = self.find_adjacent_links_at_link(
+ link_at_A2, objective_links="vertical"
+ )[
+ :, 0
+ ] # 0: E, Left
+ link_at_A3 = self.find_adjacent_links_at_link(
+ link_at_A2, objective_links="vertical"
+ )[
+ :, 2
+ ] # 2: W, Right
+
+ # Selecting downstream link based on velocity direction
+ link_at_A1 = np.where(temp_Uvel[link_at_B2] >= 0, link_at_A1, link_at_A3)
+ link_at_A3 = np.where(temp_Uvel[link_at_B2] >= 0, link_at_A3, link_at_A1)
+
+ link_at_B1 = self.find_adjacent_links_at_link(
+ link_at_B2, objective_links="vertical"
+ )[
+ :, 0
+ ] # 0: E, Left
+ link_at_B3 = self.find_adjacent_links_at_link(
+ link_at_B2, objective_links="vertical"
+ )[
+ :, 2
+ ] # 2: W, Right
+
+ # Selecting downstream link based on velocity direction
+ link_at_B1 = np.where(temp_Uvel[link_at_B2] >= 0, link_at_B1, link_at_B3)
+ link_at_B3 = np.where(temp_Uvel[link_at_B2] >= 0, link_at_B3, link_at_B1)
+
+ link_at_C1 = self.find_adjacent_links_at_link(
+ link_at_C2, objective_links="vertical"
+ )[
+ :, 0
+ ] # 0: E, Left
+ link_at_C3 = self.find_adjacent_links_at_link(
+ link_at_C2, objective_links="vertical"
+ )[
+ :, 2
+ ] # 2: W, Right
+
+ # Selecting downstream link based on velocity direction
+ link_at_C1 = np.where(temp_Uvel[link_at_B2] >= 0, link_at_C1, link_at_C3)
+ link_at_C3 = np.where(temp_Uvel[link_at_B2] >= 0, link_at_C3, link_at_C1)
+
+ # Getting velocity around the particle
+ vel_at_A1 = np.where(
+ link_at_A1 >= 0, self._vel_at_N[link_at_A1], self._vel_at_N[link_at_A2]
+ )
+ vel_at_A2 = self._vel_at_N[link_at_A2]
+ vel_at_A3 = np.where(
+ link_at_A3 >= 0, self._vel_at_N[link_at_A3], self._vel_at_N[link_at_A2]
+ )
+
+ vel_at_B1 = np.where(
+ link_at_B1 >= 0, self._vel_at_N[link_at_B1], self._vel_at_N[link_at_B2]
+ )
+ vel_at_B2 = self._vel_at_N[link_at_B2]
+ vel_at_B3 = np.where(
+ link_at_B3 >= 0, self._vel_at_N[link_at_B3], self._vel_at_N[link_at_B2]
+ )
+
+ vel_at_C1 = np.where(
+ link_at_C1 >= 0, self._vel_at_N[link_at_C1], self._vel_at_N[link_at_C2]
+ )
+ vel_at_C2 = self._vel_at_N[link_at_C2]
+ vel_at_C3 = np.where(
+ link_at_C3 >= 0, self._vel_at_N[link_at_C3], self._vel_at_N[link_at_C2]
+ )
+
+ # Getting coordinates around the particle
+ x_at_2 = self._grid.xy_of_link[link_at_B2][:, 0]
+ x_at_1 = np.where(
+ temp_Uvel[link_at_B2] >= 0, x_at_2 + self._dx, x_at_2 - self._dx
+ )
+ x_at_3 = np.where(
+ temp_Uvel[link_at_B2] >= 0, x_at_2 - self._dx, x_at_2 + self._dx
+ )
+
+ y_at_B = self._grid.xy_of_link[link_at_B2][:, 1]
+ y_at_A = np.where(
+ self._vel_at_N[link_at_B2] >= 0, y_at_B + self._dy, y_at_B - self._dy
+ )
+ y_at_C = np.where(
+ self._vel_at_N[link_at_B2] >= 0, y_at_B - self._dy, y_at_B + self._dy
+ )
+
+ # Calculating the weights W(i,j) for k around x-direction
+ W1 = (
+ (self._x_at_exit_point - x_at_2)
+ * (self._x_at_exit_point - x_at_3)
+ / ((x_at_1 - x_at_2) * (x_at_1 - x_at_3))
+ )
+ W2 = (
+ (self._x_at_exit_point - x_at_1)
+ * (self._x_at_exit_point - x_at_3)
+ / ((x_at_2 - x_at_1) * (x_at_2 - x_at_3))
+ )
+ W3 = (
+ (self._x_at_exit_point - x_at_1)
+ * (self._x_at_exit_point - x_at_2)
+ / ((x_at_3 - x_at_1) * (x_at_3 - x_at_2))
+ )
+
+ # Interpolation by row around 'y_at_exit_point'
+ A = W1 * vel_at_A1 + W2 * vel_at_A2 + W3 * vel_at_A3
+ B = W1 * vel_at_B1 + W2 * vel_at_B2 + W3 * vel_at_B3
+ C = W1 * vel_at_C1 + W2 * vel_at_C2 + W3 * vel_at_C3
+
+ # Calculating the weghts W(i,j) for l around y-direction
+ W1 = (
+ (self._y_at_exit_point - y_at_B)
+ * (self._y_at_exit_point - y_at_C)
+ / ((y_at_A - y_at_B) * (y_at_A - y_at_C))
+ )
+ W2 = (
+ (self._y_at_exit_point - y_at_A)
+ * (self._y_at_exit_point - y_at_C)
+ / ((y_at_B - y_at_A) * (y_at_B - y_at_C))
+ )
+ W3 = (
+ (self._y_at_exit_point - y_at_A)
+ * (self._y_at_exit_point - y_at_B)
+ / ((y_at_C - y_at_A) * (y_at_C - y_at_B))
+ )
+
+ # Calculating VsL by bicuadratic interpolation
+ self._VsL[tempB2] = W1 * A + W2 * B + W3 * C
+
+ """ Computing viscous terms
+ V-located particles
+ """
+ # Central difference scheme around x- and y- direction for V-located particles
+ self._Vvis = np.zeros_like(self._v_vel)
+
+ tempCalc1 = (
+ self._eddy_viscosity
+ * self._dt
+ * (vel_at_B3 - 2 * vel_at_B2 + vel_at_B1)
+ / (self._dx**2)
+ )
+ tempCalc2 = (
+ self._eddy_viscosity
+ * self._dt
+ * (vel_at_C2 - 2 * vel_at_B2 + vel_at_A2)
+ / (self._dy**2)
+ )
+
+ self._Vvis[tempB2] = tempCalc1 + tempCalc2
+
+ """ Computing advective terms F(U,V)
+ """
+ # Computing advective terms (FU, FV)
+ self._f_vel = np.zeros_like(self._vel_at_N)
+
+ # Adding semi-lagrangian and viscous terms
+ tempCalc1 = self._UsL + self._Uvis
+ tempCalc2 = self._VsL + self._Vvis
+
+ # Including the results according with links directions
+ self._f_vel[self._horizontal_links] = tempCalc1
+ self._f_vel[self._vertical_links] = tempCalc2
+
+ """ Setting G-faces
+ """
+ # Setting G-faces
+ self._g_links = np.zeros_like(self._vel_at_N)
+
+ # Computing G-faces
+ self._g_links = self._h_at_N_at_links * self._f_vel - self._h_at_N_at_links * (
+ 1 - self._theta
+ ) * self._g * self._dt / self._dx * self._grid.calc_diff_at_link(self._eta_at_N)
+
+ # Using only wet-link values, and setting dry links equal to 0 to avoid using wrong values
+ self._g_links = np.where(self._wet_links , self._g_links, 0)
+ self._g_links = np.where(
+ self._grid.status_at_link == 4, 0, self._g_links
+ ) # link is active (0), fixed (2), inactive (4)
+
+ """ Solving semi-implicit scheme with PCG method
+ """
+ # Building the system of equations 'A*x=b'
+ A = np.zeros(
+ (self._number_of_nodes, self._number_of_nodes)
+ ) # Full 'A' matrix with all nodes on it
+ b = np.zeros(self._number_of_nodes) # Full 'b' vector with all nodes on it
+
+ # Getting surrounding locations for core nodes
+ adjacent_nodes = self._grid.adjacent_nodes_at_node[
+ self._core_nodes
+ ] # East, North, West, South
+ adjacent_links = self._grid.links_at_node[
+ self._core_nodes
+ ] # East, North, West, South
+ nodes_location = np.append(
+ adjacent_nodes, np.array([self._core_nodes]).T, axis=1
+ ) # East, North, West, South, Center
+
+ # Boolean to differentiate between core and boundary nodes
+ tempB1 = np.isin(nodes_location, self._core_nodes)
+ # Core node if tempB1 == True, boundary node if tempB1 == False
+ tempB2 = ~tempB1
+ # Boundary node if tempB2 == True, core node if tempB2 == False
+
+ ## Building 'b' for the right-hand side of the system
+ # Calculating 'delta' to build 'b'
+ tempCalc1 = (
+ self._h_at_N_at_links[adjacent_links] * self._vel_at_N[adjacent_links]
+ )
+ tempCalc2 = (
+ self._eta_at_N[self._core_nodes]
+ - (1 - self._theta)
+ * self._dt
+ / self._dx
+ * (tempCalc1[:, 0] - tempCalc1[:, 2])
+ - (1 - self._theta)
+ * self._dt
+ / self._dy
+ * (tempCalc1[:, 1] - tempCalc1[:, 3])
+ )
+
+ tempCalc1 = (
+ self._h_at_N_at_links[adjacent_links]
+ * self._g_links[adjacent_links]
+ / self._a_links[adjacent_links]
+ )
+ b[self._core_nodes] = (
+ tempCalc2
+ - self._theta * self._dt / self._dx * (tempCalc1[:, 0] - tempCalc1[:, 2])
+ - self._theta * self._dt / self._dy * (tempCalc1[:, 1] - tempCalc1[:, 3])
+ )
+
+ ## Building 'A' for the left-hand side of the system
+ # Calculating coefficients for the system of equations
+ tempCalc1 = (
+ self._h_at_N_at_links[adjacent_links] ** 2 / self._a_links[adjacent_links]
+ )
+ coefficients = [
+ -tempCalc1[:, 0] * (self._g * self._theta * self._dt / self._dx) ** 2,
+ -tempCalc1[:, 1] * (self._g * self._theta * self._dt / self._dy) ** 2,
+ -tempCalc1[:, 2] * (self._g * self._theta * self._dt / self._dx) ** 2,
+ -tempCalc1[:, 3] * (self._g * self._theta * self._dt / self._dy) ** 2,
+ 1
+ + (tempCalc1[:, 0] + tempCalc1[:, 2])
+ * (self._g * self._theta * self._dt / self._dx) ** 2
+ + (tempCalc1[:, 1] + tempCalc1[:, 3])
+ * (self._g * self._theta * self._dt / self._dy) ** 2,
+ ]
+ coefficients = np.array(coefficients).T
+
+ ## For loop iterates through every row of 'nodes_location' to:
+ # a) find the node number (row in A) and choose an equation, and
+ # b) find the columns associated with adjacent nodes
+ for row in range(nodes_location.shape[0]):
+ # Getting the current node
+ current_node = nodes_location[row, 4]
+ # Getting the row associated with the current node
+ current_rows_in_A = np.array([current_node])
+ # Getting the columns associated with surrounding nodes
+ current_cols_in_A = nodes_location[row, :]
+
+ # Filling A matrix with coefficients associated with surrounding nodes
+ A[np.ix_(current_rows_in_A, current_cols_in_A)] = (
+ coefficients[row, :] * tempB1[row, :]
+ )
+
+ # Adding known terms (boundary nodes) to the right-hand side of the equation
+ b[current_rows_in_A] = b[current_rows_in_A] - sum(
+ self._eta_at_N[nodes_location[row, :]]
+ * coefficients[row, :]
+ * tempB2[row, :]
+ )
+ # for END
+
+ # Extracting only core nodes to be solved
+ left_hand_side = A[np.ix_(self._core_nodes, self._core_nodes)]
+ right_hand_side = b[self._core_nodes]
+
+ # Applying PCG method to 'LHS*eta=RHS' using np.diag() as a preconditioner for 'LHS'
+ # Preconditioned conjugated gradient output flag:
+ # 0 : successful exit
+ # >0 : convergence to tolerance not achieved, number of iterations
+ # <0 : illegal input or breakdown
+ # Alternative preconditiner: Li = np.linalg.cholesky(left_hand_side)
+ Mi = np.diag(np.diag(left_hand_side))
+ pcg_results = sp.sparse.linalg.cg(
+ left_hand_side,
+ right_hand_side,
+ M=Mi,
+ tol=self._pcg_tolerance,
+ maxiter=self._pcg_max_iterations,
+ atol=0
+ )
+
+ # Getting the new water surface elevation
+ self._eta = np.zeros_like(self._eta_at_N)
+ self._eta[self._core_nodes] = pcg_results[0]
+
+ """ Boundary conditions
+ Radiation Boundary Conditions of Roed & Smedstad (1984) applied on open boundaries
+ Water surface elevation
+ """
+ ## Updating the new WSE ('eta') with the fixed nodes values
+ if self._fixed_nodes_exist is True:
+ self._eta[self._fixed_entry_nodes] = (
+ self._entry_nodes_h_values - self._z[self._fixed_entry_nodes]
+ )
+
+ ## Getting the 1-line-upstream nodes from boundary nodes
+ tempCalc1 = self._grid.active_adjacent_nodes_at_node[self._open_boundary_nodes]
+ open_boundary_nodes_1_backwards = np.extract(tempCalc1 >= 0, tempCalc1)
+
+ ## Getting the 2-line-upstream nodes from boundary nodes
+ # Looking for these nodes
+ tempCalc1 = np.tile(self._open_boundary_nodes, (4, 1)).T
+ tempCalc2 = self._grid.active_adjacent_nodes_at_node[
+ open_boundary_nodes_1_backwards
+ ] # Surrounding nodes to 1-line-upstream
+
+ # Getting the node positions to extract them from all the surrounding nodes
+ tempB1 = np.tile([0, 1, 2, 3], (len(self._open_boundary_nodes), 1))
+ tempB2 = tempB1[tempCalc1 == tempCalc2]
+
+ # It gives me the node indices to extract
+ # folowing the face direction
+ tempB1 = np.where(tempB2 == 0, 2, tempB2)
+ tempB1 = np.where(tempB2 == 1, 3, tempB1)
+ tempB1 = np.where(tempB2 == 2, 0, tempB1)
+ tempB1 = np.where(tempB2 == 3, 1, tempB1)
+
+ open_boundary_nodes_2_backwards = tempCalc2[
+ [range(tempCalc2.shape[0])], tempB1
+ ][0]
+
+ ## Getting WSE at different locations
+ eta_at_N_at_B = self._eta_at_N[self._open_boundary_nodes]
+ eta_at_N_at_B_1 = self._eta_at_N[open_boundary_nodes_1_backwards]
+ eta_at_N_1_at_B_1 = self._eta_at_N_1[open_boundary_nodes_1_backwards]
+ eta_at_N_1_at_B_2 = self._eta_at_N_1[open_boundary_nodes_2_backwards]
+
+ ## Computing boundary condition
+ tempCalc1 = eta_at_N_at_B_1 - eta_at_N_1_at_B_1
+ tempCalc2 = eta_at_N_1_at_B_1 - eta_at_N_1_at_B_2
+ tempCalc3 = np.where(tempCalc2 == 0, 1, tempCalc2)
+
+ Ce = np.where(tempCalc2 == 0, 0, tempCalc1 / tempCalc3 * (-self._dx / self._dt))
+ Ce = np.where(tempCalc2 == 0, 0, Ce)
+
+ # eta[open_boundary_nodes] = tempCalc1/tempCalc2
+ self._eta[self._open_boundary_nodes] = np.where(
+ Ce >= 0, eta_at_N_at_B_1, eta_at_N_at_B
+ )
+ self._eta = np.where(
+ abs(self._eta) > abs(self._z), -self._z, self._eta
+ ) # Correcting WSE below topographic elevation
+
+ self._eta_at_links = self._grid.map_mean_of_link_nodes_to_link(self._eta)
+
+ # Corner nodes treatment
+ self._eta[self._corner_nodes] = np.mean(
+ self._eta[self._adjacent_nodes_at_corner_nodes], axis=1
+ )
+
+ """ Updating water velocity
+ """
+ # tempB1 : Considering only wet cells
+ # tempB2 : Cells with elevation below the water surface elevation
+ tempB1 = np.where(
+ abs(self._eta[self._grid.node_at_link_head])
+ <= abs(self._z[self._grid.node_at_link_head] - self._threshold_depth),
+ 1,
+ 0,
+ )
+ tempB2 = np.where(
+ abs(self._z[self._grid.node_at_link_head])
+ > abs(self._eta[self._grid.node_at_link_tail]),
+ 1,
+ 0,
+ )
+ tempB1 = tempB1 + tempB2
+ tempB1 = np.where(tempB1 > 1, 1, 0)
+
+ # Updating water velocity
+ tempCalc1 = (
+ self._theta
+ * self._g
+ * self._dt
+ / self._dx
+ * (self._grid.calc_diff_at_link(self._eta))
+ * self._h_at_N_at_links
+ / self._a_links
+ )
+ self._vel = self._g_links / self._a_links - tempCalc1 * tempB1
+
+ # Only updating velocity on wet cells
+ self._vel = np.where(self._wet_links , self._vel, 0)
+
+ """ Boundary conditions
+ Radiation Boundary Conditions of Roed & Smedstad (1984) applied on open boundaries
+ Water velocity
+ """
+ ## Updating the new Velocity with the fixed links values
+ if self._fixed_links_exist is True:
+ self._vel[self._fixed_entry_links] = self._entry_links_vel_values
+
+ ## Getting the boundary links
+ tempB1 = [i in self._open_boundary_links for i in self._active_links]
+ open_boundary_active_links = self._grid.active_links[tempB1]
+
+ ## Getting the 1-line-upstream links from boundary links
+ tempCalc1 = np.tile(open_boundary_active_links, (4, 1)).T
+ tempCalc2 = self._grid.links_at_node[open_boundary_nodes_1_backwards]
+
+ # Getting the link positions to extract them from all the surrounding nodes
+ tempB1 = np.tile([0, 1, 2, 3], (len(self._open_boundary_nodes), 1))
+ tempB2 = tempB1[tempCalc1 == tempCalc2]
+
+ # It gives me the link indices to extract
+ # folowing the face direction
+ tempB1 = np.where(tempB2 == 0, 2, tempB2)
+ tempB1 = np.where(tempB2 == 1, 3, tempB1)
+ # tempB1 is where the target link is located
+ tempB1 = np.where(tempB2 == 2, 0, tempB1)
+ # tempB2 is where the upstream link is located
+ tempB1 = np.where(tempB2 == 3, 1, tempB1)
+
+ open_boundary_active_links_1_backwards = tempCalc2[
+ [range(tempCalc2.shape[0])], tempB1
+ ][0]
+
+ ### Getting the 2-line-upstream links from boundary nodes
+ tempCalc1 = np.tile(open_boundary_active_links_1_backwards, (4, 1)).T
+ tempCalc2 = self._grid.links_at_node[open_boundary_nodes_2_backwards]
+
+ # Getting the link positions to extract them from all the surrounding nodes
+ tempB1 = np.tile([0, 1, 2, 3], (len(self._open_boundary_nodes), 1))
+ tempB2 = tempB1[(tempCalc1 == tempCalc2)]
+
+ # It gives me the link indices to extract
+ # folowing the face direction
+ tempB1 = np.where(tempB2 == 0, 2, tempB2)
+ tempB1 = np.where(tempB2 == 1, 3, tempB1)
+ # tempB1 is where the target link is located
+ tempB1 = np.where(tempB2 == 2, 0, tempB1)
+ # tempB2 is where the upstream link is located
+ tempB1 = np.where(tempB2 == 3, 1, tempB1)
+
+ open_boundary_active_links_2_backwards = tempCalc2[
+ [range(tempCalc2.shape[0])], tempB1
+ ][0]
+
+ ## Getting water velocity at different locations
+ vel_at_N_at_B = self._vel_at_N[open_boundary_active_links]
+ vel_at_N_at_B_1 = self._vel_at_N[open_boundary_active_links_1_backwards]
+ vel_at_N_1_at_B_1 = self._vel_at_N_1[open_boundary_active_links_1_backwards]
+ vel_at_N_1_at_B_2 = self._vel_at_N_1[open_boundary_active_links_2_backwards]
+
+ ## Computing boundary condition
+ tempCalc1 = vel_at_N_at_B_1 - vel_at_N_1_at_B_1
+ tempCalc2 = vel_at_N_1_at_B_1 - vel_at_N_1_at_B_2
+ tempCalc3 = np.where(tempCalc2 == 0, 1, tempCalc2)
+
+ Ce = np.where(tempCalc2 == 0, 0, tempCalc1 / tempCalc3 * (-self._dx / self._dt))
+ Ce = np.where(tempCalc2 == 0, 0, Ce)
+
+ self._vel[open_boundary_active_links] = np.where(
+ Ce >= 0, vel_at_N_at_B_1, vel_at_N_at_B
+ )
+
+ """ Updating water depth at links
+ """
+ # Using only values where the WSE is above the topographic elevation
+ tempB1 = np.where(abs(self._eta) <= abs(self._z - self._threshold_depth), 1, 0)
+
+ # Updating water depth at links
+ tempCalc1 = (
+ self._z_at_links + self._eta[self._grid.node_at_link_head]
+ ) * tempB1[self._grid.node_at_link_head]
+ tempCalc2 = (
+ self._z_at_links + self._eta[self._grid.node_at_link_tail]
+ ) * tempB1[self._grid.node_at_link_tail]
+ tempCalc3 = np.zeros_like(self._h_at_N_at_links)
+
+ self._h_at_links = np.array((tempCalc1, tempCalc2, tempCalc3)).max(axis=0)
+
+ # Applying boundary condition at links
+ self._h_at_links[self._open_boundary_links] = (
+ self._z_at_links[self._open_boundary_links]
+ + self._eta_at_links[self._open_boundary_links]
+ )
+
+ # Wet cells threshold
+ self._h_at_links = np.where(
+ self._h_at_links < self._threshold_depth, 0, self._h_at_links
+ )
+
+ # Updating wet links
+ self._wet_links = np.where(
+ self._h_at_links >= self._threshold_depth, True, False
+ )
+ self._vel = self._vel * self._wet_links
+
+ """ Calculating average water depth at nodes
+ """
+ # If a node is dry, using only surrounding links such that 'WSE' is above 'z'
+ # If a node is wet, using all surrounding links even if 'WSE' is below 'z' (jumps)
+
+ # Checking surrounding wet links
+ surrounding_links = self._grid.links_at_node[self._core_nodes]
+
+ # Checking whether the core node is wet (T) or dry (F)
+ tempB1 = abs(self._eta[self._core_nodes]) < abs(
+ self._z[self._core_nodes] - self._threshold_depth
+ )
+
+ # Checking whether surrounding links are wet (T) or dry (F)
+ tempB2 = self._wet_links[surrounding_links]
+
+ # Checking whether surrounding 'WSE' links are above (T) or below (F) 'z' at nodes
+ tempB3 = (
+ abs(self._eta_at_links[surrounding_links])
+ < abs(self._z[self._core_nodes] - self._threshold_depth)[:, None]
+ )
+
+ # Getting the number of wet links around each core node, satisfying tempB2, and avoiding divisions by zero
+ tempCalc2 = np.sum(tempB2 * 1, axis=1)
+ tempCalc2 = np.where(tempCalc2 == 0, -9999, tempCalc2)
+
+ # Getting the number of wet links around each core node, satisfying tempB3, and avoiding divisions by zero
+ tempCalc3 = np.sum(tempB2 * tempB3 * 1, axis=1)
+ tempCalc3 = np.where(tempCalc3 == 0, -9999, tempCalc3)
+
+ # Updating water depth
+ # h = h_at_N - rmg.calc_net_flux_at_node(h_at_links*vel) # (influx if negative)
+ self._h[self._core_nodes] = np.where(
+ tempCalc3 > 0,
+ np.sum(self._h_at_links[surrounding_links] * tempB2 * tempB3, axis=1)
+ / tempCalc3,
+ 0,
+ ) # Dry nodes, tempB1 == False
+
+ ### Updating boundary nodes
+ if self._fixed_nodes_exist is True:
+ self._h[self._fixed_entry_nodes] = self._entry_nodes_h_values
+ self._h[self._open_boundary_nodes] = (
+ self._eta[self._open_boundary_nodes] + self._z[self._open_boundary_nodes]
+ )
+ self._h = np.where(self._h < self._threshold_depth, 0, self._h)
+
+ # Corner nodes treatment
+ self._h[self._corner_nodes] = np.mean(
+ self._h[self._adjacent_nodes_at_corner_nodes], axis=1
+ )
+
+ # Updating wet nodes
+ self._wet_nodes = np.where(self._h >= self._threshold_depth, True, False)
+
+ """ Storing values in the grid
+ """
+ self._grid.at_node["surface_water__depth"] = self._h
+ self._grid.at_link["surface_water__velocity"] = self._vel
+ self._grid.at_node["surface_water__elevation"] = self._eta + (
+ self._max_elevation + self._additional_z
+ )
+
+ self._grid.at_link["surface_water__velocity_at_N-1"] = self._vel_at_N
+ self._grid.at_node["surface_water__elevation_at_N-1"] = self._eta_at_N + (
+ self._max_elevation + self._additional_z
+ )
+ self._grid.at_node["surface_water__elevation_at_N-2"] = self._eta_at_N_1 + (
+ self._max_elevation + self._additional_z
+ )
+
+ """ Storing values at previous time steps
+ """
+ self._eta_at_N = self._eta.copy()
+ self._eta_at_N_1 = self._eta_at_N.copy()
+ self._eta_at_N_2 = self._eta_at_N_1.copy()
+
+ self._h_at_N = self._h.copy()
+ self._h_at_N_at_links = self._h_at_links.copy()
+
+ self._vel_at_N = self._vel.copy()
+ self._vel_at_N_1 = self._vel_at_N.copy()
diff --git a/notebooks/tutorials/river_flow_dynamics/river_flow_dynamics_tutorial.ipynb b/notebooks/tutorials/river_flow_dynamics/river_flow_dynamics_tutorial.ipynb
new file mode 100644
index 0000000000..e0e4dccd8f
--- /dev/null
+++ b/notebooks/tutorials/river_flow_dynamics/river_flow_dynamics_tutorial.ipynb
@@ -0,0 +1,997 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "![](\"../../landlab_header.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 2D Surface Water Flow component\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
\n",
+ "For more Landlab tutorials, click here: https://landlab.readthedocs.io/en/latest/user_guide/tutorials.html\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overview\n",
+ "\n",
+ "This notebook demonstrate the usage of the `river flow dynamics` Landlab component. The component runs a semi-implicit, semi-Lagrangian finite-volume approximation to the depth-averaged 2D shallow-water equations of Casulli and Cheng (1992) and related work.\n",
+ "\n",
+ "### Theory\n",
+ "\n",
+ "The depth-averaged 2D shallow-water equations are the simplification of the Navier-Stokes equations, which correspond to the balance of momentum and mass in the fluid. It is possible to simplify these equations by assuming a well-mixed water column and a small water depth to width ratio, where a vertical integration results in depth-averaged equations. These require boundary conditions at the top and bottom of the water column, which are provided by the wind stress and the Manning-Chezy formula, respectively:\n",
+ "\n",
+ "$$\n",
+ "\\frac{\\partial U}{\\partial t}\n",
+ "+ U\\frac{\\partial U}{\\partial x} + V\\frac{\\partial U}{\\partial y}\n",
+ "= \n",
+ "- g\\frac{\\partial \\eta}{\\partial x}\n",
+ "+ \\epsilon\\left(\\frac{\\partial^2 U}{\\partial x^2} + \\frac{\\partial^2 U}{\\partial y^2}\\right)\n",
+ "+ \\frac{\\gamma_T(U_a - U)}{H} - g\\frac{\\sqrt{U^2 + V^2}}{Cz^2}U + \\mathbf{f}V\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "\\frac{\\partial V}{\\partial t}\n",
+ "+ U\\frac{\\partial V}{\\partial x} + V\\frac{\\partial V}{\\partial y}\n",
+ "= \n",
+ "- g\\frac{\\partial \\eta}{\\partial y}\n",
+ "+ \\epsilon\\left(\\frac{\\partial^2 V}{\\partial x^2} + \\frac{\\partial^2 V}{\\partial y^2}\\right)\n",
+ "+ \\frac{\\gamma_T(V_a - V)}{H} - g\\frac{\\sqrt{U^2 + V^2}}{Cz^2}V + \\mathbf{f}U\n",
+ "$$\n",
+ "\n",
+ "$$\n",
+ "\\frac{\\partial \\eta}{\\partial t}\n",
+ "+ \\frac{\\partial (HU)}{\\partial x} + \\frac{\\partial (HV)}{\\partial y}\n",
+ "= 0\n",
+ "$$\n",
+ "\n",
+ "where $U$ is the water velocity in the $x$-direction, $V$ is the water velocity in the $y$-direction, $H$ is the water depth, $\\eta$ is the water surface elevation, $Cz$ is the Chezy friction coefficient, and $t$ is time. For the constants $g$ is the gravity acceleration, $\\epsilon$ is the horizontal eddy viscosity, $\\mathbf{f}$ is the Coriolis parameter, $\\gamma_T$ is the wind stress coefficient, and $U_a$ and $V_a$ are the prescribed wind velocities.\n",
+ "\n",
+ "### Numerical representation\n",
+ "\n",
+ "A semi-implicit, semi-Lagrangian, finite volume numerical approximation represents the depth averaged, 2D shallow-water equations described before. The water surface elevation, $\\eta$, is defined at the center of each computational volume (nodes). Water depth, $H$, and velocity components, $U$ and $V$, are defined at the midpoint of volume faces (links). The finite volume structure provides a control volume representation that is inherently mass conservative.\n",
+ "\n",
+ "The combination of a semi-implciit water surface elevation solution and a semi-Lagrangian representation of advection provides the advantages of a stable solution and of time steps that exceed the CFL criterion. In the semi-implicit process, $\\eta$ in the momentum equations, and the velocity divergence in the continuity equation, are trated implicitly. The advective terms in the momentum equations, are discretized explicitly. See the cited literature for more details.\n",
+ "\n",
+ "### The component\n",
+ "\n",
+ "Import the needed libraries:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from landlab import RasterModelGrid\n",
+ "from landlab.components import river_flow_dynamics\n",
+ "from landlab.io import read_esri_ascii\n",
+ "from landlab.plot.imshow import imshow_grid"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Information about the component\n",
+ "\n",
+ "Using the class name as argument for the `help` function returns descriptions of the various methods and parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on class river_flow_dynamics in module landlab.components.river_flow_dynamics.river_flow_dynamics:\n",
+ "\n",
+ "class river_flow_dynamics(landlab.core.model_component.Component)\n",
+ " | river_flow_dynamics(grid, dt=0.01, eddy_viscosity=0.0001, mannings_n=0.012, threshold_depth=0.01, theta=0.5, fixed_entry_nodes=[], fixed_entry_links=[], entry_nodes_h_values=[], entry_links_vel_values=[], pcg_tolerance=1e-05, pcg_max_iterations=None, surface_water__elevation_at_N_1=None, surface_water__elevation_at_N_2=None, surface_water__velocity_at_N_1=None)\n",
+ " | \n",
+ " | Simulate surface fluid flow based on Casulli and Cheng (1992).\n",
+ " | \n",
+ " | Landlab component that simulates surface fluid flow using the Casulli and Cheng (1992)\n",
+ " | approximations of the 2D shallow water equations.\n",
+ " | \n",
+ " | This components calculates water depth and velocity across the raster grid, given\n",
+ " | a certain input discharge.\n",
+ " | \n",
+ " | References\n",
+ " | ----------\n",
+ " | **Required Software Citation(s) Specific to this Component**\n",
+ " | \n",
+ " | None Listed\n",
+ " | \n",
+ " | **Additional References**\n",
+ " | \n",
+ " | Casulli, V., Cheng, R.T. (1992). “Semi-implicit finite difference methods for\n",
+ " | three-dimensional shallow water flow”. International Journal for Numerical Methods\n",
+ " | in Fluids. 15: 629-648.\n",
+ " | https://doi.org/10.1002/fld.1650150602\n",
+ " | \n",
+ " | Method resolution order:\n",
+ " | river_flow_dynamics\n",
+ " | landlab.core.model_component.Component\n",
+ " | builtins.object\n",
+ " | \n",
+ " | Methods defined here:\n",
+ " | \n",
+ " | __init__(self, grid, dt=0.01, eddy_viscosity=0.0001, mannings_n=0.012, threshold_depth=0.01, theta=0.5, fixed_entry_nodes=[], fixed_entry_links=[], entry_nodes_h_values=[], entry_links_vel_values=[], pcg_tolerance=1e-05, pcg_max_iterations=None, surface_water__elevation_at_N_1=None, surface_water__elevation_at_N_2=None, surface_water__velocity_at_N_1=None)\n",
+ " | Simulate the vertical-averaged surface fluid flow\n",
+ " | \n",
+ " | Landlab component that simulates surface fluid flow using the Casulli and Cheng (1992)\n",
+ " | approximations of the 2D shallow water equations.\n",
+ " | \n",
+ " | This components calculates water depth and velocity across the raster grid, given\n",
+ " | a certain input discharge.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | grid : RasterModelGrid\n",
+ " | A grid.\n",
+ " | dt : float, optional\n",
+ " | Time step in seconds. If not given, it is calculated from CFL condition.\n",
+ " | eddy_viscosity : float, optional\n",
+ " | Eddy viscosity coefficient. Default = 1e-4 :math:`m^2 / s`\n",
+ " | mannings_n : float or array_like, optional\n",
+ " | Manning's roughness coefficient. Default = 0.012 :math:`s / m^1/3`\n",
+ " | threshold_depth : float, optional\n",
+ " | Threshold at which a cell is considered wet. Default = 0.01 m\n",
+ " | theta : float, optional\n",
+ " | Degree of 'implicitness' of the solution, ranging between 0.5 and 1.0. Default = 0.5.\n",
+ " | When it is equal to 0.5, the approximation is centered in time.\n",
+ " | When it is equal to 1.0, the approximation is fully implicit.\n",
+ " | fixed_entry_nodes : array_like or None, optional\n",
+ " | Node IDs where flow enters the domain (Dirichlet boundary condition).\n",
+ " | If not provided, the water already present in the domain is not renewed.\n",
+ " | fixed_entry_links : array_like or None, optional\n",
+ " | Link IDs where flow enters the domain (Dirichlet boundary condition).\n",
+ " | If not provided, the water already present in the domain is not renewed.\n",
+ " | entry_nodes_h_values : array_like, optional\n",
+ " | Water depth values at nodes where flow enters the domain (Dirichlet boundary condition).\n",
+ " | If not provided, the water already present in the domain is not renewed.\n",
+ " | entry_links_vel_values : array_like, optional\n",
+ " | Water velocity values at links where flow enters the domain (Dirichlet boundary condition).\n",
+ " | If not provided, the water already present in the domain is not renewed.\n",
+ " | pcg_tolerance : float, optional\n",
+ " | Preconditioned Conjugate Gradient method argument. Tolerance for convergence.\n",
+ " | Default = 1e-05\n",
+ " | pcg_max_iterations : integer, optional\n",
+ " | Preconditioned Conjugate Gradient method argument. Maximum number of iterations.\n",
+ " | Iteration will stop after maxiter steps even if the specified tolerance has not been achieved.\n",
+ " | Default = None\n",
+ " | surface_water__elevation_at_N_1: float, optional\n",
+ " | Water surface elevation at time N-1.\n",
+ " | units: m, mapping: node\n",
+ " | surface_water__elevation_at_N_2: float, optional\n",
+ " | Water surface elevation at time N-2.\n",
+ " | units: m, mapping: node\n",
+ " | surface_water__velocity_at_N_1: float, optional\n",
+ " | Speed of water flow above the surface at time N-1\",\n",
+ " | units: m/2, mapping: link\n",
+ " | \n",
+ " | find_adjacent_links_at_link(self, current_link, objective_links='horizontal')\n",
+ " | Get adjacent links to the link.\n",
+ " | \n",
+ " | This function finds the links at right, above, left and below the given link.\n",
+ " | Similar purpose to the \"adjacent_nodes_at_node\" function.\n",
+ " | Return the adjacent links in as many rows as given links.\n",
+ " | Link IDs are returned as columns in clock-wise order starting from East (E, N, W, S).\n",
+ " | \n",
+ " | find_nearest_link(self, x_coordinates, y_coordinates, objective_links='all')\n",
+ " | Link nearest a point.\n",
+ " | \n",
+ " | Find the index to the link nearest the given x, y coordinates.\n",
+ " | Returns the indices of the links nearest the given coordinates.\n",
+ " | \n",
+ " | path_line_tracing(self)\n",
+ " | \" Path line tracing algorithm.\n",
+ " | \n",
+ " | This function implements the semi-analytical path line tracing method of Pollock (1988).\n",
+ " | \n",
+ " | The semi-analytical path line tracing method was developed for particle tracking in ground\n",
+ " | water flow models. The assumption that each directional velocity component varies linearly\n",
+ " | in its coordinate directions within each computational volume or cell underlies the method.\n",
+ " | Linear variation allows the derivation of an analytical expression for the path line of a\n",
+ " | particle across a volume.\n",
+ " | \n",
+ " | Given an initial point located at each volume faces of the domain, particle trayectories are\n",
+ " | traced backwards on time. Then, this function returns the departure point of the particle at\n",
+ " | the beginning of the time step.\n",
+ " | \n",
+ " | run_one_step(self)\n",
+ " | Calculate water depth and water velocity for a time period dt.\n",
+ " | \n",
+ " | ----------------------------------------------------------------------\n",
+ " | Methods inherited from landlab.core.model_component.Component:\n",
+ " | \n",
+ " | initialize_optional_output_fields(self)\n",
+ " | Create fields for a component based on its optional field outputs,\n",
+ " | if declared in _optional_var_names.\n",
+ " | \n",
+ " | This method will create new fields (without overwrite) for any\n",
+ " | fields output by the component as optional. New fields are\n",
+ " | initialized to zero. New fields are created as arrays of floats,\n",
+ " | unless the component also contains the specifying property\n",
+ " | _var_type.\n",
+ " | \n",
+ " | initialize_output_fields(self, values_per_element=None)\n",
+ " | Create fields for a component based on its input and output var\n",
+ " | names.\n",
+ " | \n",
+ " | This method will create new fields (without overwrite) for any fields\n",
+ " | output by, but not supplied to, the component. New fields are\n",
+ " | initialized to zero. Ignores optional fields. New fields are created as\n",
+ " | arrays of floats, unless the component specifies the variable type.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | values_per_element: int (optional)\n",
+ " | On occasion, it is necessary to create a field that is of size\n",
+ " | (n_grid_elements, values_per_element) instead of the default size\n",
+ " | (n_grid_elements,). Use this keyword argument to acomplish this\n",
+ " | task.\n",
+ " | \n",
+ " | ----------------------------------------------------------------------\n",
+ " | Class methods inherited from landlab.core.model_component.Component:\n",
+ " | \n",
+ " | from_path(grid, path) from builtins.type\n",
+ " | Create a component from an input file.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | grid : ModelGrid\n",
+ " | A landlab grid.\n",
+ " | path : str or file_like\n",
+ " | Path to a parameter file, contents of a parameter file, or\n",
+ " | a file-like object.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | Component\n",
+ " | A newly-created component.\n",
+ " | \n",
+ " | var_definition(name) from builtins.type\n",
+ " | Get a description of a particular field.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | name : str\n",
+ " | A field name.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple of (*name*, *description*)\n",
+ " | A description of each field.\n",
+ " | \n",
+ " | var_help(name) from builtins.type\n",
+ " | Print a help message for a particular field.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | name : str\n",
+ " | A field name.\n",
+ " | \n",
+ " | var_loc(name) from builtins.type\n",
+ " | Location where a particular variable is defined.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | name : str\n",
+ " | A field name.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | str\n",
+ " | The location ('node', 'link', etc.) where a variable is defined.\n",
+ " | \n",
+ " | var_type(name) from builtins.type\n",
+ " | Returns the dtype of a field (float, int, bool, str...).\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | name : str\n",
+ " | A field name.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | dtype\n",
+ " | The dtype of the field.\n",
+ " | \n",
+ " | var_units(name) from builtins.type\n",
+ " | Get the units of a particular field.\n",
+ " | \n",
+ " | Parameters\n",
+ " | ----------\n",
+ " | name : str\n",
+ " | A field name.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | str\n",
+ " | Units for the given field.\n",
+ " | \n",
+ " | ----------------------------------------------------------------------\n",
+ " | Static methods inherited from landlab.core.model_component.Component:\n",
+ " | \n",
+ " | __new__(cls, *args, **kwds)\n",
+ " | Create and return a new object. See help(type) for accurate signature.\n",
+ " | \n",
+ " | ----------------------------------------------------------------------\n",
+ " | Readonly properties inherited from landlab.core.model_component.Component:\n",
+ " | \n",
+ " | cite_as\n",
+ " | Citation information for component.\n",
+ " | \n",
+ " | Return required software citation, if any. An empty string indicates\n",
+ " | that no citations other than the standard Landlab package citations are\n",
+ " | needed for the component.\n",
+ " | \n",
+ " | Citations are provided in BibTeX format.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | cite_as\n",
+ " | \n",
+ " | coords\n",
+ " | Return the coordinates of nodes on grid attached to the\n",
+ " | component.\n",
+ " | \n",
+ " | definitions\n",
+ " | Get a description of each field.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple of (*name*, *description*)\n",
+ " | A description of each field.\n",
+ " | \n",
+ " | grid\n",
+ " | Return the grid attached to the component.\n",
+ " | \n",
+ " | input_var_names\n",
+ " | Names of fields that are used by the component.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple of str\n",
+ " | Tuple of field names.\n",
+ " | \n",
+ " | name\n",
+ " | Name of the component.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | str\n",
+ " | Component name.\n",
+ " | \n",
+ " | optional_var_names\n",
+ " | Names of fields that are optionally provided by the component, if\n",
+ " | any.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple of str\n",
+ " | Tuple of field names.\n",
+ " | \n",
+ " | output_var_names\n",
+ " | Names of fields that are provided by the component.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple of str\n",
+ " | Tuple of field names.\n",
+ " | \n",
+ " | shape\n",
+ " | Return the grid shape attached to the component, if defined.\n",
+ " | \n",
+ " | unit_agnostic\n",
+ " | Whether the component is unit agnostic.\n",
+ " | \n",
+ " | If True, then the component is unit agnostic. Under this condition a\n",
+ " | user must still provide consistent units across all input arguments,\n",
+ " | keyword arguments, and fields. However, when ``unit_agnostic`` is True\n",
+ " | the units specified can be interpreted as dimensions.\n",
+ " | \n",
+ " | When False, then the component requires inputs in the specified units.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | bool\n",
+ " | \n",
+ " | units\n",
+ " | Get the units for all field values.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple or str\n",
+ " | Units for each field.\n",
+ " | \n",
+ " | var_mapping\n",
+ " | Location where variables are defined.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | tuple of (name, location)\n",
+ " | Tuple of variable name and location ('node', 'link', etc.) pairs.\n",
+ " | \n",
+ " | ----------------------------------------------------------------------\n",
+ " | Data descriptors inherited from landlab.core.model_component.Component:\n",
+ " | \n",
+ " | __dict__\n",
+ " | dictionary for instance variables (if defined)\n",
+ " | \n",
+ " | __weakref__\n",
+ " | list of weak references to the object (if defined)\n",
+ " | \n",
+ " | current_time\n",
+ " | Current time.\n",
+ " | \n",
+ " | Some components may keep track of the current time. In this case, the\n",
+ " | ``current_time`` attribute is incremented. Otherwise it is set to None.\n",
+ " | \n",
+ " | Returns\n",
+ " | -------\n",
+ " | current_time\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(river_flow_dynamics)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Examples\n",
+ "\n",
+ "-- --\n",
+ "\n",
+ "### Example 1: Flow in a rectangular channel 6.0 m long\n",
+ "\n",
+ "This first basic example illustrates water flowing through a rectangular channel 1.0 $m$ wide and 6.0 $m$ long. Our channel is made in concrete, so we choose a Manning's roughness coefficient equal to 0.012 $s/m^\\frac{1}{3}$, and it has a slope of 0.01 $m/m$.\n",
+ "\n",
+ "We specify some basic parameters such as the grid resolution, time step duration, number of time steps, and the domain dimensions by specifying the number of columns and rows. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Basic parameters\n",
+ "n = 0.012 # Manning's roughness coefficient, [s/m^(1/3)]\n",
+ "S0 = 0.01 # Channel slope [m/m]\n",
+ "\n",
+ "# Simulation parameters\n",
+ "n_timesteps = 100 # Number of timesteps\n",
+ "dt = 0.1 # Timestep duration, [s]\n",
+ "nrows = 20 # Number of node rows\n",
+ "ncols = 60 # Number of node cols\n",
+ "dx = 0.1 # Node spacing in the x-direction, [m]\n",
+ "dy = 0.1 # Node spacing in the y-direction, [m]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create the grid:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create and set up the grid\n",
+ "grid = RasterModelGrid((nrows, ncols), xy_spacing=(dx, dy))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create the elevation field and define the topography to represent our rectangular channel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# The grid represents a basic rectangular channel with slope equal to 0.01 m/m\n",
+ "te = grid.add_zeros(\"topographic__elevation\", at=\"node\")\n",
+ "te += 1.0 - S0*grid.x_of_node\n",
+ "te[grid.y_of_node > 1.5] = 2.5\n",
+ "te[grid.y_of_node < 0.5] = 2.5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We show a top view of the domain:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Showing the topography\n",
+ "imshow_grid(grid, \"topographic__elevation\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The channel is empty at the beginning of the simulation, so we create the fields for the water surface elevation, depth and velocity:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# We establish the initial conditions, which represent an empty channel\n",
+ "h = grid.add_zeros(\"surface_water__depth\", at=\"node\")\n",
+ "\n",
+ "# Water velocity is zero in everywhere since there is no water yet\n",
+ "vel = grid.add_zeros(\"surface_water__velocity\", at=\"link\")\n",
+ "\n",
+ "# Calculating the initial water surface elevation from water depth and topographic elevation\n",
+ "wse = grid.add_zeros(\"surface_water__elevation\", at=\"node\")\n",
+ "wse += h + te"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Then, we specify the nodes at which water is entering into the domain, and also the associated links. These are going to be the entry boundary conditions for water depth and velocity. In this case, water flows from left to right at 0.5 $m$ depth, with a velocity of 0.45 $m/s$:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# We set fixed boundary conditions, specifying the nodes and links in which the water is flowing into the grid\n",
+ "fixed_entry_nodes = np.array([300, 360, 420, 480, 540, 600, 660, 720, 780, 840, 900])\n",
+ "fixed_entry_links = grid.links_at_node[fixed_entry_nodes][:,0]\n",
+ "\n",
+ "# We set the fixed values in the entry nodes/links\n",
+ "entry_nodes_h_values = np.array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5])\n",
+ "entry_links_vel_values = np.array([0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45, 0.45])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And now we show the boundary condition in the cross-section:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUWklEQVR4nO3de1xUdf4/8NdBhuE+iMpFBUQzFa94S3S9peAl2WwzrXa9ZdvPVcv0W26UpWwlW5sJlKu1a7JWGrVeK1MwA3JTUwNtt7IsDUXQlGC4CAzM+f1xnIGR2wzMzJmZ83o+HvNw5sznHN7no868+VwFURRFEBERESmIm9wBEBEREdkbEyAiIiJSHCZAREREpDhMgIiIiEhxmAARERGR4jABIiIiIsVhAkRERESKwwSIiIiIFIcJEBERESkOEyAiatWZM2ewcOFCREZGwtPTE76+vhg6dChefvllFBcXyx2eQ/riiy+wdu1alJSUNHpvwoQJmDBhgt1jIqJ6ArfCIKKW/OMf/8CSJUvQp08fLFmyBFFRUdDpdDh58iT+8Y9/YPDgwdi9e7fcYTqcV155BU8++STOnz+PHj16mLz3zTffAACioqJkiIyIAMBd7gCIyHEdPXoUf/rTnxAbG4s9e/ZArVYb34uNjcX//d//4cCBA82ef+PGDXh5edkjVKfCxIdIfuwCI6JmrVu3DoIg4M033zRJfgw8PDzw29/+FgDQo0cPzJgxA7t27UJ0dDQ8PT2RmJgIAPjvf/+Lu+++Gx07doSnpyeGDBmCf/3rXybX0uv1eOGFF9CnTx94eXkhICAAgwYNQkpKirHML7/8gkceeQRhYWFQq9Xo0qULxowZg0OHDrV6Lz/99BPuv/9+dO3aFWq1GsHBwZg0aRLy8vJMyqWnpyMmJgY+Pj7w9fXFlClTkJub2+h6x48fR3x8PDp16gRPT0/06tULjz/+OABg7dq1ePLJJwEAkZGREAQBgiAgKysLQNNdYMXFxViyZAm6desGDw8P9OzZE8888wyqq6tNygmCgGXLluHtt99Gv3794O3tjcGDB+Ojjz5qtQ6IqB5bgIioSXV1dTh8+DCGDRuGsLAws8756quv8O2332L16tWIjIyEj48Pzp49i9GjRyMoKAipqano1KkT3nnnHSxYsABXrlzBqlWrAAAvv/wy1q5di9WrV2PcuHHQ6XT47rvvTMbQzJ07F1999RVefPFF3H777SgpKcFXX32F69evtxrb9OnTUVdXh5dffhnh4eG4du0avvjiC5Prr1u3DqtXr8bChQuxevVq1NTU4G9/+xvGjh2LL7/80thyc/DgQcTHx6Nfv3549dVXER4ejgsXLiAjIwMA8PDDD6O4uBivvfYadu3ahdDQUADNt/xUVVVh4sSJ+PHHH5GYmIhBgwbh888/R1JSEvLy8vDxxx+blP/4449x4sQJ/OUvf4Gvry9efvll3HPPPTh79ix69uxp1t8VkeKJRERNKCoqEgGI999/v1nlIyIixA4dOohnz541OX7//feLarVazM/PNzk+bdo00dvbWywpKRFFURRnzJghDhkypMWf4evrKz7++OMW3IXk2rVrIgAxOTm52TL5+fmiu7u7+Oijj5ocLysrE0NCQsTZs2cbj/Xq1Uvs1auXeOPGjWav97e//U0EIJ4/f77Re+PHjxfHjx9vfL1582YRgPj++++blHvppZdEAGJGRobxGAAxODhY1Gq1xmNFRUWim5ubmJSU1Gw8RGSKXWBEZDWDBg3C7bffbnLs8OHDmDRpUqNWpAULFqCyshJHjx4FAIwcORKnT5/GkiVLcPDgQWi12kbXHzlyJNLS0vDCCy/g2LFj0Ol0Ju+Looja2lqTBwAEBgaiV69e+Nvf/oZXX30Vubm50Ov1JucePHgQtbW1mDdvnsn5np6eGD9+vLH76vvvv8ePP/6IRYsWwdPTs1311bCOfHx8MGvWrEZ1BACffvqpyfGJEyfCz8/P+Do4OBhBQUH4+eefrRIPkRIwASKiJnXu3Bne3t44f/682ecYunoaun79epPHu3btanwfABISEvDKK6/g2LFjmDZtGjp16oRJkybh5MmTxnPS09Mxf/58/POf/0RMTAwCAwMxb948FBUVAQD+9a9/QaVSmTwAadzMp59+iilTpuDll1/G0KFD0aVLFzz22GMoKysDAFy5cgUAMGLEiEbXSE9Px7Vr1wBI45AAoHv37mbXS2uuX7+OkJAQCIJgcjwoKAju7u6Nuvg6derU6BpqtRo3btywWkxEro5jgIioSR06dMCkSZPwySef4NKlS2Z94d/6BQ5IX9aFhYWNjl++fBmAlGgBgLu7O1auXImVK1eipKQEhw4dwtNPP40pU6bg4sWL8Pb2RufOnZGcnIzk5GTk5+dj3759eOqpp3D16lUcOHAA8fHxOHHiRJOxRUREYMuWLQCkVpz3338fa9euRU1NDTZv3myM49///jciIiKavccuXboAAC5dutRqfZirU6dOOH78OERRNKnDq1evora21hgbEVkPW4CIqFkJCQkQRRF//OMfUVNT0+h9nU6HDz/8sMVrTJo0CYcPHzYmPAbbtm2Dt7c3Ro0a1eicgIAAzJo1C0uXLkVxcTEuXLjQqEx4eDiWLVuG2NhYfPXVVwCkRGL48OEmj6bcfvvtWL16NQYOHGg8d8qUKXB3d8ePP/7Y6BoNr3X77bejV69eeOuttxrN0GrIMGvOnFaZSZMmoby8HHv27GlUR4b3ici62AJERM2KiYnBpk2bsGTJEgwbNgx/+tOf0L9/f+h0OuTm5uLNN9/EgAEDEB8f3+w11qxZg48++ggTJ07Ec889h8DAQLz77rv4+OOP8fLLL0Oj0QAA4uPjMWDAAAwfPhxdunTBzz//jOTkZERERKB3794oLS3FxIkT8eCDD6Jv377w8/PDiRMncODAAfzud79r8T7OnDmDZcuW4b777kPv3r3h4eGBw4cP48yZM3jqqacASNP4//KXv+CZZ57BTz/9hKlTp6Jjx464cuUKvvzyS/j4+Bin9W/cuBHx8fEYNWoUVqxYgfDwcOTn5+PgwYN49913AQADBw4EAKSkpGD+/PlQqVTo06ePydgdg3nz5mHjxo2YP38+Lly4gIEDB+LIkSNYt24dpk+fjsmTJ1v+l0dELZN5EDYROYG8vDxx/vz5Ynh4uOjh4SH6+PiI0dHR4nPPPSdevXpVFEVpFthdd93V5Plff/21GB8fL2o0GtHDw0McPHiwuHXrVpMy69evF0ePHi127txZ9PDwEMPDw8VFixaJFy5cEEVRFKuqqsTFixeLgwYNEv39/UUvLy+xT58+4po1a8SKiooW479y5Yq4YMECsW/fvqKPj4/o6+srDho0SNywYYNYW1trUnbPnj3ixIkTRX9/f1GtVosRERHirFmzxEOHDpmUO3r0qDht2jRRo9GIarVa7NWrl7hixQqTMgkJCWLXrl1FNzc3EYD42WefiaLYeBaYKIri9evXxcWLF4uhoaGiu7u7GBERISYkJIhVVVUm5QCIS5cubXSPERER4vz581usByKqx60wiIiISHE4BoiIiIgUhwkQERERKQ4TICIiIlIcWROgpKQkjBgxAn5+fggKCsLMmTNx9uzZFs9ZsGCBcWPBho/+/fsby6SlpTVZpqqqyta3RERERE5A1gQoOzsbS5cuxbFjx5CZmYna2lrExcWhoqKi2XNSUlJQWFhofFy8eBGBgYG47777TMr5+/ublCssLLTasvVERETk3GRdB+jAgQMmr7du3YqgoCCcOnUK48aNa/IcjUZjXDcEAPbs2YNff/0VCxcuNCknCAJCQkKsHzQRERE5PYdaCLG0tBSAtHGhubZs2YLJkyc3Wrq+vLwcERERqKurw5AhQ/D8888jOjq6yWtUV1ebrOiq1+tRXFyMTp06Nbm0PxERETkeURRRVlaGrl27ws2tlU4umdchMtLr9WJ8fLz4m9/8xuxzLl++LHbo0EFMT083OX706FHx7bffFvPy8sScnBzx3nvvFb28vMTvv/++yeusWbNGBMAHH3zwwQcffLjA4+LFi63mEA6zEOLSpUvx8ccf48iRI2bvspyUlIT169fj8uXL8PDwaLacXq/H0KFDMW7cOKSmpjZ6/9YWoNLSUoSHh+P8+fNNLlvvLHQ6HT777DNMnDjRuCu2ErEeJKwHCetBwnqox7qQuEI9lJWVITIyEiUlJSbDZZriEF1gjz76KPbt24ecnByzkx9RFPHWW29h7ty5LSY/AODm5oYRI0bghx9+aPJ9tVpt3LiwocDAQPj7+5sVjyPS6XTw9vZGp06dnPYfszWwHiSsBwnrQcJ6qMe6kLhCPRjiNmf4iqyzwERRxLJly7Br1y4cPnwYkZGRZp+bnZ2Nc+fOYdGiRWb9nLy8PISGhrYnXCIiInIRsrYALV26FNu3b8fevXvh5+eHoqIiANJMLy8vLwBAQkICCgoKsG3bNpNzt2zZgjvuuAMDBgxodN3ExESMGjUKvXv3hlarRWpqKvLy8rBx40bb3xQRERE5PFkToE2bNgEAJkyYYHJ869atWLBgAQCgsLAQ+fn5Ju+XlpZi586dSElJafK6JSUleOSRR1BUVASNRoPo6Gjk5ORg5MiRVr8HIiIicj6yJkDmjL9OS0trdEyj0aCysrLZczZs2IANGza0JzQiIiJyYdwLjIiIiBSHCRAREREpDhMgIiIiUhwmQERERKQ4TICIiIhIcZgAERERkeIwASIiIiLFYQJEREREisMEiIiIiBSHCRAREREpDhMgIiIiUhwmQERERKQ4TICIiIhIcZgAERERkeIwASIiIiLFYQJEREREisMEiIiIiBSHCRAREREpDhMgIiIiUhwmQERERKQ4TICIiIhIcZgAERERkeIwASIiIiLFYQJEREREisMEiIiIiBSHCRAREREpDhMgIiIiUhwmQERERKQ4TICIiIhIcZgAERERkeIwASIiIiLFYQJEREREisMEiIiIiBSHCRAREREpDhMgIiIiUhxZE6CkpCSMGDECfn5+CAoKwsyZM3H27NkWz8nKyoIgCI0e3333nUm5nTt3IioqCmq1GlFRUdi9e7ctb4WIiIiciKwJUHZ2NpYuXYpjx44hMzMTtbW1iIuLQ0VFRavnnj17FoWFhcZH7969je8dPXoUc+bMwdy5c3H69GnMnTsXs2fPxvHjx215O0REROQk3OX84QcOHDB5vXXrVgQFBeHUqVMYN25ci+cGBQUhICCgyfeSk5MRGxuLhIQEAEBCQgKys7ORnJyMHTt2WCV2IiIicl6yJkC3Ki0tBQAEBga2WjY6OhpVVVWIiorC6tWrMXHiRON7R48exYoVK0zKT5kyBcnJyU1eq7q6GtXV1cbXWq0WAKDf8SD0XipLb8NhuIl6hNfdBp0uVu5QZKXT6Uz+VCrWg4T1IGE91GNdAKgqhXDgzxiVfxZu29+CXnDOIcL6G+b/HQqiKIo2jMVsoiji7rvvxq+//orPP/+82XJnz55FTk4Ohg0bhurqarz99tvYvHkzsrKyjK1GHh4eSEtLw4MPPmg8b/v27Vi4cKFJomOwdu1aJCYmNjpe+pQf/NWCFe5OPjo3L+wftBkQnPs+iIjIdsKvZyM6f4vcYbSbtlqE5q9lKC0thb+/f4tlHaYFaNmyZThz5gyOHDnSYrk+ffqgT58+xtcxMTG4ePEiXnnlFZNuM+GWL3xRFBsdM0hISMDKlSuNr7VaLcLCwlA7bT1qfb3bcjvy09fB/aNHodLfQOy4kVD5dZE7ItnodDpkZmYiNjYWKpXztui1F+tBwnqQsB7qsS4At6zTQD5w1W8ANOMeQYcODpMeWKS2vBL46yNmlXWIO3z00Uexb98+5OTkoHv37hafP2rUKLzzzjvG1yEhISgqKjIpc/XqVQQHBzd5vlqthlqtbnTcfcgcuLeSQToy8XAihMprUFUUQRXYVe5wZKdSqRT74dYQ60HCepCwHuopui7KCgAAv/hFoeOQB+HupPXgrtUCMC8BkrWTTxRFLFu2DLt27cLhw4cRGRnZpuvk5uYiNDTU+DomJgaZmZkmZTIyMjB69Oh2xetsRP9uAACh9KLMkRARkUO7+T1xQ9VJ5kDsR9YWoKVLl2L79u3Yu3cv/Pz8jK02Go0GXl5eAKTuqYKCAmzbtg2ANMOrR48e6N+/P2pqavDOO+9g586d2Llzp/G6y5cvx7hx4/DSSy/h7rvvxt69e3Ho0KFWu9dcjiYMKDoNQVsgdyREROTIbiZAlR6dZQ7EfmRNgDZt2gQAmDBhgsnxrVu3YsGCBQCAwsJC5OfnG9+rqanBE088gYKCAnh5eaF///74+OOPMX36dGOZ0aNH47333sPq1avx7LPPolevXkhPT8cdd9xh83tyJKLmZnciW4CIiKg5+jpAexkAcMODLUB2Yc4EtLS0NJPXq1atwqpVq1o9b9asWZg1a1ZbQ3MNNxMgtgAREVGzyooAfS1EN3dUqQLkjsZunHOiP5lF9A+TnrAFiIiImmP4jvDvBjjp+j9toZw7VSBRYxgEfUnmSIiIyGHd/I4wTJxRCiZArkwjtQAJFVcBXZXMwRARkUMquTnO9uZ3hlIwAXJlXoGoFTyk5xwHRERETTG2AFm+Dp8zYwLkygShfkQ/xwEREVFTbn4/GGcOKwQTIBdXnwBxHBARETXB8P3ABIhciXFRqxK2ABER0S1E0fj9wBYgcilsASIiomZVlQI1ZdJzzgIjV2JsASrNb7kgEREpj2F8qHdnQOUtbyx2xgTIxRk3tmMXGBER3crw3aCw7i+ACZDLqzR0gWkLAL1e3mCIiMixGIZHBChrDSCACZDLq/LoCFFwA+pqgIqrcodDRESOxDA8QhMubxwyYALk4kTBHfANkV5wIDQRETWk0CnwABMgRRANy5uXcCA0ERE1YBgDxC4wckk3N0VlCxAREZlgCxC5MmMLELfDICIig9pqoLxIes4xQOSS/NkCREREtzBsku3uBXgHyhuLDJgAKUD9GCC2ABER0U0Nx/8IgryxyIAJkAKI/jf7dtkFRkREBgoe/wMwAVIGwz/uqhKgukzWUIiIyEEYfinWKG8GGMAESBnUfoCnRnrOcUBERAQwAZI7ALITwwh/jgMiIiJA0WsAAUyAlMPQDcZd4YmICGjQAsQxQOTKDBk+u8CIiEivB0pvToNnFxi5NE6FJyIig4pfgLpqQHAD/LvKHY0smAAphbELjC1ARESKZ/gu8AsFOqjkjUUmTICUIuDmIGiuBURERIbxoArt/gKYACmHoQWorBCo08kbCxERyUvhiyACTICUwycI6OABiHpAe1nuaIiISE4KnwIPMAFSDjc3bopKREQStgAxAVIU41R4jgMiIlI04xigcHnjkBETICXRMAEiIiKwBQhMgJSFawEREVF1OXDjV+k5EyBSBK4FREREhu8ATw3g6S9vLDJiAqQkHANERETGPcCUO/4HkDkBSkpKwogRI+Dn54egoCDMnDkTZ8+ebfGcXbt2ITY2Fl26dIG/vz9iYmJw8OBBkzJpaWkQBKHRo6qqypa34/gadoGJoryxEBGRPEoMA6CV2/0FyJwAZWdnY+nSpTh27BgyMzNRW1uLuLg4VFRUNHtOTk4OYmNjsX//fpw6dQoTJ05EfHw8cnNzTcr5+/ujsLDQ5OHp6WnrW3JshmnwtTeAymJ5YyEiInkYusAUvAYQALjL+cMPHDhg8nrr1q0ICgrCqVOnMG7cuCbPSU5ONnm9bt067N27Fx9++CGio6ONxwVBQEhIiNVjdmoqT8A3GCi/Ik2B9Okkd0RERGRvxi4wZSdADjUGqLS0FAAQGBho9jl6vR5lZWWNzikvL0dERAS6d++OGTNmNGohUiwOhCYiUjZOgQcgcwtQQ6IoYuXKlfjNb36DAQMGmH3e+vXrUVFRgdmzZxuP9e3bF2lpaRg4cCC0Wi1SUlIwZswYnD59Gr179250jerqalRXVxtfa7VaAIBOp4NO57z7Zhlib3gPHfy7w63gFOqKL0DvxPdmiabqQYlYDxLWg4T1UE9pdeFekg8BQK1vV4gN7tkV6sGS2AVRdIzRsEuXLsXHH3+MI0eOoHt387LSHTt24OGHH8bevXsxefLkZsvp9XoMHToU48aNQ2pqaqP3165di8TExEbHt2/fDm9vb/Nvwgn0L9iB265+gnNdpuB/3X8vdzhERGRHgliH+LyHIEDEgQGpqFYFyB2SVVVWVuLBBx9EaWkp/P1bnuLvEAnQo48+ij179iAnJweRkZFmnZOeno6FCxfigw8+wF133dVq+T/+8Y+4dOkSPvnkk0bvNdUCFBYWhmvXrrVagY5Mp9MhMzMTsbGxUKlUAAC3E/9Ah4wE6PvMQN2sNHkDtJOm6kGJWA8S1oOE9VBPUXVRehGq16MhdvBA7Z8vAUL9SBhXqAetVovOnTublQDJ2gUmiiIeffRR7N69G1lZWWYnPzt27MBDDz2EHTt2mJX8iKKIvLw8DBw4sMn31Wo11Gp1o+Mqlcpp/xE0ZHIfgREAALeyAri5wL1ZwlX+PtuL9SBhPUhYD/UUURcVRQAAwb8bVB6Nv/cA564HS+KWNQFaunQptm/fjr1798LPzw9FRdJfjEajgZeXFwAgISEBBQUF2LZtGwAp+Zk3bx5SUlIwatQo4zleXl7QaDQAgMTERIwaNQq9e/eGVqtFamoq8vLysHHjRhnu0sFwOwwiIuUyfPYrfAo8IPMssE2bNqG0tBQTJkxAaGio8ZGenm4sU1hYiPz8fOPrN954A7W1tVi6dKnJOcuXLzeWKSkpwSOPPIJ+/fohLi4OBQUFyMnJwciRI+16fw7JMOq/8hqguyFvLEREZF+cAm8kexdYa9LS0kxeZ2VltXrOhg0bsGHDhjZG5eK8OgIevkBNuTQVsnPjWXFEROSimAAZOdQ6QGQHgtBgLSB2gxERKQrXADJiAqREHAdERKRMHANkxARIidgCRESkPKLILrAGmAApkSHz53YYRETKceNXQFcpPTdsjq1gTICUSBMu/ckuMCIi5Si5OaPaN1jaHFvhmAApEbvAiIiUhwOgTTABUiJDF5i2ANDXyRsLERHZB8f/mGACpES+IYDQAdDXAuVX5I6GiIjsgS1AJpgAKVEH9/oBcBwHRESkDIYxQAHh8sbhIJgAKRXHARERKQtbgEwwAVIq41R4JkBERIrAMUAmmAAplbEFiGsBERG5PN0NoOIX6TlbgAAwAVIubodBRKQcpQXSnx6+0qbYxARIsTRcDZqISDGM3V/dpU2xiQmQYnEMEBGRcnD8TyNMgJTK0AdcrQVulMgaChER2VhJgxYgAsAESLk8fACvQOk5u8GIiFyb4XM+gC1ABkyAlIzdYEREymDsAuMiiAZMgJSMA6GJiJShlF1gt2ICpGTGqfD58sZBRES2o9fXT4NnF5gREyAl42KIRESur/wKoNdJm2D7hsgdjcNgAqRkHANEROT6DJ/x/t2kzbAJABMgZWMLEBGR6+P4nyYxAVIyw2yAsiKgtkbeWIiIyDYMawBx/I8JJkBK5tMZcPcEIALaArmjISIiWzC08rMFyAQTICUThAbdYBwHRETkkrgNRpOYACkdxwEREbk2YwsQE6CGmAApnXEtILYAERG5JI4BahITIKUzrgbNxRCJiFxOVSlQXSo95xggE0yAlC6A22EQEbksw2e7V6C0CTYZMQFSOsNvBOwCIyJyPSVcA6g5TICUruGGqKIobyxERGRdhhlgAdwF/lZMgJTOvxsAAairBip+kTsaIiKyJk6BbxYTIKVz9wD8bm6Ox7WAiIhcCxdBbBYTIOJUeCIiV8Up8M2SNQFKSkrCiBEj4Ofnh6CgIMycORNnz55t9bzs7GwMGzYMnp6e6NmzJzZv3tyozM6dOxEVFQW1Wo2oqCjs3r3bFrfgGrgYIhGRa2ILULNkTYCys7OxdOlSHDt2DJmZmaitrUVcXBwqKiqaPef8+fOYPn06xo4di9zcXDz99NN47LHHsHPnTmOZo0ePYs6cOZg7dy5Onz6NuXPnYvbs2Th+/Lg9bsv5GKfCswWIiMhl1NYAZYXScw0HQd/KXc4ffuDAAZPXW7duRVBQEE6dOoVx48Y1ec7mzZsRHh6O5ORkAEC/fv1w8uRJvPLKK7j33nsBAMnJyYiNjUVCQgIAICEhAdnZ2UhOTsaOHTtsd0POSsO1gIiIXE7ZZQCitOm1T2e5o3E4DjUGqLRUWq0yMDCw2TJHjx5FXFycybEpU6bg5MmT0Ol0LZb54osvrByxizCOAeJq0ERELqPhGkCCIG8sDkjWFqCGRFHEypUr8Zvf/AYDBgxotlxRURGCg4NNjgUHB6O2thbXrl1DaGhos2WKioqavGZ1dTWqq6uNr7VaLQBAp9MZkypnZIi91XvwCYEKgFh6CbVOfL/NMbseXBzrQcJ6kLAe6rlqXQjFP8MdgN6/G+rMuDdXqAdLYneYBGjZsmU4c+YMjhw50mpZ4ZZMVry5gF/D402VufWYQVJSEhITExsdz8jIgLe3d6vxOLrMzMwW33evq8RdAIQbxTj44W7UdVDbJzA7a60elIL1IGE9SFgP9VytLm4v+hT9AFzUAnn795t9njPXQ2VlpdllzUqA9u3bZ3EQsbGx8PLyMqvso48+in379iEnJwfdu7c8Uj0kJKRRS87Vq1fh7u6OTp06tVjm1lYhg4SEBKxcudL4WqvVIiwsDHFxcfD39zfrHhyRTqdDZmYmYmNjoVKpWiwrnn0SQnUZpsT0BzrfbqcI7cOSenBlrAcJ60HCeqjnqnXR4eMMoBDo3n8Uuo6d3mp5V6gHQw+OOcxKgGbOnGlRAIIg4IcffkDPnj1bLCeKIh599FHs3r0bWVlZiIyMbPXaMTEx+PDDD02OZWRkYPjw4ca/sJiYGGRmZmLFihUmZUaPHt3kNdVqNdTqxq0eKpXKaf8RNGTWfWjCgav/g6q8EAjtb5/A7MxV/j7bi/UgYT1IWA/1XK4utAUAgA6BPdDBgvty5nqwJG6zB0EXFRVBr9eb9TC322jp0qV45513sH37dvj5+aGoqAhFRUW4ceOGsUxCQgLmzZtnfL148WL8/PPPWLlyJb799lu89dZb2LJlC5544gljmeXLlyMjIwMvvfQSvvvuO7z00ks4dOgQHn/8cXNvV3mMawFxIDQRkUso5UaoLTErAZo/f77Z3VkA8Ic//MGsrqNNmzahtLQUEyZMQGhoqPGRnp5uLFNYWIj8/Pov5cjISOzfvx9ZWVkYMmQInn/+eaSmphqnwAPA6NGj8d5772Hr1q0YNGgQ0tLSkJ6ejjvuuMPse1CcAE6FJyJyGaLYYBFErgLdFLO6wLZu3WrRRTdt2mRWOdGM3cfT0tIaHRs/fjy++uqrFs+bNWsWZs2aZVYcBG6HQUTkSiquAbVVAISbm17TrRxqHSCSEbfDICJyHYbuL78QadNrasTiafBVVVV47bXX8Nlnn+Hq1avQ6/Um77fWMkMOKuDmMuncDoOIyPkZx/+w+6s5FidADz30EDIzMzFr1iyMHDmy2bV1yMkYWoC0l4G6WqCDwywRRUREluImqK2y+Fvu448/xv79+zFmzBhbxENy8Q0B3FSAXidtnhfA3xqIiJyWYTwnP8ubZfEYoG7dusHPz88WsZCc3NwA/67Sc44DIiJybuwCa5XFCdD69evx5z//GT///LMt4iE5cRwQEZFrYALUKou7wIYPH46qqir07NkT3t7ejVZdLC4utlpwZGfGmWBMgIiInBrHALXK4gTogQceQEFBAdatW4fg4GAOgnYlXAuIiMj51VQAldel5xwD1CyLE6AvvvgCR48exeDBg20RD8mJawERETm/UmkPMKj9AU+NvLE4MIvHAPXt29dkry5yIcbtMNgCRETktAx7OnL8T4ssToD++te/4v/+7/+QlZWF69evQ6vVmjzIiTXsAjNjmxIiInJAJdwE1RwWd4FNnToVADBp0iST46IoQhAE1NXVWScysj/DfxZdBXDjV8A7UN54iIjIcoZhDBz/0yKLE6DPPvvMFnGQI1B5AT5dgIpfpG4wJkBERM6HU+DNYnECNH78eFvEQY5C0/1mAnQJCOVAdyIip8Mp8GYxawzQmTNnGm162pL//e9/qK2tbXNQJCNOhScicm7GbTDC5Y3DwZmVAEVHR+P69etmXzQmJgb5+fltDopkpOFMMCIip6WvA7Q3p8GzBahFZnWBiaKIZ599Ft7e3mZdtKampl1BkYw4FZ6IyHmVFQJinbS5tW+I3NE4NLMSoHHjxuHs2bNmXzQmJgZeXl5tDopkxMUQiYicl+Gz27+rtMk1NcusBCgrK8vGYZDD4BggIiLnxfE/ZmN6SKYMCVDFVUBXJW8sRERkmVIugmguJkBkyjsQUN0c62UYSEdERM6BawCZjQkQmRKEBuOA2A1GRORUuAaQ2ZgAUWMcB0RE5JyMY4DYAtQaJkDUGFuAiIicjyiyC8wCFm+FAQDff/89srKycPXq1UYrRD/33HNWCYxkZFwLiFPhiYicRlUJUFMuPWcXWKssToD+8Y9/4E9/+hM6d+6MkJAQCIJgfE8QBCZArkBzc/pkCVfzJiJyGobuL58u0ubW1CKLE6AXXngBL774Iv785z/bIh5yBFwMkYjI+XAAtEUsHgP066+/4r777rNFLOQoDF1g2gLAgk1wiYhIRhz/YxGLE6D77rsPGRkZtoiFHIVfKCC4AXU10oKIRETk+JgAWcTiLrDbbrsNzz77LI4dO4aBAwdCpVKZvP/YY49ZLTiSSQcV4NcV0F6S+pT9uKEeEZHD4xR4i1icAL355pvw9fVFdnY2srOzTd4TBIEJkKvQdJcSoNKLQNgIuaMhIqLWcAyQRSxOgM6fP2+LOMjRBIQBF49xLSAiImfBLjCLtGshRFEUIYqitWIhR8KZYEREzqO2Gii/Ij1nAmSWNiVA27Ztw8CBA+Hl5QUvLy8MGjQIb7/9trVjIzlxOwwiIudh+GVV5S1tak2tsrgL7NVXX8Wzzz6LZcuWYcyYMRBFEf/5z3+wePFiXLt2DStWrLBFnGRvGq4GTUTkNBqO/2mwQDE1z+IE6LXXXsOmTZswb94847G7774b/fv3x9q1a5kAuQrjdhhcDZqIyOFx/I/FLO4CKywsxOjRoxsdHz16NAoLCy26Vk5ODuLj49G1a1cIgoA9e/a0WH7BggUQBKHRo3///sYyaWlpTZapqqqyKDbFM4wBqioFqrTyxkJERC0zDFfgDDCzWZwA3XbbbXj//fcbHU9PT0fv3r0tulZFRQUGDx6M119/3azyKSkpKCwsND4uXryIwMDARitT+/v7m5QrLCyEp6enRbEpntoP8AyQnrMbjIjIsRk+p7kGkNks7gJLTEzEnDlzkJOTgzFjxkAQBBw5cgSffvppk4lRS6ZNm4Zp06aZXV6j0UCj0Rhf79mzB7/++isWLlxoUk4QBISEcPG+dgsIA4pKpKbV4Ci5oyEiouYYhisYNrOmVlmcAN177704fvw4NmzYgD179kAURURFReHLL79EdHS0LWJs1pYtWzB58mRERESYHC8vL0dERATq6uowZMgQPP/88y3GVl1djerqauNrrVbq8tHpdNDpdLYJ3g4Msbf1Hjr4dYNb0deoK74AvYLrwVWwHiSsBwnroZ4r1IV7yUUIAGp9QyC28T5coR4siV0QHWQhH0EQsHv3bsycOdOs8oWFhQgLC8P27dsxe/Zs4/Fjx47h3LlzGDhwILRaLVJSUrB//36cPn262S66tWvXIjExsdHx7du3w9vbu0334woGXnobPX/JxA9Bd+GbbnPkDoeIiJoi6jHj9MPoINYio/+ruOHRWe6IZFNZWYkHH3wQpaWl8Pf3b7GsWQmQVqs1XsjQOtKc1n5gs4FYmAAlJSVh/fr1uHz5Mjw8PJotp9frMXToUIwbNw6pqalNlmmqBSgsLAzXrl1r8/04Ap1Oh8zMTMTGxjbas80cbsdeR4dP10Lf/3eom/mmDSK0j/bWg6tgPUhYDxLWQz2nr4vyK1Cl9IcouKH2zwXSfo5t4PT1AOn7u3PnzmYlQGZ1gXXs2BGFhYUICgpCQEAAhCbWGBBFEYIgoK6urm1RW0AURbz11luYO3dui8kPALi5uWHEiBH44Ycfmi2jVquhVqsbHVepVE77j6ChNt9HYA8AgJu2AG5KrgcXw3qQsB4krId6TlsXFUUAAMGvK1Se7e+1cNp6ACyK26wE6PDhwwgMlFaW/Oyzz9oWlRVlZ2fj3LlzWLRoUatlRVFEXl4eBg4caIfIXAwXQyQicnylnALfFmYlQOPHjzc+j4yMRFhYWKNWIFEUcfGiZdsmlJeX49y5c8bX58+fR15eHgIDAxEeHo6EhAQUFBRg27ZtJudt2bIFd9xxBwYMGNDomomJiRg1ahR69+4NrVaL1NRU5OXlYePGjRbFRqhPgMoKgTpdm5tViYjIhgxrAHEKvEUsngUWGRlp7A5rqLi4GJGRkRZ1gZ08eRITJ040vl65ciUAYP78+UhLS0NhYSHy801XIi4tLcXOnTuRkpLS5DVLSkrwyCOPoKioCBqNBtHR0cjJycHIkSPNjotu8ukCdPAA6moA7WWgY0Tr5xARkX013AaDzGZxAmQY63Or8vJyixcbnDBhQou7yaelpTU6ptFoUFlZ2ew5GzZswIYNGyyKg5rh5ib9hyr+SWpiZQJEROR4uA1Gm5idABlaZwRBwLPPPmsyPbyurg7Hjx/HkCFDrB4gycyYAHEcEBGRQ2IC1CZmJ0C5ubkApBagr7/+2mT2lYeHBwYPHownnnjC+hGSvAyripZYNr6LiIjshGOA2sTsBMgw+2vhwoVISUlx6vVxyAKGPmXuCk9E5Hiqy4CqEuk5xwBZxOIxQFu3brVFHOSoAjgVnojIYRk+mz0DpE2syWwWJ0AAcOLECXzwwQfIz89HTU2NyXu7du2ySmDkIAx9yuwCIyJyPOz+ajM3S0947733MGbMGHzzzTfYvXs3dDodvvnmGxw+fNhkp3ZyEcYusEuAY2wbR0REBhwA3WYWJ0Dr1q3Dhg0b8NFHH8HDwwMpKSn49ttvMXv2bISHh9siRpKTIQGqvQFUXpc3FiIiMsUEqM0sToB+/PFH3HXXXQCkPbQqKiogCAJWrFiBN9903g0zqRnuasA3WHpeym4wIiKHwkUQ28ziBCgwMBBlZWUAgG7duuG///0vAGkF5pYWKCQnxnFARESOiWOA2sziBGjs2LHIzMwEAMyePRvLly/HH//4RzzwwAOYNGmS1QMkB9BwHBARETkOYwsQEyBLWTwL7PXXX0dVVRUAICEhASqVCkeOHMHvfvc7PPvss1YPkByAcSo8W4CIiBxGnQ4ouyw9ZwJkMYsToMDAQONzNzc3rFq1CqtWrbJqUORgNEyAiIgcTlkhIOqlTat9usgdjdOxuAts4sSJ2LJlC0pLS20RDzkijgEiInI8hs9kTXdp82qyiMU1NnDgQKxevRohISG49957sWfPnkaLIZKL4RggIiLHwxlg7WJxApSamoqCggLs3bsXfn5+mD9/PkJCQvDII48gOzvbFjGS3AxjgCqvATWc6UdE5BAMezRquAZfW7SpzczNzQ1xcXFIS0vDlStX8MYbb+DLL7/EnXfeae34yBF4BgAevtJztgIRETmGhl1gZLE27QVmUFRUhPfeew/vvPMOzpw5gxEjRlgrLnIkgiCNA/rlW2kgdJfb5Y6IiIgMv5ByDaA2sbgFSKvVYuvWrYiNjUVYWBg2bdqE+Ph4fP/99zh+/LgtYiRHwKnwRESOhdtgtIvFLUDBwcHo2LEjZs+ejXXr1rHVRyk4EJqIyHGIIgdBt5PFCdDevXsxefJkuHHKnbJwKjwRkeOoLAZ0NyelMAFqE4uzmLi4OOj1ehw6dAhvvPGGcV+wy5cvo7y83OoBkoMwLobIFiAiItkZur98g6VNq8liFrcA/fzzz5g6dSry8/NRXV2N2NhY+Pn54eWXX0ZVVRU2b95sizhJbsYxQPnyxkFERBz/YwUWtwAtX74cw4cPx6+//govLy/j8XvuuQeffvqpVYMjB2JoYtVeBvR18sZCRKR0HP/Tbha3AB05cgT/+c9/4OHhYXI8IiICBQUFVguMHIxfKCB0APS1QFkRoOkmd0RERMplGI/JKfBtZnELkF6vR11d4xaAS5cuwc/PzypBkQNy6wD430x6OA6IiEhe7AJrN4sToNjYWCQnJxtfC4KA8vJyrFmzBtOnT7dmbORouBYQEZFjYALUbhZ3gW3YsAETJ05EVFQUqqqq8OCDD+KHH35A586dsWPHDlvESI7CuBYQEyAiIllxDFC7WZwAde3aFXl5edixYwe++uor6PV6LFq0CL///e9NBkWTC+JaQERE8tPdACp+kZ5zDFCbtWkvMC8vLzz00EN46KGHrB0POTK2ABERyc/Q+uPhK21WTW1iVgK0b98+sy/429/+ts3BkIML4GKIRESyazj+RxDkjcWJmZUAzZw506yLCYLQ5AwxchGacOnPkovSPjT8j0dEZH+cAm8VZiVAer3e1nGQMzCs/VNTBlSVAl4BsoZDRKRIHABtFdzRlMzn4QN4d5KecxwQEZE8OAXeKsxOgKZPn47S0lLj6xdffBElJSXG19evX0dUVJRVgyMHZBwIzXFARESyMLYAMQFqD7MToIMHD6K6utr4+qWXXkJxcbHxdW1tLc6ePWvd6MjxcCo8EZG8Sm5uSs0xQO1idgIkimKLr9siJycH8fHx6Nq1KwRBwJ49e1osn5WVBUEQGj2+++47k3I7d+5EVFQU1Go1oqKisHv37nbHSjdpuBo0EZFs9HXSptQAxwC1k6xjgCoqKjB48GC8/vrrFp139uxZFBYWGh+9e/c2vnf06FHMmTMHc+fOxenTpzF37lzMnj0bx48ft3b4ysTtMIiI5FN+BdDrpM2p/ULljsapmb0QoqG15dZj7TFt2jRMmzbN4vOCgoIQEBDQ5HvJycmIjY1FQkICACAhIQHZ2dlITk7mVh3WYMEYIFEUcUMn/7IIOl0tquuAyppaqETlTt1nPUhYDxLWQz1HqgsvVYeWv1sNn73+3aRNqqnNzE6ARFHEggULoFarAQBVVVVYvHgxfHx8AMBkfJCtRUdHo6qqClFRUVi9ejUmTpxofO/o0aNYsWKFSfkpU6aYbOB6q+rqapP4tVotAECn00Gn01k3eDsyxG7NexB8QuEOQCzJR20r162sqcXg5w9b7We3jztWfekosciJ9SBhPUhYD/Ucoy5OP3snvD2a/2oWrp+HOwC9phvqrPz9ZIvvDHuzJHazE6D58+ebvP7DH/7QqMy8efPM/sFtERoaijfffBPDhg1DdXU13n77bUyaNAlZWVkYN24cAKCoqAjBwcEm5wUHB6OoqKjZ6yYlJSExMbHR8YyMDHh7e1v3JmSQmZlptWt56LSYBkAov4IDH+2F3k3VbNnqOqCNu60QESnSwYMZULfQsHPblU/RH0BBmYCv9u+3SQzW/M6wt8rKSrPLmv3ttHXr1jYFY019+vRBnz59jK9jYmJw8eJFvPLKK8YECGjcNSeKYotNigkJCVi5cqXxtVarRVhYGOLi4uDv72/FO7AvnU6HzMxMxMbGQqVqPlGxiChC/O4JCLVVmDpmENAxsoWiIqZMcYwusMOHD+POO++ESqXchIz1IGE9SFgP9RypLlrrAnM7kAVcBrpGjULIhOlW/dk2+c6wM0MPjjmc/l/9qFGj8M477xhfh4SENGrtuXr1aqNWoYbUarWxa68hlUrltP8IGrL6fWi6A9fPQVVeCATd3mJRDw/r/di20ul0UHcAND6eLvH32VasBwnrQcJ6qOdUdaEtAAB06BiODjaK1Zm/+yyJ2+lXgs7NzUVoaP1I+JiYmEbNdxkZGRg9erS9Q3NdGm6KSkQkC8PnLtcAajdZW4DKy8tx7tw54+vz588jLy8PgYGBCA8PR0JCAgoKCrBt2zYA0gyvHj16oH///qipqcE777yDnTt3YufOncZrLF++HOPGjcNLL72Eu+++G3v37sWhQ4dw5MgRu9+fyzLOBONUeCIiu+I2GFYjawJ08uRJkxlchnE48+fPR1paGgoLC5Gfn298v6amBk888QQKCgrg5eWF/v374+OPP8b06fX9oKNHj8Z7772H1atX49lnn0WvXr2Qnp6OO+64w3435uoCbu4KzwSIiMh+qkqB6ptjXLgIYrvJmgBNmDChxRWl09LSTF6vWrUKq1atavW6s2bNwqxZs9obHjWH22EQEdmf4TPXu5O0OTW1i9OPASIZcENUIiL7M26CytYfa2ACRJYLaDAIWq+XNxYiIqXg+B+rYgJElvPrCkAA6qqBymtyR0NEpAxMgKyKCRBZzt2jfhM+jgMiIrIPw+ctp8BbBRMgahtOhScisi+OAbIqJkDUNsZxQEyAiIjsgl1gVsUEiNqGM8GIiOyntgYou7nNExMgq2ACRG3DtYCIiOxHWwBABNw9AZ/OckfjEpgAUdto2AVGRGQ3Dcf/tLBbPJmPCRC1DccAERHZD8f/WB0TIGobwxigG78C1eXyxkJE5OoMww04A8xqmABR23hqALVGes6B0EREtmVoATJsRk3txgSI2o7dYERE9sEuMKtjAkRtx8UQiYjsg4sgWh0TIGo7ToUnIrI9UaxPgLgNhtUwAaK242KIRES2V3ENqK0CINzcjJqsgQkQtR3HABER2V5pvvSnX6i0GTVZBRMgajvjYohsASIishmO/7EJJkDUdoYESHsZqKuVNxYiIldlGGfJ8T9WxQSI2s43GHBTAWIdUFYodzRERK6JLUA2wQSI2s7NDdB0k55zHBARkW1wDSCbYAJE7cNxQEREtsUEyCaYAFH7GNcCypc3DiIiV8UxQDbBBIjah6tBExHZTk0FcKNYes4xQFbFBIjaJ4BdYERENmP4bFVrpE2oyWqYAFH7cDsMIiLbYfeXzTABovZpOAhaFOWNhYjI1RgHQLP7y9qYAFH7GKbB6yqAG7/KGwsRkavhDDCbYQJE7aPyAny6SM85EJqIyLq4CKLNMAGi9uM4ICIi2+AYIJthAkTtZ5wKz5lgRERWZWwBYgJkbUyAqP0CwqU/2QVGRGQ9dbWAtkB6zgTI6pgAUftxMUQiIusrL5I2m3ZTSZtPk1UxAaL24xggIiLrM3ymarpJm0+TVbFGqf04BoiIyPo4/semZE2AcnJyEB8fj65du0IQBOzZs6fF8rt27UJsbCy6dOkCf39/xMTE4ODBgyZl0tLSIAhCo0dVVZUN70ThDGOAKq4COtYzEZFVlN7cZJoJkE3ImgBVVFRg8ODBeP31180qn5OTg9jYWOzfvx+nTp3CxIkTER8fj9zcXJNy/v7+KCwsNHl4enra4hYIALw6Aipv6TlbgYiIrKOEq0DbkrucP3zatGmYNm2a2eWTk5NNXq9btw579+7Fhx9+iOjoaONxQRAQEhJirTCpNYIg/YZy7aw0ELrzbXJHRETk/Ay/UHINIJuQNQFqL71ej7KyMgQGBpocLy8vR0REBOrq6jBkyBA8//zzJgnSraqrq1FdXW18rdVqAQA6nQ46nc42wduBIXZ73EMH/+5wu3YWtcUXIIY7Vp3Zsx4cGetBwnqQsB7qOWpduJfkQwBQ69sVoh1ic9R6sIQlsTt1ArR+/XpUVFRg9uzZxmN9+/ZFWloaBg4cCK1Wi5SUFIwZMwanT59G7969m7xOUlISEhMTGx3PyMiAt7e3zeK3l8zMTJv/jMGlevQAcO5UFs5eDmytuCzsUQ/OgPUgYT1IWA/1HKouRBF3Ff8MdwBZuedQ8W2F3X60Q9WDhSorK80uK4iiY2zhLQgCdu/ejZkzZ5pVfseOHXj44Yexd+9eTJ48udlyer0eQ4cOxbhx45CamtpkmaZagMLCwnDt2jX4+/tbdB+ORKfTITMzE7GxsVCpVDb9WW7/2YAOWS9CP+h+1MWbN6bLXuxZD46M9SBhPUhYD/Ucsi5u/ArVq9Iv7bpVF6V9F23MIevBQlqtFp07d0ZpaWmr399O2QKUnp6ORYsW4YMPPmgx+QEANzc3jBgxAj/88EOzZdRqNdRqdaPjKpXKaf8RNGSX++gYAQBw0xbAzUHrzFX+PtuL9SBhPUhYD/Ucqi6uFUl/+nSBytu+v4g7VD1YyJK4nW4doB07dmDBggXYvn077rrrrlbLi6KIvLw8hIaG2iE6BTMM0uNq0ERE7Wf4LOUUeJuRtQWovLwc586dM74+f/488vLyEBgYiPDwcCQkJKCgoADbtm0DICU/8+bNQ0pKCkaNGoWiIilD9vLygkajAQAkJiZi1KhR6N27N7RaLVJTU5GXl4eNGzfa/waVxLgYYgGg13PVUiKi9jAugsgp8LYi67fUyZMnER0dbZyhtXLlSkRHR+O5554DABQWFiI/P99Y/o033kBtbS2WLl2K0NBQ42P58uXGMiUlJXjkkUfQr18/xMXFoaCgADk5ORg5cqR9b05p/LoCghug1wHlV+SOhojIuZXc/O4zLDRLVidrC9CECRPQ0hjstLQ0k9dZWVmtXnPDhg3YsGFDOyMji3Vwl5Ig7SXpNxd/djkSEbUZW4Bsjv0UZD3GcUD5LZcjIqKWcQyQzTEBIuvhpqhERNbBFiCbYwJE1mP4TaWEM8GIiNpMV1U/lpJjgGyGCRBZj7EFiAkQEVGbaQukP1Xe0mbTZBNMgMh6DL+psAuMiKjtGo7/EQR5Y3FhTIDIetgFRkTUfobPUO4Cb1NMgMh6DF1g1aVAVam8sRAROSsOgLYLJkBkPWrf+v5qdoMREbUNp8DbBRMgsi5OhSciah8mQHbBBIisS3NzIHQJF0MkImoTjgGyCyZAZF1sASIiaju9vn4aPMcA2RQTILIu43YYnAlGRGSxiqtAXY20ubRfV7mjcWlMgMi62AJERNR2hs9Ov67SJtNkM0yAyLqMY4DYAkREZDHD+EmO/7E5JkBkXYYWoLJCoE4nbyxERM6GawDZDRMgsi6fLkAHNQCxfiAfERGZh1Pg7YYJEFmXmxug6SY9ZzcYEZFlDJ+bbAGyOSZAZH2G31w4EJqIyDKGz03D5tJkM0yAyPo4FZ6IqG1Kbw6CZheYzTEBIuvTMAEiIrJYlbZ+I2l2gdkcEyCyPkMCxDFARETmM3R/eXWUNpcmm2ICRNbHxRCJiCzHKfB2xQSIrC+gwSBoUZQ3FiIiZ2Ec/8MB0PbABIisz//mNPjaG0DldXljISJyFmwBsismQGR97mrAN0R6bljWnYiIWmYYN8ltMOyCCRDZBscBERFZhi1AdsUEiGyDawEREVnGuA0GxwDZAxMgsg22ABERma9OJ20iDbAFyE6YAJFtGH6D4RggIqLWaS8Dol7aTNqni9zRKAITILINYwsQu8CIiFpl7P7qJm0qTTbHWibbCOCGqEREZjMOgOYMMHthAkS2YfhPXHkdqKmQNxYiIkfHKfB2xwSIbMNTA3j4Sc9LC+SNhYjI0Rm7wJgA2QsTILINQWjQDcaB0ERELWICZHdMgMh2OBWeiMg8XATR7mRNgHJychAfH4+uXbtCEATs2bOn1XOys7MxbNgweHp6omfPnti8eXOjMjt37kRUVBTUajWioqKwe/duG0RPrTL8JlPCmWBERM0SRY4BkoGsCVBFRQUGDx6M119/3azy58+fx/Tp0zF27Fjk5ubi6aefxmOPPYadO3cayxw9ehRz5szB3Llzcfr0acydOxezZ8/G8ePHbXUb1By2ABERta6yWNo8GqjfTJpszl3OHz5t2jRMmzbN7PKbN29GeHg4kpOTAQD9+vXDyZMn8corr+Dee+8FACQnJyM2NhYJCQkAgISEBGRnZyM5ORk7duyw+j1QCwJuLobItYCIiJpnGCfpGyJtJk12IWsCZKmjR48iLi7O5NiUKVOwZcsW6HQ6qFQqHD16FCtWrGhUxpA0kR0ZWoCufgN8+hfZwnCr06Pf5XNw+ywX6KDcYW+sBwnrQcJ6qCd7XRT/JP3J8T925VQJUFFREYKDg02OBQcHo7a2FteuXUNoaGizZYqKipq9bnV1Naqrq42vtVotAECn00Gn01nxDuzLELts9+DXHe4QINz4Ffh8vTwxAOgA4HYAuCJbCA6B9SBhPUhYD/UcpS70HSNRJ+N3juzfGVZgSexOlQABgCAIJq9FUWx0vKkytx5rKCkpCYmJiY2OZ2RkwNvbuz3hOoTMzEzZfnb3iP+HgMqfZPv5RETOQC+ocEF/Byr375c7FFm/M9qrsrLS7LJOlQCFhIQ0asm5evUq3N3d0alTpxbL3Noq1FBCQgJWrlxpfK3VahEWFoa4uDj4+/tb8Q7sS6fTITMzE7GxsVCpVDJFMV2mn1vPMepBfqwHCetBwnqo5yh10UO2nyxxlHpoD0MPjjmcKgGKiYnBhx9+aHIsIyMDw4cPN/5lxcTEIDMz02QcUEZGBkaPHt3sddVqNdTqxgPPVCqV0/4jaMhV7qO9WA8S1oOE9SBhPdRjXUicuR4siVvWBKi8vBznzp0zvj5//jzy8vIQGBiI8PBwJCQkoKCgANu2bQMALF68GK+//jpWrlyJP/7xjzh69Ci2bNliMrtr+fLlGDduHF566SXcfffd2Lt3Lw4dOoQjR47Y/f6IiIjIMck69P/kyZOIjo5GdHQ0AGDlypWIjo7Gc889BwAoLCxEfn79NgqRkZHYv38/srKyMGTIEDz//PNITU01ToEHgNGjR+O9997D1q1bMWjQIKSlpSE9PR133HGHfW+OiIiIHJasLUATJkwwDmJuSlpaWqNj48ePx1dffdXidWfNmoVZs2a1NzwiIiJyUcpe/IGIiIgUiQkQERERKQ4TICIiIlIcJkBERESkOEyAiIiISHGYABEREZHiMAEiIiIixWECRERERIrDBIiIiIgUhwkQERERKQ4TICIiIlIcJkBERESkOEyAiIiISHGYABEREZHiMAEiIiIixWECRERERIrDBIiIiIgUhwkQERERKQ4TICIiIlIcJkBERESkOEyAiIiISHGYABEREZHiMAEiIiIixWECRERERIrDBIiIiIgUhwkQERERKQ4TICIiIlIcJkBERESkOEyAiIiISHGYABEREZHiMAEiIiIixWECRERERIrDBIiIiIgUhwkQERERKQ4TICIiIlIc2ROgv//974iMjISnpyeGDRuGzz//vNmyCxYsgCAIjR79+/c3lklLS2uyTFVVlT1uh4iIiJyArAlQeno6Hn/8cTzzzDPIzc3F2LFjMW3aNOTn5zdZPiUlBYWFhcbHxYsXERgYiPvuu8+knL+/v0m5wsJCeHp62uOWiIiIyAnImgC9+uqrWLRoER5++GH069cPycnJCAsLw6ZNm5osr9FoEBISYnycPHkSv/76KxYuXGhSThAEk3IhISH2uB0iIiJyErIlQDU1NTh16hTi4uJMjsfFxeGLL74w6xpbtmzB5MmTERERYXK8vLwcERER6N69O2bMmIHc3FyrxU1ERETOz12uH3zt2jXU1dUhODjY5HhwcDCKiopaPb+wsBCffPIJtm/fbnK8b9++SEtLw8CBA6HVapGSkoIxY8bg9OnT6N27d5PXqq6uRnV1tfF1aWkpAKC4uBg6nc7SW3MYOp0OlZWVuH79OlQqldzhyIb1IGE9SFgPEtZDPdaFxBXqoaysDAAgimKrZWVLgAwEQTB5LYpio2NNSUtLQ0BAAGbOnGlyfNSoURg1apTx9ZgxYzB06FC89tprSE1NbfJaSUlJSExMbHQ8MjLSjDsgIiIiR1JWVgaNRtNiGdkSoM6dO6NDhw6NWnuuXr3aqFXoVqIo4q233sLcuXPh4eHRYlk3NzeMGDECP/zwQ7NlEhISsHLlSuNrvV6P4uJidOrUyaxkzFFptVqEhYXh4sWL8Pf3lzsc2bAeJKwHCetBwnqox7qQuEI9iKKIsrIydO3atdWysiVAHh4eGDZsGDIzM3HPPfcYj2dmZuLuu+9u8dzs7GycO3cOixYtavXniKKIvLw8DBw4sNkyarUaarXa5FhAQECr13YW/v7+TvuP2ZpYDxLWg4T1IGE91GNdSJy9Hlpr+TGQtQts5cqVmDt3LoYPH46YmBi8+eabyM/Px+LFiwFILTMFBQXYtm2byXlbtmzBHXfcgQEDBjS6ZmJiIkaNGoXevXtDq9UiNTUVeXl52Lhxo13uiYiIiByfrAnQnDlzcP36dfzlL39BYWEhBgwYgP379xtndRUWFjZaE6i0tBQ7d+5ESkpKk9csKSnBI488gqKiImg0GkRHRyMnJwcjR460+f0QERGRc5B9EPSSJUuwZMmSJt9LS0trdEyj0aCysrLZ623YsAEbNmywVnhOTa1WY82aNY2695SG9SBhPUhYDxLWQz3WhURp9SCI5swVIyIiInIhsu8FRkRERGRvTICIiIhIcZgAERERkeIwASIiIiLFYQLk5P7+978jMjISnp6eGDZsGD7//HOzzvvPf/4Dd3d3DBkyxLYB2oml9VBdXY1nnnkGERERUKvV6NWrF9566y07RWs7ltbDu+++i8GDB8Pb2xuhoaFYuHAhrl+/bqdobSMnJwfx8fHo2rUrBEHAnj17Wj0nOzsbw4YNg6enJ3r27InNmzfbPlAbs7Qedu3ahdjYWHTp0gX+/v6IiYnBwYMH7ROsDbXl34OBK31OtqUeXPVz0oAJkBNLT0/H448/jmeeeQa5ubkYO3Yspk2b1mjtpFuVlpZi3rx5mDRpkp0ita221MPs2bPx6aefYsuWLTh79ix27NiBvn372jFq67O0Ho4cOYJ58+Zh0aJF+N///ocPPvgAJ06cwMMPP2znyK2roqICgwcPxuuvv25W+fPnz2P69OkYO3YscnNz8fTTT+Oxxx7Dzp07bRypbVlaDzk5OYiNjcX+/ftx6tQpTJw4EfHx8cjNzbVxpLZlaT0YuNrnZFvqwRU/J02I5LRGjhwpLl682ORY3759xaeeeqrF8+bMmSOuXr1aXLNmjTh48GAbRmgfltbDJ598Imo0GvH69ev2CM9uLK2Hv/3tb2LPnj1NjqWmpordu3e3WYz2BkDcvXt3i2VWrVol9u3b1+TY//t//08cNWqUDSOzL3PqoSlRUVFiYmKi9QOSiSX14Gqfkw2ZUw+u+jnZEFuAnFRNTQ1OnTqFuLg4k+NxcXH44osvmj1v69at+PHHH7FmzRpbh2gXbamHffv2Yfjw4Xj55ZfRrVs33H777XjiiSdw48YNe4RsE22ph9GjR+PSpUvYv38/RFHElStX8O9//xt33XWXPUJ2GEePHm1Ub1OmTMHJkyeh0+lkikp+er0eZWVlCAwMlDsUu3O1z8m2cMXPyVvJvhI0tc21a9dQV1eH4OBgk+PBwcEoKipq8pwffvgBTz31FD7//HO4u7vGX31b6uGnn37CkSNH4Onpid27d+PatWtYsmQJiouLnbZ/uy31MHr0aLz77ruYM2cOqqqqUFtbi9/+9rd47bXX7BGywygqKmqy3mpra3Ht2jWEhobKFJm81q9fj4qKCsyePVvuUOzKFT8n28IVPydvxRYgJycIgslrURQbHQOAuro6PPjgg0hMTMTtt99ur/Dsxtx6AKTfbAVBwLvvvouRI0di+vTpePXVV5GWlub0v91YUg/ffPMNHnvsMTz33HM4deoUDhw4gPPnzxs3I1aSpuqtqeNKsWPHDqxduxbp6ekICgqSOxy7cfXPSUu48uekgXLTWyfXuXNndOjQodFv91evXm302ywAlJWV4eTJk8jNzcWyZcsASP/ARVGEu7s7MjIycOedd9oldmuytB4AIDQ0FN26dYNGozEe69evH0RRxKVLl9C7d2+bxmwLbamHpKQkjBkzBk8++SQAYNCgQfDx8cHYsWPxwgsvKKblIyQkpMl6c3d3R6dOnWSKSj7p6elYtGgRPvjgA0yePFnucOzKVT8n28IVPydvxRYgJ+Xh4YFhw4YhMzPT5HhmZiZGjx7dqLy/vz++/vpr5OXlGR+LFy9Gnz59kJeXhzvuuMNeoVuVpfUAAGPGjMHly5dRXl5uPPb999/Dzc0N3bt3t2m8ttKWeqisrISbm+lHQIcOHQDUt4AoQUxMTKN6y8jIwPDhw6FSqWSKSh47duzAggULsH37dsWNBQNc93OyLVzxc7IRuUZfU/u99957okqlErds2SJ+88034uOPPy76+PiIFy5cEEVRFJ966ilx7ty5zZ7vKrMbLK2HsrIysXv37uKsWbPE//3vf2J2drbYu3dv8eGHH5brFqzC0nrYunWr6O7uLv79738Xf/zxR/HIkSPi8OHDxZEjR8p1C1ZRVlYm5ubmirm5uSIA8dVXXxVzc3PFn3/+WRTFxvXw008/id7e3uKKFSvEb775RtyyZYuoUqnEf//733LdglVYWg/bt28X3d3dxY0bN4qFhYXGR0lJiVy3YBWW1sOtXOVz0tJ6cNXPyYaYADm5jRs3ihEREaKHh4c4dOhQMTs72/je/PnzxfHjxzd7rqv8xxZFy+vh22+/FSdPnix6eXmJ3bt3F1euXClWVlbaOWrrs7QeUlNTxaioKNHLy0sMDQ0Vf//734uXLl2yc9TW9dlnn4kAGj3mz58vimLT9ZCVlSVGR0eLHh4eYo8ePcRNmzbZP3Ars7Qexo8f32J5Z9WWfw8NucrnZFvqwVU/Jw0EUVRQWzcREREROAaIiIiIFIgJEBERESkOEyAiIiJSHCZAREREpDhMgIiIiEhxmAARERGR4jABIiIiIsVhAkREdiUIAvbs2SN3GFa3YMECCIJglftbu3at8VrJyclWiY+ITDEBIqJ2a/jlr1KpEBwcjNjYWLz11lvQ6/UmZQsLCzFt2jSzrutsydLUqVMtur/mPPHEEygsLHSdPZeIHBATICKyCsOX/4ULF/DJJ59g4sSJWL58OWbMmIHa2lpjuZCQEKjVahkjtR21Wm2V+/P19UVISIhxc1oisj4mQERkFYYv/27dumHo0KF4+umnsXfvXnzyySdIS0szlmvYqlNTU4Nly5YhNDQUnp6e6NGjB5KSkgAAPXr0AADcc889EATB+PrHH3/E3XffjeDgYPj6+mLEiBE4dOiQSSw9evTAunXr8NBDD8HPzw/h4eF48803TcpcunQJ999/PwIDA+Hj44Phw4fj+PHjxvc//PBDDBs2DJ6enujZsycSExNNEjlzXLhwAYIg4P3338fYsWPh5eWFESNG4Pvvv8eJEycwfPhw+Pr6YurUqfjll18sujYRtQ8TICKymTvvvBODBw/Grl27mnw/NTUV+/btw/vvv4+zZ8/inXfeMSY6J06cAABs3boVhYWFxtfl5eWYPn06Dh06hNzcXEyZMgXx8fHIz883ufb69esxfPhw5ObmYsmSJfjTn/6E7777zniN8ePH4/Lly9i3bx9Onz6NVatWGbvrDh48iD/84Q947LHH8M033+CNN95AWloaXnzxxTbVw5o1a7B69Wp89dVXcHd3xwMPPIBVq1YhJSUFn3/+OX788Uc899xzbbo2EbWNu9wBEJFr69u3L86cOdPke/n5+ejduzd+85vfQBAEREREGN/r0qULACAgIAAhISHG44MHD8bgwYONr1944QXs3r0b+/btw7Jly4zHp0+fjiVLlgAA/vznP2PDhg3IyspC3759sX37dvzyyy84ceIEAgMDAQC33Xab8dwXX3wRTz31FObPnw8A6NmzJ55//nmsWrUKa9assbgOnnjiCUyZMgUAsHz5cjzwwAP49NNPMWbMGADAokWLTFrJiMj2mAARkU2JoghBEJp8b8GCBYiNjUWfPn0wdepUzJgxA3FxcS1er6KiAomJifjoo49w+fJl1NbW4saNG41agAYNGmR8LggCQkJCcPXqVQBAXl4eoqOjjcnPrU6dOoUTJ06YtPjU1dWhqqoKlZWV8Pb2Nuvem4olODgYADBw4ECTY4bYiMg+mAARkU19++23iIyMbPK9oUOH4vz58/jkk09w6NAhzJ49G5MnT8a///3vZq/35JNP4uDBg3jllVdw2223wcvLC7NmzUJNTY1JOZVKZfJaEARjF5eXl1eLMev1eiQmJuJ3v/tdo/c8PT1bPLcpDWMxJIO3Hrt1thwR2RYTICKymcOHD+Prr7/GihUrmi3j7++POXPmYM6cOZg1axamTp2K4uJiBAYGQqVSoa6uzqT8559/jgULFuCee+4BII3nuXDhgkVxDRo0CP/85z+NP+dWQ4cOxdmzZ026xYjItTABIiKrqK6uRlFREerq6nDlyhUcOHAASUlJmDFjBubNm9fkORs2bEBoaCiGDBkCNzc3fPDBBwgJCUFAQAAAaTaXYayMWq1Gx44dcdttt2HXrl2Ij4+HIAh49tlnLW49eeCBB7Bu3TrMnDkTSUlJCA0NRW5uLrp27YqYmBg899xzmDFjBsLCwnDffffBzc0NZ86cwddff40XXnihvVVFRA6As8CIyCoOHDiA0NBQ9OjRA1OnTsVnn32G1NRU7N27t9n1bHx9ffHSSy9h+PDhGDFiBC5cuID9+/fDzU36aFq/fj0yMzMRFhaG6OhoAFLS1LFjR4wePRrx8fGYMmUKhg4dalGsHh4eyMjIQFBQEKZPn46BAwfir3/9qzHOKVOm4KOPPkJmZiZGjBiBUaNG4dVXXzUZpE1Ezk0QRVGUOwgiIme3YMEClJSUWHXl6h49euDxxx/H448/brVrEpGELUBERFby0UcfwdfXFx999FG7rrNu3Tr4+vo2mtlGRNbDFiAiIiu4evUqtFotACA0NBQ+Pj5tvlZxcTGKi4sBSOshaTQaq8RIRPWYABEREZHisAuMiIiIFIcJEBERESkOEyAiIiJSHCZAREREpDhMgIiIiEhxmAARERGR4jABIiIiIsVhAkRERESKwwSIiIiIFOf/AynZd2DXixlOAAAAAElFTkSuQmCC",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(grid.y_of_node[fixed_entry_nodes], entry_nodes_h_values + te[fixed_entry_nodes])\n",
+ "plt.plot(grid.y_of_node[grid.nodes_at_left_edge], te[grid.nodes_at_left_edge])\n",
+ "plt.title(\"Cross-section\")\n",
+ "plt.xlabel(\"Distance [m]\")\n",
+ "plt.ylabel(\"Elevation [m]\")\n",
+ "plt.axis([0.25, 1.75, 0.75, 2.75])\n",
+ "plt.grid(True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We construct our component by passing the arguments we defined previously:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Finally, we run the model and let the water fill our channel\n",
+ "rfd = riverFlowDynamics(grid, dt=dt, mannings_n=n, fixed_entry_nodes=fixed_entry_nodes, fixed_entry_links=fixed_entry_links,\n",
+ " entry_nodes_h_values=entry_nodes_h_values, entry_links_vel_values=entry_links_vel_values)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And finally, we run the simulation for 100 timesteps (10 seconds):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Progress: 99/100\r"
+ ]
+ }
+ ],
+ "source": [
+ "# Running\n",
+ "for timestep in range(n_timesteps):\n",
+ " print(\"Progress: \"+str(timestep)+\"/\"+str(n_timesteps), end='\\r')\n",
+ " rfd.run_one_step()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Exploring the water depth results:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "imshow_grid(grid, \"surface_water__depth\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And the water surface elevation:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGFCAYAAABdSJFpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoA0lEQVR4nO3df3RU9Z3/8deQmAQxM92gCUkJGn/AoaQgm7BrqCiIxg2crHTZb2nxCFXgW44hFiOeGulXrXWbrUdd6gZC6RdNWQE5Ggj0lFVylpJIhVOCSaFqKWi2iZgY4awzIZWEJPf7R5r5OobATGbm3ju5z0fP54+5uZ9735lSePf9/tzPdRmGYQgAAMAko6wOAAAAOAvJBwAAMBXJBwAAMBXJBwAAMBXJBwAAMBXJBwAAMBXJBwAAMFW81QEAAOB058+fV3d3d9jXSUhIUFJSUgQiii6SDwAALHT+/HllZWWpra0t7GuNGzdOTU1Ntk9ASD4AALBQd3e32tra1NLSIrfbPezr+Hw+ZWZmqru7m+QDAABcntudLLc7OYwrxM7bUkg+AACwAcMwFM7r1mLpVW087QIAAExF5QMAAFswFF7rJHYqHyQfAADYgnOSD9ouAADAVFQ+AACwASctOCX5AADAFmi7AAAARAWVDwAAbME5lQ+SDwAAbIA1HwAAwGTOqXyw5gMAAJiKygcAALbgnMoHyQcAADbgpDUftF0AAICpqHwAAGALtF0AAICpnJN80HYBAACmovIBAIANOGnBKckHAAC2QNsFAAAgKqh8AABgC86pfJB8AABgA6z5AAAAJnNO5YM1HwAAwFQkHwAA2IIhqS+MEVrlo6ysTDNmzFBycrJSU1O1YMECnThxIuj5v/3tbxUfH6+bb745pPtKJB8AANjCwJqPcEYoamtrVVRUpMOHD6umpkY9PT3Kz89XZ2fnZed6vV4tWbJEc+fOHdbv6jJiaYUKAAAjjM/nk8fjUXv7B3K7k8O4TodSU2+Q1+uV2+0Oef6nn36q1NRU1dbW6rbbbrvkud/+9rd10003KS4uTtXV1WpsbAzpXlQ+AACwBSMCoz+Z+eLo6uoK6u5er1eSlJKScsnzXn75ZX3wwQd68sknQ/v1voDkAwAAW4hM8pGZmSmPx+MfZWVll7+zYaikpES33nqrsrOzhzzv5MmTeuyxx7R161bFxw//gVketQUAYARpaWkJaLskJiZeds6qVat07NgxHTx4cMhzent7tXjxYv3oRz/SxIkTw4qRNR8AAFhoYM3HJ5/8Kew1H2lpE0Ne81FcXKzq6mrV1dUpKytryPM+++wz/c3f/I3i4uL8x/r6+mQYhuLi4rRv3z7dcccdQd2TygcAALZg7iZjhmGouLhYu3bt0oEDBy6ZeEiS2+3W8ePHA45t2LBB+/fv1+uvv37Z+V9E8gEAgC2Ym3wUFRVp27Zt2r17t5KTk9XW1iZJ8ng8Gj16tCSptLRUp0+f1pYtWzRq1KhB60FSU1OVlJR0yXUiF8OCUwAAHKiiokJer1ezZ89Wenq6f+zYscN/Tmtrq5qbmyN+b9Z8AABgoYE1H21t74e95mPcuMnD3ufDTLRdAACwBV4sBwAAEBVUPgAAsIHhvJ/ly/NjBckHAAC2MPB22nDmxwbaLgAAwFRUPgAAsAXnLDgl+QAAwAactOaDtgsAADAVlQ8AAGyBtgsAADAVyQcAADARaz4AAACihMoHAAC2ETvVi3CQfAAAYAvscAoAABAVVD4AALABJy04JfkAAMAWnPOoLW0XAABgKiofAADYgnMqHyQfAADYgJPWfNB2AQAApqLyAQCALdB2AQAApnLOJmMkHwAA2ABrPgAAAKKEygcAALbAmg8AAGAq5yQftF0AAICpqHwAAGADhtEnwxj+EyvhzDUbyQcAALZA2wUAACAqqHwAAGADTtrng+QDAABboO0CAAAQFVQ+AACwBUPhvZ8ldiofJB8AANgAaz4AAIDJWPMBAAAQFVQ+AACwBedUPkg+AACwhfC2Vw9vsaq5aLsAAABTUfkAAMAWaLsAAABTOSf5oO0CAABMReUDAAAbMIzwFpyGt1jVXCQfAADYAm0XAACAqKDyAQCALTin8kHyAQCADbDmAwAAmMw5lQ/WfAAAAFNR+QAAwAYMw5BhDL96Ec5cs1H5AADAFgz1vxxuuCO05KOsrEwzZsxQcnKyUlNTtWDBAp04ceKSc3bu3Km77rpL11xzjdxut/Ly8vTmm2+GdF+J5AMAAEeqra1VUVGRDh8+rJqaGvX09Cg/P1+dnZ1Dzqmrq9Ndd92lvXv36ujRo5ozZ44KCwvV0NAQ0r1dRizVaQAAGGF8Pp88Ho9OnXpNyclXDvs6HR1/0Y03/i95vV653e6Q53/66adKTU1VbW2tbrvttqDnTZkyRYsWLdITTzwR9BzWfAAAYAORWvPh8/kCjicmJioxMfGy871eryQpJSUl6Hv29fWpo6MjpDkSbRcAAEaUzMxMeTwe/ygrK7vsHMMwVFJSoltvvVXZ2dlB3+v5559XZ2envvWtb4UUI5UPAADswDD6RzjzJbW0tAS0XYKpeqxatUrHjh3TwYMHg77d9u3b9dRTT2n37t1KTU0NKVSSDwAARhC32x3Smo/i4mLt2bNHdXV1Gj9+fFBzduzYoWXLlum1117TnXfeGXKMJB8AADiQYRgqLi7Wrl27dODAAWVlZQU1b/v27XrggQe0fft2zZ8/f1j3JvkAAMAGzN5krKioSNu2bdPu3buVnJystrY2SZLH49Ho0aMlSaWlpTp9+rS2bNkiqT/xWLJkiX72s5/plltu8c8ZPXq0PB5P0PdmwSkAAHZgRGCEoKKiQl6vV7Nnz1Z6erp/7Nixw39Oa2urmpub/Z9//vOfq6enR0VFRQFzvv/974d0byofAADYgNmVj2DOr6ysDPh84MCBkO4xFCofAADAVFQ+AACwg2G0TgbNjxEkHwAA2EGE9vmIBbRdAACAqah8AABgAw4qfJB8AABgCw7KPmi7AAAAU5F8AAAAU9F2AQDABszeZMxKVD4AAICpqHwAAGAHbDIGAABM5aCnXUg+AACwAQflHqz5AAAA5qLyAQCAHTio9EHyAQCADRgKM/eIWCTR57jko6+vTx9//LGSk5PlcrmsDgcAYGOGYaijo0MZGRkaNYqVCpHiuOTj448/VmZmptVhAABiSEtLi8aPHx/dm9B2GbmSk5Ml9f9BcrvdFkcDALAzn8+nzMxM/78dUcU+HyPXQKvF7XaTfAAAgkKbPrIcl3wAAGBHxl//E878WEHyAQCAHTio7cLSXQAAYCoqHwAA2AFPuwAAADM5KPcg+QAAwBYclH2w5gMAAJiKygcAADbgoMIHyQcAALbgoOyDtgsAADAVlQ8AAOzAQZuMkXwAAGADhmHICKN1Es5cs9F2AQAApqLyAQCAHdB2AQAAZqLtAgAAECVUPgAAsAPaLgAAwFQO2mSM5AMAABtwUO7Bmg8AAGAuKh8AANiBoTBLHxGLJOpIPgAAsAMHLTil7QIAAExlafJRV1enwsJCZWRkyOVyqbq6+pLnHzhwQC6Xa9D44x//aE7AAABEiSHDv9HYsEYMlT4sbbt0dnZq2rRpuv/++7Vw4cKg5504cUJut9v/+Zprrgn53j9ZvFiJV1wx6PiF3t4h5/T29V30eM8QxyXJGOJnfcPs6w01b9jXu0TsQxnOLnrDiW84sUX8ex1GDJLUa+Pfdzj3GerP/mXvNUR8w7nesP+7MOn3vdSc4cTec4m/i4aMYRhzLvX313Cud6GrK+Q5knShuzti9xrOtYYyvD91w+SgtoulyUdBQYEKCgpCnpeamqqvfOUrkQ8IAABEXUyu+Zg+fbrS09M1d+5c/eY3v7nkuV1dXfL5fAEDAADbCaflEu4mISaLqeQjPT1dmzZtUlVVlXbu3KlJkyZp7ty5qqurG3JOWVmZPB6Pf2RmZpoYMQAAQTIiMGJETD1qO2nSJE2aNMn/OS8vTy0tLXruued02223XXROaWmpSkpK/J99Ph8JCAAAFoqp5ONibrnlFr3yyitD/jwxMVGJiYkmRgQAwDA4aH/1mE8+GhoalJ6ebnUYAACExUG5h7VrPs6dO6fGxkY1NjZKkpqamtTY2Kjm5mZJ/S2TJUuW+M9ft26dqqurdfLkSb377rsqLS1VVVWVVq1aZUX4AABEzkD2Ec4IQVlZmWbMmKHk5GSlpqZqwYIFOnHixGXn1dbWKicnR0lJSbr++uu1cePGkH9VS5OP+vp6TZ8+XdOnT5cklZSUaPr06XriiSckSa2trf5ERJK6u7u1Zs0aTZ06VbNmzdLBgwf161//Wv/0T/9kSfwAAMSq2tpaFRUV6fDhw6qpqVFPT4/y8/PV2dk55JympibNmzdPs2bNUkNDgx5//HE99NBDqqqqCuneLmM4O0bFMJ/PJ4/Hox/Mn88mY2KTscvNY5OxfmwyFt4cNhkLYp6NNxn7SJLX6w3Y3DKSBv5dqt+7QVeNGT3s65zr/Fy58x4cdqyffvqpUlNTVVtbO+RDHD/4wQ+0Z88evf/++/5jK1eu1O9//3sdOnQo6HvF1KO2AACMWBFqu3x5b6uuIBNCr9crSUpJSRnynEOHDik/Pz/g2N133636+npduHAh6F+V5AMAgBEkMzMzYH+rsrKyy84xDEMlJSW69dZblZ2dPeR5bW1tSktLCziWlpamnp4enTlzJugYY/5pFwAARoQIvdulpaUloO0SzHYTq1at0rFjx3Tw4MHLnutyuQJv+9eKy5ePXwrJBwAANuDfJj2M+ZLkdrtDWvNRXFysPXv2qK6uTuPHj7/kuePGjVNbW1vAsfb2dsXHx2vs2LFB35O2CwAADmQYhlatWqWdO3dq//79ysrKuuycvLw81dTUBBzbt2+fcnNzdcVFHuIYCskHAAB2YPI+H0VFRXrllVe0bds2JScnq62tTW1tbfr888/953x5v62VK1fqz3/+s0pKSvT+++/rpZde0ubNm7VmzZqQ7k3yAQCADZice6iiokJer1ezZ89Wenq6f+zYscN/zpf328rKytLevXt14MAB3Xzzzfrxj3+sF198UQsXLgzp3qz5AADAgYJZX1JZWTno2O2336533nknrHuTfAAAYAcOerkLyQcAAHYQoUdtYwHJBwAANhCpR21jAQtOAQCAqah8AABgB7RdAACAmWi7AAAARAmVDwAA7CJ2ihdhIfkAAMAOHLTPB20XAABgKiofAADYgJMWnJJ8AABgBw561Ja2CwAAMBWVDwAAbMBJbRdLKx91dXUqLCxURkaGXC6XqqurLzuntrZWOTk5SkpK0vXXX6+NGzdGP1AAAKKtLwIjRliafHR2dmratGkqLy8P6vympibNmzdPs2bNUkNDgx5//HE99NBDqqqqinKkAABE2cCjtuGMGGFp26WgoEAFBQVBn79x40ZNmDBB69atkyRNnjxZ9fX1eu6557Rw4cIoRQkAACIp6MrHRx99FM04gnLo0CHl5+cHHLv77rtVX1+vCxcuXHROV1eXfD5fwAAAwG4cVPgIPvnIzs7Wf/zHf0Qzlstqa2tTWlpawLG0tDT19PTozJkzF51TVlYmj8fjH5mZmWaECgBAaByUfQSdfPzkJz9RUVGRFi5cqLNnz0YzpktyuVwBnwdW9375+IDS0lJ5vV7/aGlpiXqMAABgaEEnHw8++KB+//vf63/+5380ZcoU7dmzJ5pxXdS4cePU1tYWcKy9vV3x8fEaO3bsReckJibK7XYHDAAA7MZBhY/QFpxmZWVp//79Ki8v18KFCzV58mTFxwde4p133ologF+Ul5enX/3qVwHH9u3bp9zcXF1xxRVRuy8AAFHnoBfLhfy0y5///GdVVVUpJSVF99xzz6DkIxTnzp3TqVOn/J+bmprU2NiolJQUTZgwQaWlpTp9+rS2bNkiSVq5cqXKy8tVUlKiFStW6NChQ9q8ebO2b98+7BgAAIC5QsocfvGLX+iRRx7RnXfeqT/84Q+65pprwrp5fX295syZ4/9cUlIiSVq6dKkqKyvV2tqq5uZm/8+zsrK0d+9ePfzww1q/fr0yMjL04osv8pgtACD2UfkY7B/+4R/0u9/9TuXl5VqyZElEbj579uxLbgdbWVk56Njtt98e1dYOAABWMPr6RzjzY0XQyUdvb6+OHTum8ePHRzMeAAAwwgWdfNTU1EQzDgAAnM1QmG2XiEUSdbzVFgAAG3DQkg+SDwAAbMFB2Yelb7UFAADOQ+UDAAA7cFDlg+QDAAAbMIwwH7WNndyDtgsAADAXlQ8AAOyAtgsAADCTg3IP2i4AAMBcVD4AALADB5U+SD4AALABwzAu+bLVYObHCtouAADAVFQ+AACwg76/jnDmxwiSDwAA7IA1HwAAwEwOyj1Y8wEAAMxF5QMAADvoM/pHOPNjBMkHAAA2wKO2AAAAUULlAwAAOzD+OsKZHyMsr3xs2LBBWVlZSkpKUk5Ojt56660hzz1w4IBcLteg8cc//tHEiAEAiIKBx13CGTHC0uRjx44dWr16tdauXauGhgbNmjVLBQUFam5uvuS8EydOqLW11T9uuukmkyIGAADhsjT5eOGFF7Rs2TItX75ckydP1rp165SZmamKiopLzktNTdW4ceP8Iy4uzqSIAQCIkj5DRhgjlp52sSz56O7u1tGjR5Wfnx9wPD8/X2+//fYl506fPl3p6emaO3eufvOb31zy3K6uLvl8voABAIDtGBEYMcKy5OPMmTPq7e1VWlpawPG0tDS1tbVddE56ero2bdqkqqoq7dy5U5MmTdLcuXNVV1c35H3Kysrk8Xj8IzMzM6K/BwAACI3lC05dLlfAZ8MwBh0bMGnSJK1YsUJ/+7d/q7y8PG3YsEHz58/Xc889N+T1S0tL5fV6/aOlpSWi8QMAEAmGDP9eH8Mawyh91NXVqbCwUBkZGXK5XKqurr7snK1bt2ratGm68sorlZ6ervvvv19nz54N6b6WJR9XX3214uLiBlU52tvbB1VDLuWWW27RyZMnh/x5YmKi3G53wAAAwHb6IjBC1NnZqWnTpqm8vDyo8w8ePKglS5Zo2bJlevfdd/Xaa6/pyJEjWr58eUj3tWyfj4SEBOXk5Kimpkbf/OY3/cdramp0zz33BH2dhoYGpaenh3z/x7dtIxEBAFySz+eTx+Mx5V5W7HBaUFCggoKCoM8/fPiwrrvuOj300EOSpKysLH3ve9/Ts88+G9J9Ld1krKSkRPfdd59yc3OVl5enTZs2qbm5WStXrpTU3zI5ffq0tmzZIklat26drrvuOk2ZMkXd3d165ZVXVFVVpaqqKit/DQAAbOPLD1YkJiYqMTExIteeOXOm1q5dq71796qgoEDt7e16/fXXNX/+/JCuY2nysWjRIp09e1ZPP/20WltblZ2drb179+raa6+VJLW2tgbs+dHd3a01a9bo9OnTGj16tKZMmaJf//rXmjdvnlW/AgAAkRGhF8t9+cGKJ598Uk899VQYgf1/M2fO1NatW7Vo0SKdP39ePT09+sd//Ef9+7//e0jXcRmx9CaaCBgooXm9XtouAIBLMuPfjIF71Pz4hxqTlDTs63SeP6+7/s8zamlpCYg12MqHy+XSrl27tGDBgiHPee+993TnnXfq4Ycf1t13363W1lY9+uijmjFjhjZv3hx0rLzbBQCAESSaD1eUlZXpG9/4hh599FFJ0tSpUzVmzBjNmjVLzzzzTNBrMEk+AACwASsWnIbqL3/5i+LjA1OHgV3GQ7k/yQcAAHYQoTUfoTh37pxOnTrl/9zU1KTGxkalpKRowoQJgx78KCws1IoVK1RRUeFvu6xevVp/93d/p4yMjKDvS/IBAIBD1dfXa86cOf7PJSUlkqSlS5eqsrJy0IMf3/3ud9XR0aHy8nI98sgj+spXvqI77rhDP/3pT0O6L8kHAAA2YBj9I5z5oZo9e/Yl2yWVlZWDjhUXF6u4uDj0m30ByQcAAHZgQdvFKpa/2wUAADgLlQ8AAGwgFp52iRSSDwAA7GCYL4cLmB8jSD4AALCB/gWn4VQ+IhhMlLHmAwAAmIrKBwAAdmCE+bRLDJU+SD4AALAD468jnPkxgrYLAAAwFZUPAABsgEdtAQCAqZyUfNB2AQAApqLyAQCADThojzGSDwAA7IC2CwAAQJRQ+QAAwAacVPkg+QAAwAYctMeY9W2XDRs2KCsrS0lJScrJydFbb711yfNra2uVk5OjpKQkXX/99dq4caNJkQIAED0DlY9wRqywNPnYsWOHVq9erbVr16qhoUGzZs1SQUGBmpubL3p+U1OT5s2bp1mzZqmhoUGPP/64HnroIVVVVZkcOQAAGC5Lk48XXnhBy5Yt0/LlyzV58mStW7dOmZmZqqiouOj5Gzdu1IQJE7Ru3TpNnjxZy5cv1wMPPKDnnnvO5MgBAIgsKh8m6O7u1tGjR5Wfnx9wPD8/X2+//fZF5xw6dGjQ+Xfffbfq6+t14cKFi87p6uqSz+cLGAAA2A3JhwnOnDmj3t5epaWlBRxPS0tTW1vbRee0tbVd9Pyenh6dOXPmonPKysrk8Xj8IzMzMzK/AAAAGBbLF5y6XK6Az4ZhDDp2ufMvdnxAaWmpvF6vf7S0tIQZMQAAkWdEYMQKyx61vfrqqxUXFzeoytHe3j6oujFg3LhxFz0/Pj5eY8eOveicxMREJSYm+j8PJCu0XwAAlzPwb4UpLY1wWycx1HaxLPlISEhQTk6Oampq9M1vftN/vKamRvfcc89F5+Tl5elXv/pVwLF9+/YpNzdXV1xxRVD37ejokCTaLwCAoHV0dMjj8Vgdxohh6SZjJSUluu+++5Sbm6u8vDxt2rRJzc3NWrlypaT+lsnp06e1ZcsWSdLKlStVXl6ukpISrVixQocOHdLmzZu1ffv2oO+ZkZGhlpYWJScny+VyyefzKTMzUy0tLXK73VH5PWMB30M/vod+fA/9+B76Ofl7MAxDHR0dysjIMOVe7HBqgkWLFuns2bN6+umn1draquzsbO3du1fXXnutJKm1tTVgz4+srCzt3btXDz/8sNavX6+MjAy9+OKLWrhwYdD3HDVqlMaPHz/ouNvtdtz/qC6G76Ef30M/vod+fA/9nPo9mFXxcNIOp5Zvr/7ggw/qwQcfvOjPKisrBx27/fbb9c4770Q5KgAAzOWkyoflT7sAAABnsbzyYbXExEQ9+eSTAU/EOBHfQz++h358D/34HvrxPZjDSZUPlxFL0QIAMML4fD55PB5tLyrSlWEkeH/p6tJ31q+X1+u1/doc2i4AAMBUjm+7AABgB31/HeHMjxUkHwAA2ICT1nzQdgEAAKai8gEAgA1Q+XCIDRs2KCsrS0lJScrJydFbb71ldUimq6urU2FhoTIyMuRyuVRdXW11SJYoKyvTjBkzlJycrNTUVC1YsEAnTpywOizTVVRUaOrUqf6dLPPy8vSf//mfVodlqbKyMrlcLq1evdrqUEz31FNPyeVyBYxx48ZZHdaINZB8hDNihWOTjx07dmj16tVau3atGhoaNGvWLBUUFARs5+4EnZ2dmjZtmsrLy60OxVK1tbUqKirS4cOHVVNTo56eHuXn56uzs9Pq0Ew1fvx4/eu//qvq6+tVX1+vO+64Q/fcc4/effddq0OzxJEjR7Rp0yZNnTrV6lAsM2XKFLW2tvrH8ePHrQ4JI4Bj2y4vvPCCli1bpuXLl0uS1q1bpzfffFMVFRUqKyuzODrzFBQUqKCgwOowLPfGG28EfH755ZeVmpqqo0eP6rbbbrMoKvMVFhYGfP6Xf/kXVVRU6PDhw5oyZYpFUVnj3Llzuvfee/WLX/xCzzzzjNXhWCY+Pp5qh0mc9G4XR1Y+uru7dfToUeXn5wccz8/P19tvv21RVLATr9crSUpJSbE4Euv09vbq1VdfVWdnp/Ly8qwOx3RFRUWaP3++7rzzTqtDsdTJkyeVkZGhrKwsffvb39aHH35odUgjlpPaLo6sfJw5c0a9vb1KS0sLOJ6Wlqa2tjaLooJdGIahkpIS3XrrrcrOzrY6HNMdP35ceXl5On/+vK666irt2rVLX/va16wOy1Svvvqq3nnnHR05csTqUCz193//99qyZYsmTpyoTz75RM8884xmzpypd999V2PHjrU6vBHHUHiLRmMn9XBo8jHA5XIFfDYMY9AxOM+qVat07NgxHTx40OpQLDFp0iQ1Njbqs88+U1VVlZYuXara2lrHJCAtLS36/ve/r3379ikpKcnqcCz1xZbs17/+deXl5emGG27QL3/5S5WUlFgYGWKdI5OPq6++WnFxcYOqHO3t7YOqIXCW4uJi7dmzR3V1dRo/frzV4VgiISFBN954oyQpNzdXR44c0c9+9jP9/Oc/tzgycxw9elTt7e3KycnxH+vt7VVdXZ3Ky8vV1dWluLg4CyO0zpgxY/T1r39dJ0+etDqUEanPMNQXRuUjnLlmc+Saj4SEBOXk5KimpibgeE1NjWbOnGlRVLCSYRhatWqVdu7cqf379ysrK8vqkGzDMAx1dXVZHYZp5s6dq+PHj6uxsdE/cnNzde+996qxsdGxiYckdXV16f3331d6errVoYxIRgRGrHBk5UOSSkpKdN999yk3N1d5eXnatGmTmpubtXLlSqtDM9W5c+d06tQp/+empiY1NjYqJSVFEyZMsDAycxUVFWnbtm3avXu3kpOT/VUxj8ej0aNHWxydeR5//HEVFBQoMzNTHR0devXVV3XgwIFBTwONZMnJyYPW+owZM0Zjx4513BqgNWvWqLCwUBMmTFB7e7ueeeYZ+Xw+LV261OrQEOMcm3wsWrRIZ8+e1dNPP63W1lZlZ2dr7969uvbaa60OzVT19fWaM2eO//NAH3fp0qWqrKy0KCrzVVRUSJJmz54dcPzll1/Wd7/7XfMDssgnn3yi++67T62trfJ4PJo6dareeOMN3XXXXVaHBgt89NFH+s53vqMzZ87ommuu0S233KLDhw877u9Jszhph1OXEUvRAgAwwvh8Pnk8Hm1avlxXJiQM+zp/6e7W//6//1der1dutzuCEUaeI9d8AAAA6zi27QIAgK2Eu1FYDDUySD4AALABHrUFAACIEiofAADYgJOedqHyAQCADVixyVhdXZ0KCwuVkZEhl8ul6urqy87p6urS2rVrde211yoxMVE33HCDXnrppZDuS+UDAAAbsKLy0dnZqWnTpun+++/XwoULg5rzrW99S5988ok2b96sG2+8Ue3t7erp6QnpviQfAAA4VEFBQcALBC/njTfeUG1trT788EOlpKRIkq677rqQ70vbBXCo3t5ezZw5c9D/2/F6vcrMzNQPf/hDiyIDnGngaZdwhtS/adkXRyTfzbRnzx7l5ubq2Wef1Ve/+lVNnDhRa9as0eeffx7SdUg+AIeKi4vTL3/5S73xxhvaunWr/3hxcbFSUlL0xBNPWBgd4DwDbZdwhiRlZmbK4/H4R1lZWcRi/PDDD3Xw4EH94Q9/0K5du7Ru3Tq9/vrrKioqCuk6tF0AB7vppptUVlam4uJizZkzR0eOHNGrr76q3/3ud0oIY5tnANZpaWkJ2F49MTExYtfu6+uTy+XS1q1b5fF4JEkvvPCC/vmf/1nr168P+kWcJB+AwxUXF2vXrl1asmSJjh8/rieeeEI333yz1WEBjhOpBadutztq73ZJT0/XV7/6VX/iIUmTJ0+WYRj66KOPdNNNNwV1HdougMO5XC5VVFTov/7rv5SWlqbHHnvM6pAAR4pU2yWavvGNb+jjjz/WuXPn/Mf+9Kc/adSoURo/fnzQ1yH5AKCXXnpJV155pZqamvTRRx9ZHQ4Ak5w7d06NjY1qbGyUJDU1NamxsVHNzc2SpNLSUi1ZssR//uLFizV27Fjdf//9eu+991RXV6dHH31UDzzwQNAtF4nkA3C8Q4cO6d/+7d+0e/du5eXladmyZTG1UyIwUvRFYISqvr5e06dP1/Tp0yVJJSUlmj59un/BeWtrqz8RkaSrrrpKNTU1+uyzz5Sbm6t7771XhYWFevHFF0O6r8vgbxnAsT7//HNNmzZN+fn5Ki8vV3Nzs7Kzs/Xss89q5cqVVocHOILP55PH49Hz996r0WEs9P68u1uPbN0qr9cbtTUfkULlA3Cwxx57TH19ffrpT38qSZowYYKef/55Pfroo/rv//5va4MDMGKRfAAOVVtbq/Xr16uyslJjxozxH1+xYoVmzpxJ+wUwWSwsOI0UHrUFHOr2228f8n0Mb775psnRAPjiLqXDnR8rSD4AALABK14sZxXaLgAAwFRUPgAAsINw123EUOWD5AMAABtw0poP2i4AAMBUVD4AALABQ+EtGo2dugfJBwAAtsDTLgAAAFFC5QMAABtw0oJTkg8AAGyAtgsAAECUUPkAAMAGaLsAAABTOantQvIBAIANOKnywZoPAABgKiofAADYAG0XAABgKtouAAAAUULlAwAAG6DtAgAATGWE2XaJpeSDtgsAADAVlQ8AAGyAtgsAADAVT7sAAABECZUPAABsgLYLAAAwlZPaLiQfAADYgJOSD9Z8AAAAU1H5AADABljzAQAATEXbBQAAIEqofAAAYANOqnyQfAAAYAOGYcjo6wtrfqyg7QIAAExF5QMAABug7QIAAExlhJl80HYBAAAYApUPAABsgLYLAAAwVV9fn/rCeNolnLlmI/kAAMAGnLS9Oms+AACAqah8AABgA6z5AAAApnLSmg/aLgAAwFRUPgAAsAHaLgAAwFROSj5ouwAAAFNR+QAAwAactOCU5AMAABvoMwz10nYBAAAjWV1dnQoLC5WRkSGXy6Xq6uqg5/72t79VfHy8br755pDvS/IBAIANDLRdwhmh6uzs1LRp01ReXh7SPK/XqyVLlmju3Lkh31Oi7QIAgC30KbzWyXBWfBQUFKigoCDked/73ve0ePFixcXFhVQtGUDlAwAAG4hU5cPn8wWMrq6uiMb58ssv64MPPtCTTz457GuQfAAAMIJkZmbK4/H4R1lZWcSuffLkST322GPaunWr4uOH3zyh7QIAgA309vVplMsV1nxJamlpkdvt9h9PTEwMOzZJ6u3t1eLFi/WjH/1IEydODOtaJB8AANhApHY4dbvdAclHpHR0dKi+vl4NDQ1atWpV/z37+mQYhuLj47Vv3z7dcccdQV2L5AMAAFyW2+3W8ePHA45t2LBB+/fv1+uvv66srKygr0XyAQCADUSq7RKKc+fO6dSpU/7PTU1NamxsVEpKiiZMmKDS0lKdPn1aW7Zs0ahRo5SdnR0wPzU1VUlJSYOOXw7JBwAANtDX16e+MJKP4ezzUV9frzlz5vg/l5SUSJKWLl2qyspKtba2qrm5edgxDcVlGDG0HysAACOMz+eTx+NR/te+pivi4oZ9nQu9vdr33nvyer1RWfMRSVQ+AACwgb6+PvWaXPmwCskHAAA20NvXJ5fJaz6swiZjAADAVFQ+AACwASdVPkg+AACwASuedrEKyQcAADbQE2byEO58M7HmAwAAmIrKBwAANtDb2ytXGFtvseYDAACEJNzkIZaSD9ouAADAVFQ+AACwgd7eXom2CwAAMMuFri71jRp+QyKWkg/aLgAAwFRUPgAAsIELFy6EtclYbwy9pJ7kAwAAG+jp6gpvh9MYSj5ouwAAAFNR+QAAwAa6LlwIqyIQO8tNST4AALBUQkKCxo0bp4/b2sK+1rhx45SQkBCBqKLLZRgx1CQCAGAEOn/+vLq7u8O+TkJCgpKSkiIQUXSRfAAAAFOx4BQAAJiK5AMAAJiK5AMAAJiK5AMAAJiK5AMAAJiK5AMAAJiK5AMAAJjq/wF9cPeqNfVe9wAAAABJRU5ErkJggg==",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "imshow_grid(grid, \"surface_water__elevation\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-- --\n",
+ "## Example 2: Surface water flowing over a DEM\n",
+ "\n",
+ "On this case, we will import a digital elevation model (DEM) for a side-channel of the Kootenai River, Idaho, US."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Getting the grid and some parameters\n",
+ "asc_file = \"C:\\\\UI\\\\Landlab_2D_Model\\\\DEM_to_test\\\\cropping_kootenai_river\\\\DEM-kootenai_37x50_1x1.asc\"\n",
+ "(grid, teDEM) = read_esri_ascii(asc_file, grid=None, reshape=False, name=None, halo=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Again, we specify some basic parameters such as the time step number and duration. For simplicity, we will keep our previous Manning's coefficient."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Basic parameters\n",
+ "n = 0.012 # Manning's roughness coefficient, [s/m^(1/3)]\n",
+ "\n",
+ "# Simulation parameters\n",
+ "n_timesteps = 75 # Number of timesteps\n",
+ "dt = 1.0 # Timestep duration, [s]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Since the topography is provided by the DEM, we just need to assign it to our `\"topographic__elevation\"` field. It also provides the number of nodes and grid spacing, because they are inherent properties of the DEM."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# The grid represents a basic rectangular channel with slope equal to 0.01 m/m\n",
+ "te = grid.add_zeros(\"topographic__elevation\", at=\"node\")\n",
+ "te += teDEM"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's see our new topography:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Showing the topography\n",
+ "imshow_grid(grid, \"topographic__elevation\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Our side-channel is empty at the beggining of the simulation, so we create the proper fields:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# We establish the initial conditions, which represent an empty channel\n",
+ "h = grid.add_zeros(\"surface_water__depth\", at=\"node\")\n",
+ "\n",
+ "# Water velocity is zero in everywhere since there is no water yet\n",
+ "vel = grid.add_zeros(\"surface_water__velocity\", at=\"link\")\n",
+ "\n",
+ "# Calculating the initial water surface elevation from water depth and topographic elevation\n",
+ "wse = grid.add_zeros(\"surface_water__elevation\", at=\"node\")\n",
+ "wse += h + te"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Then, we specify the nodes at which water is entering into the domain, and also the associated links. These are going to be our entry boundary conditions for water depth and velocity. On this case, water flows from right to left:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# We set fixed boundary conditions, specifying the nodes and links in which the water is flowing into the grid\n",
+ "fixed_entry_nodes = grid.nodes_at_right_edge\n",
+ "fixed_entry_links = grid.links_at_node[fixed_entry_nodes][:,2]\n",
+ "\n",
+ "# We set the fixed values in the entry nodes/links\n",
+ "entry_nodes_h_values = np.array([ 0. , 0. , 0. , 0. , 0. ,\n",
+ " 0. , 0. , 0. , 0. , 0. ,\n",
+ " 0. , 0. , 0.04998779, 0.05999756, 0.03997803,\n",
+ " 0. , 0. , 0. , 0.05999756, 0.10998535,\n",
+ " 0.12994385, 0.09997559, 0.15997314, 0.23999023, 0.30999756,\n",
+ " 0.36999512, 0.45996094, 0.50994873, 0.54998779, 0.59997559,\n",
+ " 0.63995361, 0.65997314, 0.65997314, 0.60998535, 0.5 ,\n",
+ " 0.13995361, 0. ])\n",
+ "entry_links_vel_values = np.array([ 0. , 0. , 0. , 0. , 0. ,\n",
+ " 0. , 0. , 0. , 0. , 0. ,\n",
+ " 0. , 0. , -2.58638018, -2.58638018, -2.58638018,\n",
+ " 0. , 0. , 0. , -2.58638018, -2.58638018,\n",
+ " -2.58638018, -2.58638018, -2.58638018, -2.58638018, -2.58638018,\n",
+ " -2.58638018, -2.58638018, -2.58638018, -2.58638018, -2.58638018,\n",
+ " -2.58638018, -2.58638018, -2.58638018, -2.58638018, -2.58638018,\n",
+ " -2.58638018, 0. ])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can plot our entry boundary condition in the cross-section:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plt.plot(grid.y_of_node[fixed_entry_nodes], entry_nodes_h_values + te[fixed_entry_nodes])\n",
+ "plt.plot(grid.y_of_node[grid.nodes_at_right_edge], te[grid.nodes_at_right_edge])\n",
+ "plt.title(\"Entry cross-section\")\n",
+ "plt.xlabel(\"Distance [m]\")\n",
+ "plt.ylabel(\"Elevation [m]\")\n",
+ "plt.grid(True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Then we create the component by passing the arguments defined previously:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Finally, we run the model and let the water fill our channel\n",
+ "rfd = riverFlowDynamics(grid, dt=dt, mannings_n=n, fixed_entry_nodes=fixed_entry_nodes, fixed_entry_links=fixed_entry_links,\n",
+ " entry_nodes_h_values=entry_nodes_h_values, entry_links_vel_values=entry_links_vel_values)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And we run 75 time steps of 1 $s$ duration (around 1 minute of computing time):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Running\n",
+ "for timestep in range(n_timesteps):\n",
+ " print(\"Progress: \"+str(timestep)+\"/\"+str(n_timesteps), end='\\r')\n",
+ " rfd.run_one_step()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, we can explore the results by plotting the resulting water depth:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "imshow_grid(grid, \"surface_water__depth\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "-- --\n",
+ "### And that's it! \n",
+ "\n",
+ "Nice work completing this tutorial. You know now how to use the `riverFlowDynamics` Landlab component to run your own simulations :)\n",
+ "\n",
+ "-- --\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Click here for more Landlab tutorials"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/noxfile.py b/noxfile.py
index 50584420f6..fd8861e251 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -10,7 +10,7 @@
PYTHON_VERSION = "3.11"
-@nox.session(python=PYTHON_VERSION, venv_backend="mamba")
+@nox.session(python=PYTHON_VERSION, venv_backend="conda")
def test(session: nox.Session) -> None:
"""Run the tests."""
os.environ["WITH_OPENMP"] = "1"
@@ -33,8 +33,10 @@ def test(session: nox.Session) -> None:
if "CI" in os.environ:
args.append(f"--cov-report=xml:{ROOT.absolute()!s}/coverage.xml")
- session.run("pytest", *args)
-
+ # session.run("pytest", *args)
+ session.run(
+ "pytest", *args, "landlab/components/river_flow_dynamics/river_flow_dynamics.py"
+ )
if "CI" not in os.environ:
session.run("coverage", "report", "--ignore-errors", "--show-missing")
diff --git a/tests/components/river_flow_dynamics/__init__.py b/tests/components/river_flow_dynamics/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/components/river_flow_dynamics/test_river_flow_dynamics.py b/tests/components/river_flow_dynamics/test_river_flow_dynamics.py
new file mode 100644
index 0000000000..d3e12097ef
--- /dev/null
+++ b/tests/components/river_flow_dynamics/test_river_flow_dynamics.py
@@ -0,0 +1,101 @@
+"""
+Unit tests for landlab.components.river_flow_dynamics.river_flow_dynamics
+
+last updated: 10/15/2023
+"""
+import numpy as np
+import pytest
+from landlab import RasterModelGrid
+from landlab.components import river_flow_dynamics
+
+@pytest.fixture
+def rfd():
+ grid = RasterModelGrid((10,10), xy_spacing=0.1)
+ grid.add_zeros("topographic__elevation", at="node")
+ grid.add_zeros("surface_water__depth", at="node")
+ grid.add_zeros("surface_water__elevation", at="node")
+ grid.add_zeros("surface_water__velocity", at="link")
+ return river_flow_dynamics(grid)
+
+
+def test_name(rfd):
+ """Test component name"""
+ print(rfd.name)
+ assert rfd.name == "river_flow_dynamics"
+
+
+def test_input_var_names(rfd):
+ """Test input variable names"""
+ assert rfd.input_var_names == (
+ "surface_water__depth",
+ "surface_water__elevation",
+ "surface_water__velocity",
+ "topographic__elevation",
+ )
+
+
+def test_output_var_names(rfd):
+ """Test output variable names"""
+ assert rfd.output_var_names == (
+ "surface_water__depth",
+ "surface_water__elevation",
+ "surface_water__velocity",
+ )
+
+def test_var_units(rfd):
+ assert rfd.var_units("surface_water__depth") == "m"
+ assert rfd.var_units("surface_water__elevation") == "m"
+ assert rfd.var_units("surface_water__velocity") == "m/s"
+ assert rfd.var_units("topographic__elevation") == "m"
+
+
+def test_initialization():
+ """Test initialization with various parameters."""
+ grid = RasterModelGrid((10,10), xy_spacing=0.1)
+ grid.add_zeros("topographic__elevation", at="node")
+ grid.add_zeros("surface_water__depth", at="node")
+ grid.add_zeros("surface_water__elevation", at="node")
+ grid.add_zeros("surface_water__velocity", at="link")
+ rfd = river_flow_dynamics(grid)
+
+ # Making sure fields have been created
+ for field_name in rfd._info:
+ if rfd._info[field_name]["mapping"] == "node":
+ assert field_name in rfd.grid.at_node
+ elif rfd._info[field_name]["mapping"] == "link":
+ assert field_name in rfd.grid.at_link
+
+ # Re-initialize, this time with fields already existing in the grid
+ # (this triggers the "if" instead of "else" in the field setup in init)
+ rfd = river_flow_dynamics(grid)
+
+def test_run_one_step():
+ grid = RasterModelGrid((10,10), xy_spacing=0.1)
+ grid.add_zeros("topographic__elevation", at="node")
+ grid.add_zeros("surface_water__depth", at="node")
+ grid.add_zeros("surface_water__elevation", at="node")
+ grid.add_zeros("surface_water__velocity", at="link")
+
+ # We set fixed boundary conditions, specifying the nodes and links in which the water is flowing into the grid
+ fixed_entry_nodes = grid.nodes_at_left_edge
+ fixed_entry_links = grid.links_at_node[fixed_entry_nodes][:,0]
+
+ # We set the fixed values in the entry nodes/links
+ entry_nodes_h_values = 0.5*np.ones_like(fixed_entry_nodes)
+ entry_links_vel_values = 0.5*np.ones_like(fixed_entry_links)
+
+ # We specify the time step duration and we run it
+ dt = 0.1
+ rfd = river_flow_dynamics(grid, dt=dt, fixed_entry_nodes=fixed_entry_nodes, fixed_entry_links=fixed_entry_links,
+ entry_nodes_h_values=entry_nodes_h_values, entry_links_vel_values=entry_links_vel_values)
+ #rfd = river_flow_dynamics(grid)
+
+ for timestep in range(100):
+ rfd.run_one_step()
+
+ #waterDepth = np.reshape(grid['node']["surface_water__depth"],(10,10))
+ water_depth_solution = np.array([ 0.4357753 , 0.4357753 , 0.43611027, 0.43624251, 0.43626605,
+ 0.43595278, 0.43534349, 0.43491662, 0.43342158, 0.43342158])
+ water_depth_obtained = grid.at_node["surface_water__depth"][grid.nodes_at_right_edge]
+ np.testing.assert_array_almost_equal(water_depth_solution, water_depth_obtained, decimal=6)
+