The CopyMeGraph Model; a good start for a graph-based model. More...

#include <CopyMeGraph.hh>

Inheritance diagram for Utopia::Models::CopyMeGraph::CopyMeGraph:

Collaboration diagram for Utopia::Models::CopyMeGraph::CopyMeGraph:

[legend]

Public Types
using	Base = Model< CopyMeGraph, ModelTypes >
	The type of the Model base class of this derived class.

using	DataGroup = typename Base::DataGroup
	Data type of the group to write model data to, holding datasets.

using	DataSet = typename Base::DataSet
	Data type for a dataset.

using	VertexDesc = typename boost::graph_traits< GraphType >::vertex_descriptor
	Data type for a vertex descriptor.

using	EdgeDesc = typename boost::graph_traits< GraphType >::edge_descriptor
	Data type for an edge descriptor.

using	VertexVoidRule = typename std::function< void(VertexDesc, GraphType &)>
	Data type for a rule function operating on vertices returning void.

using	VertexStateRule = typename std::function< VertexState(VertexDesc, GraphType &)>
	Data type for a rule function operating on vertices returning a state.

using	EdgeVoidRule = typename std::function< void(EdgeDesc, GraphType &)>
	Data type for a rule function operating on edges returning void.

using	EdgeStateRule = typename std::function< EdgeState(EdgeDesc, GraphType &)>
	Data type for a rule function operating on edges returning a state.

Public Types inherited from Utopia::Model< CopyMeGraph, ModelTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.

using	DataManager = DataIO::Default::DefaultDataManager< CopyMeGraph >
	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 >
	CopyMeGraph (const std::string &name, ParentModel &parent_model, const DataIO::Config &custom_cfg={})
	Construct the CopyMeGraph model.

void	perform_step ()
	Iterate a single step.

void	monitor ()
	Monitor model information.

void	write_data ()
	Write data.

Public Member Functions inherited from Utopia::Model< CopyMeGraph, ModelTypes >
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< CopyMeGraph > &w_deciders=DataIO::Default::default_deciders< CopyMeGraph >, const DataIO::Default::DefaultTriggermap< CopyMeGraph > &w_triggers=DataIO::Default::default_triggers< CopyMeGraph >)
	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
GraphType	initialize_graph ()
	Initialize the graph.

void	initialize_vertices (GraphType &g)

void	initialize_edges (GraphType &g)

double	calc_some_state_mean () const
	Calculate the mean of all vertices' some_state.

Private Attributes
std::uniform_real_distribution< double >	_prob_distr
	A re-usable uniform real distribution to evaluate probabilities.

GraphType	_g
	The graph.

double	_some_parameter
	Some parameter.

std::shared_ptr< DataGroup >	_dgrp_g_static
	A datagroup for a static graph.

std::shared_ptr< DataGroup >	_dgrp_g_dynamic
	A datagroup for a dynamic graph.

std::shared_ptr< DataSet >	_dset_some_state
	A dataset for storing all vertices' some_state.

std::shared_ptr< DataSet >	_dset_some_trait
	A dataset for storing all vertices' some_trait.

VertexVoidRule	some_interaction
	An interaction function of a single vertex with its neighbors.

VertexStateRule	some_other_rule
	Some other rule function.

Additional Inherited Members
Protected Member Functions inherited from Utopia::Model< CopyMeGraph, ModelTypes >
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.

CopyMeGraph &	impl ()
	cast to the derived class

const CopyMeGraph &	impl () const
	const cast to the derived interface

Protected Attributes inherited from Utopia::Model< CopyMeGraph, ModelTypes >
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< CopyMeGraph, ModelTypes >
static constexpr WriteMode	_write_mode
	Which data-writing mode the base model should use.

Detailed Description

The CopyMeGraph Model; a good start for a graph-based model.

TODO Add your model description here. This model's sole purpose of existing is to be a template for new models. That means its functionality is only meant to show how actually useful functionality could be implemented.

Member Typedef Documentation

◆ Base

using Utopia::Models::CopyMeGraph::CopyMeGraph::Base = Model<CopyMeGraph, ModelTypes>

The type of the Model base class of this derived class.

◆ DataGroup

using Utopia::Models::CopyMeGraph::CopyMeGraph::DataGroup = typename Base::DataGroup

Data type of the group to write model data to, holding datasets.

◆ DataSet

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

Data type for a dataset.

◆ EdgeDesc

using Utopia::Models::CopyMeGraph::CopyMeGraph::EdgeDesc = typename boost::graph_traits<GraphType>::edge_descriptor

Data type for an edge descriptor.

◆ EdgeStateRule

using Utopia::Models::CopyMeGraph::CopyMeGraph::EdgeStateRule = typename std::function<EdgeState(EdgeDesc, GraphType&)>

Data type for a rule function operating on edges returning a state.

◆ EdgeVoidRule

using Utopia::Models::CopyMeGraph::CopyMeGraph::EdgeVoidRule = typename std::function<void(EdgeDesc, GraphType&)>

Data type for a rule function operating on edges returning void.

◆ VertexDesc

using Utopia::Models::CopyMeGraph::CopyMeGraph::VertexDesc = typename boost::graph_traits<GraphType>::vertex_descriptor

Data type for a vertex descriptor.

◆ VertexStateRule

using Utopia::Models::CopyMeGraph::CopyMeGraph::VertexStateRule = typename std::function<VertexState(VertexDesc, GraphType&)>

Data type for a rule function operating on vertices returning a state.

◆ VertexVoidRule

using Utopia::Models::CopyMeGraph::CopyMeGraph::VertexVoidRule = typename std::function<void(VertexDesc, GraphType&)>

Data type for a rule function operating on vertices returning void.

Constructor & Destructor Documentation

◆ CopyMeGraph()

template<class ParentModel >

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

inline

Construct the CopyMeGraph 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

                                         {}
    )
    :
        // Initialize first via base model
        Base(name, parent_model, custom_cfg),
 
        // Initialize the uniform real distribution to range [0., 1.]
        _prob_distr(0., 1.),
 
        // Now initialize the graph
        _g {initialize_graph()},
 
        // Initialize model parameters
        _some_parameter(get_as<double>("some_parameter", this->_cfg)),
        // ...
 
        // Datagroups
        // For saving graph-related data, it is recommended to use a so-called
        // graph group. This is a normal datagroup (opened with the open_group
        // method) but with additional attributes such as information about the
        // graph itself. This allows for later loading the data from the graph
        // group directly into a NetworkX graph object in Python.
        _dgrp_g_static(create_graph_group(_g, this->_hdfgrp, "g_static")),
        _dgrp_g_dynamic(create_graph_group(_g, this->_hdfgrp, "g_dynamic")),
 
        // Datasets
        // For setting up datasets that store Graph data, you can use the
        // Model::create_dset helper method which already takes care of using
        // the correct length into the time dimension (depending on the
        // num_steps and write_every parameters). Additionally, the parent
        // datagroup can be specified. The syntax is:
        //
        // this->create_dset("a_number", dgrp, {})      // 1D {#writes}
        // this->create_dset("a_vec", dgrp, {num_cols}) // 2D {#writes, #cols}
        //
        // This is also done here for storing two vertex properties in the
        // static graph group.
        _dset_some_state(this->create_dset("some_state",
                                           _dgrp_g_static,
                                           {boost::num_vertices(_g)})),
        _dset_some_trait(this->create_dset("some_trait",
                                           _dgrp_g_static,
                                           {boost::num_vertices(_g)}))
    {
        // Can do remaining initialization steps here ...
 
        // Set the second dimension name to 'vertex_idx'. The first dimension's
        // name is 'time'. Also, specify the coordinates for the vertex_idx
        // dimension, which are just the trivial coordinates 0, ..., N-1,
        // where N is the number of vertices.
        // NOTE The IDs of the vertices do not necessarily line up with the
        //      indices of the vertices when iterating over the graph. That's
        //      why the dimension is called vertex_idx, not vertex_id.
        _dset_some_state->add_attribute("dim_name__1", "vertex_idx");
        _dset_some_state->add_attribute("coords_mode__vertex_idx", "trivial");
 
        _dset_some_trait->add_attribute("dim_name__1", "vertex_idx");
        _dset_some_state->add_attribute("coords_mode__vertex_idx", "trivial");
 
        // NOTE The initial state need and should NOT be written here. The
        //      write_data method is invoked first at time `write_start`.
        //      However, this is a good place to store data that is constant
        //      during the run and needs to be written at some point.
 
        // In the case of a static graph, the topology can be saved once using
        // the DataIO::save_graph function. It saves the graph structure to the
        // specified datagroup by writing the vertex id's in a dataset named
        // `_vertices` and the edges in a dataset named `_edges`.
        save_graph(_g, _dgrp_g_static);
 
        // Initialization should be finished here.
        this->_log->debug("{} model fully set up.", this->_name);
    }

Member Function Documentation

◆ calc_some_state_mean()

double Utopia::Models::CopyMeGraph::CopyMeGraph::calc_some_state_mean ( ) const

inlineprivate

Calculate the mean of all vertices' some_state.

    {
        auto sum = 0.;
        for (const auto v : range<IterateOver::vertices>(_g)) {
            sum += _g[v].state.some_state;
        }
        return sum / boost::num_vertices(_g);
    }

◆ initialize_edges()

void Utopia::Models::CopyMeGraph::CopyMeGraph::initialize_edges ( GraphType & g )

inlineprivate

    {
        // Define a rule that acts on an edge
        auto initialize_edge = [this](const auto e, auto& g) {
            // Get the initial weight from the configuration
            g[e].state.weight = get_as<double>("init_weight", this->_cfg);
 
            // If set in the configuration randomize the weight by
            // multiplying a random number between drawn uniformaly from [0,1].
            if (get_as<bool>("init_random_weight", this->_cfg)) {
                // Here you see, how to generate a random number using the
                // random number generated from the parent model.
                // Remember that the member variable is a shared pointer,
                // so you need to dereference it by writing '*' in front of it.
                g[e].state.weight *= _prob_distr(*this->_rng);
            }
        };
 
        // Apply the single edge initialization rule to all edges
        // NOTE that you should distinguish between in_edges and out_edges
        //      if your graph is directed.
        apply_rule<IterateOver::edges, Update::async, Shuffle::off>(
            initialize_edge,
            g);
    }

◆ initialize_graph()

GraphType Utopia::Models::CopyMeGraph::CopyMeGraph::initialize_graph ( )

inlineprivate

Initialize the graph.

    {
        this->_log->debug("Create and initialize the graph ...");
 
        auto g = Graph::create_graph<GraphType>(this->_cfg["create_graph"],
                                                *this->_rng);
 
        this->initialize_vertices(g);
        this->initialize_edges(g);
 
        return g;
    }

◆ initialize_vertices()

void Utopia::Models::CopyMeGraph::CopyMeGraph::initialize_vertices ( GraphType & g )

inlineprivate

    {
        // Define a rule that acts on a vertex
        auto initialize_vertex = [this](const auto v, auto& g) {
            g[v].state.some_state =
                get_as<double>("init_some_state", this->_cfg);
            g[v].state.some_trait = get_as<int>("init_some_trait", this->_cfg);
 
            // Every 13th vertex (on average) is a VIP vertex
            if (this->_prob_distr(*this->_rng) < (1. / 13.)) {
                g[v].state.is_a_vip_vertex = true;
            }
            else {
                g[v].state.is_a_vip_vertex = false;
            }
        };
 
        // Apply the rule to all vertices
        apply_rule<IterateOver::vertices, Update::async, Shuffle::off>(
            initialize_vertex,
            g);
    }

◆ monitor()

void Utopia::Models::CopyMeGraph::CopyMeGraph::monitor ( )

inline

Monitor model information.

Here, functions and values can be supplied to the monitor that are then available to the frontend. The monitor() function is only called if a certain emit interval has passed; thus, the performance hit is small. With this information, you can then define stop conditions on frontend side, that can stop a simulation once a certain set of conditions is fulfilled.

    {
        this->_monitor.set_entry("some_value", 42);
        this->_monitor.set_entry("state_mean", calc_some_state_mean());
    }

◆ perform_step()

void Utopia::Models::CopyMeGraph::CopyMeGraph::perform_step ( )

inline

Iterate a single step.

Here you can add a detailed description what exactly happens in a single iteration step

    {
        // Apply the rule 'some_interaction' to all vertices sequentially
        apply_rule<IterateOver::vertices, Update::async, Shuffle::on>(
            some_interaction,
            _g,
            *this->_rng);
 
        // Apply 'some_other_rule' synchronously to all vertices
        apply_rule<IterateOver::vertices, Update::sync>(some_other_rule, _g);
    }

◆ write_data()

void Utopia::Models::CopyMeGraph::CopyMeGraph::write_data ( )

inline

Write data.

This function is called to write out data. The model configuration determines at which times data is written. See Utopia::DataIO::Dataset::write

    {
        // .. Writing to the static graph group ...............................
        // To save data to the already created datasets, the write method can
        // be called directly using a lambda function to extract the data from
        // the graph.
        //
        // Get the iterator pair of the vertices
        auto [v, v_end] = boost::vertices(_g);
 
        // Write out the some_state of all vertices
        _dset_some_state->write(v, v_end, [this](const auto v) {
            return this->_g[v].state.some_state;
        });
 
        // Write out the some_trait of all vertices
        _dset_some_trait->write(v, v_end, [this](const auto v) {
            return this->_g[v].state.some_trait;
        });
 
        // .. Writing to the dynamic graph group ..............................
        // To save data for dynamic graphs, it is recommended to use the
        // save_<vertex/edge>_properties functions. Since it writes all data in
        // a single iteration over the graph entities, it ensures that all data
        // written within one time step is aligned.
        //
        // First, two 'adaptor tuples' are defined - one that accesses the data
        // via a vertex-descriptor and one that does it via an edge-descriptor.
        // NOTE In order to ensure correct ordering of the data, there must not
        //      be a second adaptor tuple using the same type.
        // The adaptor tuple for the vertex data contains 1D adaptors which are
        // tuples of the form: (adaptor_name, adaptor_lambda)
        const auto get_vertex_data = std::make_tuple(
            std::make_tuple(
                "_vertices",
                [](auto vd, auto& g) {
                    return boost::get(boost::vertex_index_t(), g, vd);
                }),
            std::make_tuple("some_state",
                            [](auto vd, auto& g) {
                                return g[vd].state.some_state;
                            }),
            std::make_tuple("some_trait", [](auto vd, auto& g) {
                return g[vd].state.some_trait;
            }));
 
        // N-dimensional data can also be written. Here, 2D adaptors are used
        // for the edges and a 1D adaptor for the weights. For more details,
        // checkout the documentation of the save_<vertex/edge>_properties
        // functions.
        const auto get_edge_data = std::make_tuple(
            std::make_tuple(
                "_edges",
                "label",
                std::make_tuple("source",
                                [](auto ed, auto& g) {
                                    return boost::get(boost::vertex_index_t(),
                                                      g,
                                                      boost::source(ed, g));
                                }),
                std::make_tuple("target",
                                [](auto ed, auto& g) {
                                    return boost::get(boost::vertex_index_t(),
                                                      g,
                                                      boost::target(ed, g));
                                })),
            std::make_tuple("weights", [](auto ed, auto& g) {
                return g[ed].state.weight;
            }));
        // NOTE When using an adaptor tuple for saving dynamic edges (vertices),
        //      all edge (vertex) properties should also be saved via the
        //      adaptor tuple to ensure correct ordering.
 
        // Then, the save_<vertex/edge>_properties functions can be called.
        // NOTE Using the current time as the name of the dataset(s) indexes the
        //      data and allows to later load the data directly into a NetworkX
        //      graph.
        save_vertex_properties(_g,
                               _dgrp_g_dynamic,
                               std::to_string(get_time()),
                               get_vertex_data);
        save_edge_properties(_g,
                             _dgrp_g_dynamic,
                             std::to_string(get_time()),
                             get_edge_data);
 
        // When writing in every time step, this will result in the following
        // data structure:
        // ...
        // └┬ graph_group
        //      └┬ _vertices
        //           └┬ 0            < ... shape(num_vertices,)
        //            ├ 1            < ... shape(num_vertices,)
        //            ├ ...
        //       ├ _edges
        //           └┬ 0            < ... shape(num_edges, 2)
        //            ├ 1            < ... shape(num_edges, 2)
        //            ├ ...
        //       ├ ...
        //
        // By default, the coordinates 'vertex_idx' and 'edge_idx' are added.
    }

Member Data Documentation

◆ _dgrp_g_dynamic

std::shared_ptr<DataGroup> Utopia::Models::CopyMeGraph::CopyMeGraph::_dgrp_g_dynamic

private

A datagroup for a dynamic graph.

◆ _dgrp_g_static

std::shared_ptr<DataGroup> Utopia::Models::CopyMeGraph::CopyMeGraph::_dgrp_g_static

private

A datagroup for a static graph.

◆ _dset_some_state

std::shared_ptr<DataSet> Utopia::Models::CopyMeGraph::CopyMeGraph::_dset_some_state

private

A dataset for storing all vertices' some_state.

◆ _dset_some_trait

std::shared_ptr<DataSet> Utopia::Models::CopyMeGraph::CopyMeGraph::_dset_some_trait

private

A dataset for storing all vertices' some_trait.

◆ _g

GraphType Utopia::Models::CopyMeGraph::CopyMeGraph::_g

private

The graph.

◆ _prob_distr

std::uniform_real_distribution<double> Utopia::Models::CopyMeGraph::CopyMeGraph::_prob_distr

private

A re-usable uniform real distribution to evaluate probabilities.

◆ _some_parameter

double Utopia::Models::CopyMeGraph::CopyMeGraph::_some_parameter

private

Some parameter.

◆ some_interaction

VertexVoidRule Utopia::Models::CopyMeGraph::CopyMeGraph::some_interaction

private

Initial value:

= [this](const VertexDesc v, GraphType& g) {
        
        g[v].state.some_state += 1;
 
        for (const auto nb : range<IterateOver::neighbors>(v, g)) {
            
            g[v].state.some_trait += g[nb].state.some_trait;
 
            g[v].state.some_trait += (this->_prob_distr(*this->_rng) * 2. - 1.);
        }
 
        g[v].state.some_trait /= this->_some_parameter;
    }

An interaction function of a single vertex with its neighbors.

                                                                               {
        // Increase some_state by one
        g[v].state.some_state += 1;
 
        // Iterate over all neighbors of the current vertex
        for (const auto nb : range<IterateOver::neighbors>(v, g)) {
            // Obvious thing to do is to increase some_trait by the sum of
            // some_traits's of the neighbor. Sure thing.
            g[v].state.some_trait += g[nb].state.some_trait;
 
            // Let's add a random number in range [-1, +1] as well
            g[v].state.some_trait += (this->_prob_distr(*this->_rng) * 2. - 1.);
        }
 
        // Ahhh and obviously you need to divide some float by
        // _some_parameter because that makes totally sense
        g[v].state.some_trait /= this->_some_parameter;
    };

◆ some_other_rule

VertexStateRule Utopia::Models::CopyMeGraph::CopyMeGraph::some_other_rule

private

Initial value:

= [this](const VertexDesc v, GraphType& g) {
        
        auto state = g[v].state;
 
        
        if (this->_prob_distr(*this->_rng) < 0.3) {
            state.some_state = 0;
        }
 
        return state;
    }

Some other rule function.

Warning: This rule should be applied synchronously, so the vertex state may NOT be changed directly. Instead, the state needs to be copied and changes should be done to the copied state only.

                                                                               {
        // COPY the state -- important for synchronous update
        auto state = g[v].state;
 
        // With a probability of 0.3 set the vertex's some_state to 0
        if (this->_prob_distr(*this->_rng) < 0.3) {
            state.some_state = 0;
        }
 
        return state;
    };

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

src/utopia/models/CopyMeGraph/CopyMeGraph.hh

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ DataGroup

◆ DataSet

◆ EdgeDesc

◆ EdgeStateRule

◆ EdgeVoidRule

◆ VertexDesc

◆ VertexStateRule

◆ VertexVoidRule

Constructor & Destructor Documentation

◆ CopyMeGraph()

Member Function Documentation

◆ calc_some_state_mean()

◆ initialize_edges()

◆ initialize_graph()

◆ initialize_vertices()

◆ monitor()

◆ perform_step()

◆ write_data()

Member Data Documentation

◆ _dgrp_g_dynamic

◆ _dgrp_g_static

◆ _dset_some_state

◆ _dset_some_trait

◆ _g

◆ _prob_distr

◆ _some_parameter

◆ some_interaction

◆ some_other_rule