Utopia::Models::Geomorphology::Geomorphology Class Reference

A very simple geomorphology model. More...

#include <Geomorphology.hh>

Inheritance diagram for Utopia::Models::Geomorphology::Geomorphology:

Collaboration diagram for Utopia::Models::Geomorphology::Geomorphology:

Public Types
using	Base = Model< Geomorphology, GeomorphologyTypes >
	The base model type.
using	DataSet = typename Base::DataSet
	Data type for a dataset.
using	GeomorphologyCellManager = CellManager< CellTraits, Geomorphology >
	The type of the cell manager.
using	GeomorphologyCellType = GeomorphologyCellManager::Cell
	A cell in the geomorphology model.
using	GeomorphologyCellIndexType = Utopia::IndexType
	The index type of the Geomorphology cell manager.
using	GmorphCellContainer = Utopia::CellContainer< GeomorphologyCellType >
	The type of a cell container in the Geomorphology model.
using	RuleFunc = typename GeomorphologyCellManager::RuleFunc
	Rule function type, extracted from CellManager.
Public Types inherited from Utopia::Model< Geomorphology, GeomorphologyTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.
using	DataManager = DataIO::Default::DefaultDataManager< Geomorphology >
	The data manager to use, specialized with the derived model.
using	DataGroup = typename ModelTypes::DataGroup
	Data type that is used for storing datasets.
using	DataSet = typename ModelTypes::DataSet
	Data type that is used for storing data.
using	RNG = typename ModelTypes::RNG
	Data type of the shared RNG.
using	Space = typename ModelTypes::Space
	Data type of the space this model resides in.
using	Time = typename ModelTypes::Time
	Data type for the model time.
using	Monitor = typename ModelTypes::Monitor
	Data type for the monitor.
using	MonitorManager = typename ModelTypes::MonitorManager
	Data type for the monitor manager.
using	Level = typename ModelTypes::Level
	Data type for the hierarchical level.

Public Member Functions
template<class ParentModel >
	Geomorphology (const std::string &name, ParentModel &parent_model, const DataIO::Config &custom_cfg={})
	Dataset of watercolumn.
void	build_network ()
	The set of seperately applied rules to build the drainage network.
void	perform_step ()
	Perform step.
void	monitor ()
	Provide monitoring data: tree density and number of clusters.
void	write_data ()
	Write the cell states (aka water content)
Public Member Functions inherited from Utopia::Model< Geomorphology, GeomorphologyTypes >
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< Geomorphology > &w_deciders=DataIO::Default::default_deciders< Geomorphology >, const DataIO::Default::DefaultTriggermap< Geomorphology > &w_triggers=DataIO::Default::default_triggers< Geomorphology >)
	Constructs a Model instance.
const std::shared_ptr< Space > &	get_space () const
	Return the space this model resides in.
Time	get_time () const
	Return the current time of this model.
Time	get_time_max () const
	Return the maximum time possible for this model.
Config	get_cfg () const
	Return the config node of this model.
std::string	get_name () const
	Return the name of this model instance.
std::string	get_full_name () const
	Return the full name of this model within the model hierarchy.
std::shared_ptr< DataGroup >	get_hdfgrp () const
	Return a pointer to the HDF group this model stores data in.
Time	get_write_start () const
	Return the parameter that controls when write_data is called first.
Time	get_write_every () const
	Return the parameter that controls how often write_data is called.
DataManager	get_datamanager () const
	return the datamanager
hsize_t	get_remaining_num_writes () const
	Return the number of remaining write_data calls this model will make.
std::shared_ptr< RNG >	get_rng () const
	Return a pointer to the shared RNG.
std::shared_ptr< spdlog::logger >	get_logger () const
	Return a pointer to the logger of this model.
Monitor	get_monitor () const
	Return the monitor of this model.
std::shared_ptr< MonitorManager >	get_monitor_manager () const
	Get the monitor manager of the root model.
Level	get_level () const
	Return the hierarchical level within the model hierarchy.
virtual void	prolog ()
	A function that is called before starting model iteration.
virtual void	epilog ()
	A function that is called after the last iteration of a model.
void	iterate ()
	Iterate one (time) step of this model.
void	run ()
	Run the model from the current time to the maximum time.
std::shared_ptr< DataSet >	create_dset (const std::string name, const std::shared_ptr< DataGroup > &hdfgrp, std::vector< hsize_t > add_write_shape, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a new dataset within the given group.
std::shared_ptr< DataSet >	create_dset (const std::string name, const std::vector< hsize_t > add_write_shape, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a new dataset within the model's base data group.
std::shared_ptr< DataSet >	create_cm_dset (const std::string name, const CellManager &cm, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a dataset storing data from a CellManager.
std::shared_ptr< DataSet >	create_am_dset (const std::string name, const AgentManager &am, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a dataset storing data from a AgentManager.

Private Member Functions
bool	check_eq (const double &a, const double &b)
	Compare two floats for equality.
template<typename Cell >
bool	check_eq_waterline (const Cell &a, const Cell &b)
	Compare the waterline of two cells.
void	_initialize_cells ()
	The initialization of the cells.
template<typename Cell >
Cell	_lowest_grid_neighbor (const Cell &cell)
	Return the lowest cell of the grid-Neighborhood, including cell itself.
GmorphCellContainer	update_lakesites (GmorphCellContainer &lake, GmorphCellContainer &shore)
	Update the CellContainer of lake and shore cells.

Private Attributes
GeomorphologyCellManager	_cm
	The cell manager for the forest fire model.
std::normal_distribution	_uplift
	The random uplift as normal distribution.
double	_stream_power_coef
	The stream power coefficient.
double	_toppling_frequency
	The frequency of possible toppling events per cell.
double	_toppling_critical_height
	The critical height difference to trigget a toppling event.
double	_toppling_slope_reduction_factor
	The factor by which to reduce the slope in a toppling event.
std::unordered_map< GeomorphologyCellIndexType, std::shared_ptr< GeomorphologyCellType > >	_lowest_neighbors
const double	_float_precision
std::uniform_real_distribution	_prob_dist
	precision when comparing floats
std::shared_ptr< DataSet >	_dset_height
std::shared_ptr< DataSet >	_dset_drainage_area
	Dataset of rock height.
std::shared_ptr< DataSet >	_dset_watercolumn
	Dataset of drainage area.
RuleFunc	uplift_rule
	The rule how to uplift.
RuleFunc	erode
	The rule how to erode with stream power.
RuleFunc	toppling
	The rule how to topple / landslide.
RuleFunc	reset_network
	The rule to reset the drainage network.
RuleFunc	connect_cells
	Build a rudimentary network.
RuleFunc	build_lake
	Fill a sink with water.
RuleFunc	pass_drainage_area
	Make a drainage process from this cell.

Additional Inherited Members
Protected Member Functions inherited from Utopia::Model< Geomorphology, GeomorphologyTypes >
void	__perform_step ()
	Perform the computation of a step.
void	__monitor ()
	Monitor information in the terminal.
void	__write_data ()
	Write data; calls the implementation's write_data method.
void	__write_initial_state ()
	Write the initial state.
void	increment_time (const Time dt=1)
	Increment time.
void	__prolog ()
	The default prolog of a model.
void	__epilog ()
	The default epilog of a model.
Geomorphology &	impl ()
	cast to the derived class
const Geomorphology &	impl () const
	const cast to the derived interface
Protected Attributes inherited from Utopia::Model< Geomorphology, GeomorphologyTypes >
const std::string	_name
	Name of the model instance.
const std::string	_full_name
	The full name within the model hierarchy.
const Level	_level
	The level within the model hierarchy.
const Config	_cfg
	Config node belonging to this model instance.
const std::shared_ptr< RNG >	_rng
	The RNG shared between models.
const std::shared_ptr< spdlog::logger >	_log
	The (model) logger.
std::shared_ptr< Space >	_space
	The space this model resides in.
Time	_time
	Model-internal current time stamp.
const Time	_time_max
	Model-internal maximum time stamp.
const std::shared_ptr< DataGroup >	_hdfgrp
	The HDF group this model instance should write its data to.
const Time	_write_start
	First time at which write_data is called.
const Time	_write_every
	How often to call write_data from iterate.
Monitor	_monitor
	The monitor.
DataManager	_datamanager
	Manager object for handling data output; see DataManager.
Static Protected Attributes inherited from Utopia::Model< Geomorphology, GeomorphologyTypes >
static constexpr WriteMode	_write_mode
	Which data-writing mode the base model should use.

Detailed Description

A very simple geomorphology model.

Member Typedef Documentation

Base

using Utopia::Models::Geomorphology::Geomorphology::Base = Model<Geomorphology, GeomorphologyTypes>

The base model type.

DataSet

using Utopia::Models::Geomorphology::Geomorphology::DataSet = typename Base::DataSet

Data type for a dataset.

GeomorphologyCellIndexType

using Utopia::Models::Geomorphology::Geomorphology::GeomorphologyCellIndexType = Utopia::IndexType

The index type of the Geomorphology cell manager.

GeomorphologyCellManager

using Utopia::Models::Geomorphology::Geomorphology::GeomorphologyCellManager = CellManager<CellTraits, Geomorphology>

The type of the cell manager.

GeomorphologyCellType

using Utopia::Models::Geomorphology::Geomorphology::GeomorphologyCellType = GeomorphologyCellManager::Cell

A cell in the geomorphology model.

GmorphCellContainer

using Utopia::Models::Geomorphology::Geomorphology::GmorphCellContainer = Utopia::CellContainer<GeomorphologyCellType>

The type of a cell container in the Geomorphology model.

RuleFunc

using Utopia::Models::Geomorphology::Geomorphology::RuleFunc = typename GeomorphologyCellManager::RuleFunc

Rule function type, extracted from CellManager.

Constructor & Destructor Documentation

Geomorphology()

template<class ParentModel >

Utopia::Models::Geomorphology::Geomorphology::Geomorphology ( const std::string &  name, ParentModel &  parent_model, const DataIO::Config &  custom_cfg = {}  )

inline

Dataset of watercolumn.

Construct the Geomorphology model

Parameters

name	Name of this model instance; is used to extract the configuration from the parent model and set up a HDFGroup for this instance
parent_model	The parent model this model instance resides in
custom_cfg	A custom configuration to use instead of the one extracted from the parent model using the instance name

                                         {}
    )
    :
        // Construct the base class
        Base(name, parent_model, custom_cfg),
 
        // Initialize the cell manager, binding it to this model
        _cm(*this),
 
        _uplift{get_as<double>("uplift_mean", this->_cfg),
                get_as<double>("uplift_var", this->_cfg)},
        _stream_power_coef(get_as<double>("stream_power_coef", this->_cfg)),
        _toppling_frequency(get_as<double>("toppling_frequency", this->_cfg)),
        _toppling_critical_height(get_as<double>("toppling_critical_height",
                                  this->_cfg)),
        _toppling_slope_reduction_factor(
            get_as<double>("toppling_slope_reduction_factor", this->_cfg, 3.)),
 
        _float_precision(1e-10),
        _prob_dist(0., 1.),
 
        // Create datasets using the helper functions for CellManager-data
        _dset_height(this->create_cm_dset("height", _cm)),
        _dset_drainage_area(this->create_cm_dset("drainage_area", _cm)),
        _dset_watercolumn(this->create_cm_dset("watercolumn", _cm))
    {
        if (get_as<double>("uplift_var", this->_cfg) <= 1e-10) {
            throw std::invalid_argument("Invalid argument: uplift_var must be "
                "> _float_precision (1e-10)!");
        }
        // Update initial cell states
        _initialize_cells();
 
 
        this->_log->debug("{} model fully set up.", this->_name);
    }

Member Function Documentation

_initialize_cells()

void Utopia::Models::Geomorphology::Geomorphology::_initialize_cells ( )

inlineprivate

The initialization of the cells.

Adds the inclination to the cells initial rock height.

Defines the outflow boundary.

Initializes the drainage network and lakes

                             {
        this->_log->debug("Initializing cells ..");
 
        // Initialize altitude as an inclined plane
        // (by making use of coordinates)
        RuleFunc set_inclined_plane = [this](const auto& cell) {
            auto state = cell->state;
            auto pos = _cm.barycenter_of(cell);
            double slope = get_as<double>("initial_slope",
                                this->_cfg["cell_manager"]["cell_params"]);
            state.rock += slope*pos[1];
            if (state.rock < _float_precision) {
                std::uniform_real_distribution<> dist(0.,1e-5);
                state.rock = dist(*this->_rng);
                this->_log->warn("Received negative initial height. Was set "
                    "in [0.,1e-5]. Better chose the initial_height "
                    "distribution such that no negative values occur.");
            }
            return state;
        };
        apply_rule<Update::sync>(set_inclined_plane, _cm.cells());
 
        // set bottom cells as outflow
        apply_rule<Update::sync>(
            // The rule to apply
            [](const auto& cell){
                auto state = cell->state;
                state.is_outflow = true;
                return state;
            },
            // The containers over which to iterate
            _cm.boundary_cells("bottom")
        );
 
        // Build drainage network
        this->_log->debug(" Initializing drainage network ...");
        build_network();
 
        this->_log->debug("Cells fully set up.");
    }

_lowest_grid_neighbor()

template<typename Cell >

Cell Utopia::Models::Geomorphology::Geomorphology::_lowest_grid_neighbor ( const Cell &  cell )

inlineprivate

Return the lowest cell of the grid-Neighborhood, including cell itself.

                                                 {
        GmorphCellContainer lowest_neighbors = {cell};
        auto lowest_neighbor = cell;
        for (const auto& n : this->_cm.neighbors_of(cell)) {
            double height_diff = n->state.waterline() -
                                 lowest_neighbor->state.waterline();
 
            if (check_eq_waterline(n, lowest_neighbor)) {
                lowest_neighbors.push_back(n);
            }
 
            // If neighbor is lower, update lowest_neighbor and list
            else if (height_diff < 0) {
                lowest_neighbor = n;
                lowest_neighbors.clear();
                lowest_neighbors.push_back(lowest_neighbor);
            }
        }
 
        // If there is more than one lowest neighbor, select one randomly.
        if (lowest_neighbors.size() > 1) {
            std::uniform_int_distribution<> dist(0, lowest_neighbors.size() -1);
            lowest_neighbor = lowest_neighbors[dist(*(this->_rng))];
        }
        return lowest_neighbor;
    }

build_network()

void Utopia::Models::Geomorphology::Geomorphology::build_network ( )

inline

The set of seperately applied rules to build the drainage network.

1. Reset network
2. Connect cells to basic netork
3. Fill sinks with water, completing the network
4. Calculate the drainage area on every cell

                          {
        // reset network
        apply_rule<Update::sync>(reset_network, _cm.cells());
 
        // connect cells to drainage network
        apply_rule<Update::async, Shuffle::off>(connect_cells, _cm.cells());
 
        // fill sinks with water
        apply_rule<Update::async, Shuffle::off>(build_lake, _cm.cells());
 
        // get drainage area
        apply_rule<Update::async, Shuffle::off>(pass_drainage_area,
                                                _cm.cells());
    }

check_eq()

bool Utopia::Models::Geomorphology::Geomorphology::check_eq ( const double &  a, const double &  b  )

inlineprivate

Compare two floats for equality.

                                                    {
        return (a-b < _float_precision) && (b-a < _float_precision);
    }

check_eq_waterline()

template<typename Cell >

bool Utopia::Models::Geomorphology::Geomorphology::check_eq_waterline ( const Cell &  a, const Cell &  b  )

inlineprivate

Compare the waterline of two cells.

                                                          {
        return check_eq(a->state.waterline(), b->state.waterline());
    }

monitor()

void Utopia::Models::Geomorphology::Geomorphology::monitor ( )

inline

Provide monitoring data: tree density and number of clusters.

{ return; }

perform_step()

void Utopia::Models::Geomorphology::Geomorphology::perform_step ( )

inline

Perform step.

                         {
        // Erode
        apply_rule<Update::sync>(erode, _cm.cells());
 
        // Uplift
        apply_rule<Update::sync>(uplift_rule, _cm.cells());
 
        // Topple
        apply_rule<Update::async, Shuffle::on>(toppling, _cm.cells(),
                                               *this->_rng);
 
        // Build drainage network
        build_network();
    }

update_lakesites()

GmorphCellContainer Utopia::Models::Geomorphology::Geomorphology::update_lakesites ( GmorphCellContainer &  lake, GmorphCellContainer &  shore  )

inlineprivate

Update the CellContainer of lake and shore cells.

updates the shore Container to match the new lake

Parameters

lake	Reference to a Container of lake cells. Lake: cells of equal waterline.
shore	Reference to the Cells neighboring the lake

Returns

CellContainer of all cells connected and of same waterline as the given lake Container.

    {
        auto it = std::begin(shore);
        while(it != std::end(shore)) {
            if (check_eq_waterline(*it, lake[0])) {
                lake.push_back(*it);
                auto nb = _cm.neighbors_of(*it);
                for (auto it_lake : lake) {
                    nb.erase(std::remove(nb.begin(), nb.end(), it_lake),
                             nb.end());
                }
                for (auto it_shore : shore) {
                    nb.erase(std::remove(nb.begin(), nb.end(), it_shore),
                             nb.end());
                }
 
                auto next_it = it;
                auto next = *next_it;
                if (next_it != shore.end())
                    next_it++;
                if (next_it != shore.end())
                    next = *next_it;
                it = shore.erase(it);
                if (!nb.empty()) {
                    if (it == shore.end())
                        next = nb[0];
                    shore.insert(shore.end(), nb.begin(), nb.end());
                    it = std::find(shore.begin(), shore.end(), next);
                }
            }
            else
                ++it;
        }
 
        return lake;
    };

write_data()

void Utopia::Models::Geomorphology::Geomorphology::write_data ( )

inline

Write the cell states (aka water content)

The cell height is currently not written out as in the current implementation it does not change over time (erosion is not yet included).

                       {
        _dset_height->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) { return cell->state.rock; }
        );
 
        _dset_drainage_area->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) { return cell->state.drainage_area; }
        );
 
        _dset_watercolumn->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) { return cell->state.watercolumn; }
        );
    }

Member Data Documentation

_cm

GeomorphologyCellManager Utopia::Models::Geomorphology::Geomorphology::_cm

private

The cell manager for the forest fire model.

_dset_drainage_area

std::shared_ptr<DataSet> Utopia::Models::Geomorphology::Geomorphology::_dset_drainage_area

private

Dataset of rock height.

_dset_height

std::shared_ptr<DataSet> Utopia::Models::Geomorphology::Geomorphology::_dset_height

private

_dset_watercolumn

std::shared_ptr<DataSet> Utopia::Models::Geomorphology::Geomorphology::_dset_watercolumn

private

Dataset of drainage area.

_float_precision

const double Utopia::Models::Geomorphology::Geomorphology::_float_precision

private

_lowest_neighbors

std::unordered_map<GeomorphologyCellIndexType, std::shared_ptr<GeomorphologyCellType> > Utopia::Models::Geomorphology::Geomorphology::_lowest_neighbors

private

_prob_dist

std::uniform_real_distribution Utopia::Models::Geomorphology::Geomorphology::_prob_dist

private

precision when comparing floats

A re-usable uniform real distribution to evaluate probabilities

_stream_power_coef

double Utopia::Models::Geomorphology::Geomorphology::_stream_power_coef

private

The stream power coefficient.

_toppling_critical_height

double Utopia::Models::Geomorphology::Geomorphology::_toppling_critical_height

private

The critical height difference to trigget a toppling event.

The probability of a toppling event is given as \( p = \Delta h / h_{crit} \), where \( \Delta h \) is the difference in height between a target cell and its highest neighbor.

_toppling_frequency

double Utopia::Models::Geomorphology::Geomorphology::_toppling_frequency

private

The frequency of possible toppling events per cell.

_toppling_slope_reduction_factor

double Utopia::Models::Geomorphology::Geomorphology::_toppling_slope_reduction_factor

private

The factor by which to reduce the slope in a toppling event.

The difference in height between the source and target cell of the toppling event is divided by this factor. This amount of rock is removed from the source and added to the target site.

default value: 3.

_uplift

std::normal_distribution Utopia::Models::Geomorphology::Geomorphology::_uplift

private

The random uplift as normal distribution.

build_lake

RuleFunc Utopia::Models::Geomorphology::Geomorphology::build_lake

private

Fill a sink with water.

such that there is a shore cell to the resulting lake that is either outflow or lower than the lakes waterline.

Updates the _lowest_neighbors map for all lake cells to point to the outflow alias a Cell within lake neighboring the lower shore cell.

Note

Must be updated in an asynchronous way. No shuffle needed.

                                             {
        // return if cell has lower neighbor
        if (cell->state.is_outflow or _lowest_neighbors[cell->id()] != cell) {
            return cell->state;
        }
 
        GmorphCellContainer lake = {cell};
        GmorphCellContainer shore = this->_cm.neighbors_of(cell);
        lake = update_lakesites(lake, shore);
 
        double waterline = lake[0]->state.waterline();
        bool no_sink = true;
 
        // check for sink in new lake sites
        for (const auto& lc : lake) {
            if (lc->state.is_outflow) {
                no_sink=false;
                break;
            }
        }
 
        // lowest shore cell is candidate for outflow
        auto lowest_shore_cell = shore[0];
        for (const auto& sc : shore) {
            if (sc->state.waterline() < lowest_shore_cell->state.waterline())
            {
                lowest_shore_cell = sc;
            }
        }
 
        // raise waterline while no outflow to lake
        while (lowest_shore_cell->state.waterline() > waterline and no_sink)
        {
            // raise watercolumn to new waterline
            waterline = lowest_shore_cell->state.waterline();
            for (auto& lc : lake) {
                lc->state.watercolumn = waterline - lc->state.rock;
            }
 
            // update lake and shore
            lake = update_lakesites(lake, shore);
 
            for (const auto& lc : lake) {
                if (lc->state.is_outflow) {
                    no_sink=false;
                    break;
                }
            }
 
            // update lowest shore cell
            lowest_shore_cell = shore[0];
            for (const auto& sc : shore) {
                if (sc->state.waterline() <
                    lowest_shore_cell->state.waterline())
                {
                    lowest_shore_cell = sc;
                }
            }
        }
 
        auto outflow_cell = lowest_shore_cell;
        if (not no_sink) {
            for (const auto& lc : lake) {
                if (lc->state.is_outflow) {
                    outflow_cell = lc;
                    break;
                }
            }
        }
        else {
            auto nbs = this->_cm.neighbors_of(lowest_shore_cell);
            auto it_nb = nbs.begin();
            while(it_nb != nbs.end()) {
                if (not check_eq((*it_nb)->state.waterline(), waterline)) {
                    it_nb = nbs.erase(it_nb);
                }
                else if (lake.end() == std::find(lake.begin(), lake.end(),
                                                 *it_nb))
                {
                    it_nb = nbs.erase(it_nb);
                }
                else { ++it_nb; }
            }
 
            if (nbs.size() > 1) {
                std::uniform_int_distribution<> dist(0, nbs.size() - 1);
                outflow_cell = nbs[dist(*(this->_rng))];
            }
            else { outflow_cell = nbs[0]; }
        }
 
        for (const auto& lc : lake) {
            if (lc->state.is_outflow) {
                _lowest_neighbors[lc->id()] = lc;
            }
            else {
                _lowest_neighbors[lc->id()] = outflow_cell;
            }
        }
        if (not outflow_cell->state.is_outflow) {
            _lowest_neighbors[outflow_cell->id()] = lowest_shore_cell;
        }
 
        return cell->state;
    };

connect_cells

RuleFunc Utopia::Models::Geomorphology::Geomorphology::connect_cells

private

Initial value:

= [this](const auto& cell) {
        if (cell->state.is_outflow) {
            _lowest_neighbors[cell->id()] = cell; 
            return cell->state;
        }
 
        
        _lowest_neighbors[cell->id()] = this->_lowest_grid_neighbor(cell);
 
        return cell->state;
    }

Build a rudimentary network.

Create map: cells to their lowest_neighbor (random choice if multiple). Sinks (no lower neighbor or outflow) map to themselfes.

                                                      {
        if (cell->state.is_outflow) {
            _lowest_neighbors[cell->id()] = cell; // map to itself
            return cell->state;
        }
 
        // Set lowest neighbor for cell, is itself is sink
        _lowest_neighbors[cell->id()] = this->_lowest_grid_neighbor(cell);
 
        return cell->state;
    };

erode

RuleFunc Utopia::Models::Geomorphology::Geomorphology::erode

private

Initial value:

= [this](const auto& cell) {
        auto state = cell->state;
 
        double slope = state.waterline();
        if (not state.is_outflow) {
            
            slope -= _lowest_neighbors[cell->id()]->state.waterline();
        }
        
 
        double stream_power = (  _stream_power_coef * slope
                               * std::sqrt(state.drainage_area));
        state.rock -= std::min(stream_power, state.rock);
 
        return state;
    }

The rule how to erode with stream power.

                                              {
        auto state = cell->state;
 
        double slope = state.waterline();
        if (not state.is_outflow) {
            // slope = state->waterline - lowest_neighbor->waterline
            slope -= _lowest_neighbors[cell->id()]->state.waterline();
        }
        // else: slope = state->waterline - 0.
 
        double stream_power = (  _stream_power_coef * slope
                               * std::sqrt(state.drainage_area));
        state.rock -= std::min(stream_power, state.rock);
 
        return state;
    };

pass_drainage_area

RuleFunc Utopia::Models::Geomorphology::Geomorphology::pass_drainage_area

private

Initial value:

= [this](auto& cell) {
        auto state = cell->state;
        state.was_drained = true;
 
        if (not state.is_outflow and _lowest_neighbors[cell->id()] == cell) {
            throw std::runtime_error("No recipient assigned to a cell!");
        }
        
        if (state.is_outflow) {
            return state;
        }
 
        
        auto downstream_cell = _lowest_neighbors[cell->id()];
        downstream_cell->state.drainage_area += state.drainage_area;
 
        
        while(not downstream_cell->state.is_outflow and
              downstream_cell->state.was_drained)
        {
            downstream_cell = _lowest_neighbors[downstream_cell->id()];
            downstream_cell->state.drainage_area += state.drainage_area;
            if (downstream_cell->state.drainage_area > size(this->_cm.cells()))
            {
                throw std::runtime_error("Drainage network has loop!");
            }
        }
 
        return state;
    }

Make a drainage process from this cell.

Pass the cells drainage area through the already drained downstream cells up to an outflow or not already drained cell.

Note

Must be updated in an asynchronous way. No shuffle needed.

                                                     {
        auto state = cell->state;
        state.was_drained = true;
 
        if (not state.is_outflow and _lowest_neighbors[cell->id()] == cell) {
            throw std::runtime_error("No recipient assigned to a cell!");
        }
        // nothing to do here
        if (state.is_outflow) {
            return state;
        }
 
        // get downstream neighbor
        auto downstream_cell = _lowest_neighbors[cell->id()];
        downstream_cell->state.drainage_area += state.drainage_area;
 
        // pass drainage to all already drained cells
        while(not downstream_cell->state.is_outflow and
              downstream_cell->state.was_drained)
        {
            downstream_cell = _lowest_neighbors[downstream_cell->id()];
            downstream_cell->state.drainage_area += state.drainage_area;
            if (downstream_cell->state.drainage_area > size(this->_cm.cells()))
            {
                throw std::runtime_error("Drainage network has loop!");
            }
        }
 
        return state;
    };

reset_network

RuleFunc Utopia::Models::Geomorphology::Geomorphology::reset_network

private

Initial value:

= [](const auto& cell) {
        auto state = cell->state;
        state.drainage_area = 1.;
        state.was_drained = false;
        state.watercolumn = 0.;
        return state;
    }

The rule to reset the drainage network.

                                                  {
        auto state = cell->state;
        state.drainage_area = 1.;
        state.was_drained = false;
        state.watercolumn = 0.;
        return state;
    };

toppling

RuleFunc Utopia::Models::Geomorphology::Geomorphology::toppling

private

Initial value:

= [this](const auto& cell) {
        auto state = cell->state;
        if (_toppling_frequency == 0. or
            _toppling_frequency < this->_prob_dist(*(this->_rng))
           ) {
            
            return state;
        }
 
        auto nbrs = this->_cm.neighbors_of(cell);
        auto heighest_neighbor = cell;
        for (auto& nb : nbrs) {
            if (nb->state.waterline() > heighest_neighbor->state.waterline())
            {
                heighest_neighbor = nb;
            }
        }
        double relief = (  heighest_neighbor->state.waterline()
                         - state.waterline());
        double failure_prob = relief / _toppling_critical_height;
        if (this->_prob_dist(*(this->_rng)) < failure_prob) {
            double factor = _toppling_slope_reduction_factor;
            heighest_neighbor->state.rock -= relief / factor;
            state.rock += relief / factor;
        }
 
        return state;
    }

The rule how to topple / landslide.

Note

Only evaluated with _toppling_frequency per cell

Failure of slope occurs with p = (h_i - h_j) / h_c

On failure slope is reduced to 1/3. of its initial value.

                                                 {
        auto state = cell->state;
        if (_toppling_frequency == 0. or
            _toppling_frequency < this->_prob_dist(*(this->_rng))
           ) {
            // Done here.
            return state;
        }
 
        auto nbrs = this->_cm.neighbors_of(cell);
        auto heighest_neighbor = cell;
        for (auto& nb : nbrs) {
            if (nb->state.waterline() > heighest_neighbor->state.waterline())
            {
                heighest_neighbor = nb;
            }
        }
        double relief = (  heighest_neighbor->state.waterline()
                         - state.waterline());
        double failure_prob = relief / _toppling_critical_height;
        if (this->_prob_dist(*(this->_rng)) < failure_prob) {
            double factor = _toppling_slope_reduction_factor;
            heighest_neighbor->state.rock -= relief / factor;
            state.rock += relief / factor;
        }
 
        return state;
    };

uplift_rule

RuleFunc Utopia::Models::Geomorphology::Geomorphology::uplift_rule

private

Initial value:

= [this](const auto& cell) {
        auto state = cell->state;
        state.rock += this->_uplift(*(this->_rng));
        return state;
    }

The rule how to uplift.

                                                    {
        auto state = cell->state;
        state.rock += this->_uplift(*(this->_rng));
        return state;
    };

---

The documentation for this class was generated from the following file:

• src/utopia/models/Geomorphology/Geomorphology.hh