Utopia::Models::Opinionet::Opinionet< NWType > Class Template Reference

The Opinionet model class. More...

#include <Opinionet.hh>

Inheritance diagram for Utopia::Models::Opinionet::Opinionet< NWType >:

Collaboration diagram for Utopia::Models::Opinionet::Opinionet< NWType >:

Public Types
using	Base = Model< Opinionet, OpinionetTypes >
	The base model type.
using	Config = typename Base::Config
	Data type that holds the configuration.
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	RNG = typename Base::RNG
	Data type of the shared RNG.
Public Types inherited from Utopia::Model< Derived, ModelTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.
using	DataManager = DataIO::Default::DefaultDataManager< Derived >
	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 >
	Opinionet (const std::string name, ParentModel &parent)
	Construct the Opinionet model.
void	perform_step ()
	Iterate a single step Each step consists of an opinion update and edge rewiring.
void	monitor ()
	Monitor model information.
void	write_data ()
	Write data.
Public Member Functions inherited from Utopia::Model< Derived, ModelTypes >
template<class ParentModel , class... WriterArgs>
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< Derived > &w_deciders=DataIO::Default::default_deciders< Derived >, const DataIO::Default::DefaultTriggermap< Derived > &w_triggers=DataIO::Default::default_triggers< Derived >)
	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.
template<class CellManager >
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.
template<class AgentManager >
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
Interaction_type	initialize_interaction ()
Opinion_space_type	initialize_opinion_space ()
Rewiring	initialize_rewiring ()
void	initialize_properties ()
NWType	initialize_nw () const
std::shared_ptr< DataSet >	create_edge_weight_dset ()

Private Attributes
const Interaction_type	_interaction
	Modes.
const Opinion_space_type	_opinion_space
const Rewiring	_rewire
NWType	_nw
	Network and model dynamics parameters.
const double	_tolerance
const double	_susceptibility
const double	_weighting
std::uniform_real_distribution< double >	_uniform_prob_distr
	A uniform probability distribution.
const std::shared_ptr< DataGroup >	_dgrp_nw
const std::shared_ptr< DataSet >	_dset_opinion
const std::shared_ptr< DataSet >	_dset_edge_weights

Additional Inherited Members
Protected Member Functions inherited from Utopia::Model< Derived, 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.
Derived &	impl ()
	cast to the derived class
const Derived &	impl () const
	const cast to the derived interface
Protected Attributes inherited from Utopia::Model< Derived, 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< Derived, ModelTypes >
static constexpr WriteMode	_write_mode = ModelTypes::write_mode
	Which data-writing mode the base model should use.

Detailed Description

template<typename NWType = NetworkUndirected>
class Utopia::Models::Opinionet::Opinionet< NWType >

The Opinionet model class.

This is a 1d opinion dynamics model with interactions based on bounded confidence.

Member Typedef Documentation

Base

template<typename NWType = NetworkUndirected>

using Utopia::Models::Opinionet::Opinionet< NWType >::Base = Model<Opinionet, OpinionetTypes>

The base model type.

Config

template<typename NWType = NetworkUndirected>

using Utopia::Models::Opinionet::Opinionet< NWType >::Config = typename Base::Config

Data type that holds the configuration.

DataGroup

template<typename NWType = NetworkUndirected>

using Utopia::Models::Opinionet::Opinionet< NWType >::DataGroup = typename Base::DataGroup

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

DataSet

template<typename NWType = NetworkUndirected>

using Utopia::Models::Opinionet::Opinionet< NWType >::DataSet = typename Base::DataSet

Data type for a dataset.

RNG

template<typename NWType = NetworkUndirected>

using Utopia::Models::Opinionet::Opinionet< NWType >::RNG = typename Base::RNG

Data type of the shared RNG.

Constructor & Destructor Documentation

Opinionet()

template<typename NWType = NetworkUndirected>

template<class ParentModel >

Utopia::Models::Opinionet::Opinionet< NWType >::Opinionet ( const std::string  name, ParentModel &  parent  )

inline

Construct the Opinionet model.

Parameters

name	Name of this model instance
parent	The parent model this model instance resides in

    :
        // Initialize first via base model
        Base(name, parent),
        // Initialize modes
        _interaction(this->initialize_interaction()),
        _opinion_space(this->initialize_opinion_space()),
        _rewire(this->initialize_rewiring()),
        // Initialize the network
        _nw(this->initialize_nw()),
        // Initialize the model parameters
        _tolerance(get_as<double>("tolerance", this->_cfg)),
        _susceptibility(get_as<double>("susceptibility", this->_cfg)),
        _weighting(get_as<double>(
            "weighting", this->_cfg["network"]["edges"])),
        _uniform_prob_distr(0., 1.),
        // Create datagroups and datasets
        _dgrp_nw(create_graph_group(_nw, this->_hdfgrp, "nw")),
        _dset_opinion(this->create_dset("opinion", _dgrp_nw,
                                        {boost::num_vertices(_nw)})),
        _dset_edge_weights(this->create_edge_weight_dset())
    {
        this->_log->debug("Constructing the Opinionet Model ...");
 
        // Initialize the network properties
        this->initialize_properties();
 
        this->_log->info(
            "Initialized network with {} vertices and {} edges. Directed: {}",
            boost::num_vertices(_nw),
            boost::num_edges(_nw),
            boost::is_directed(_nw)
        );
 
        // Mark the datasets as vertex properties and add dimensions and
        // coordinates.
        _dset_opinion->add_attribute("is_vertex_property", true);
        _dset_opinion->add_attribute("dim_name__1", "vertex_idx");
        _dset_opinion->add_attribute("coords_mode__vertex_idx", "trivial");
 
        if (_rewire == Rewiring::RewiringOff) {
            save_graph(_nw, _dgrp_nw);
            this->_log->debug("Network saved.");
        }
 
        else {
            // Write the vertex data once, as it does not change with time
            auto _dset_vertices = _dgrp_nw->open_dataset(
                "_vertices", {boost::num_vertices(_nw)}
            );
            auto [v, v_end] = boost::vertices(_nw);
            _dset_vertices->write(
                v, v_end,
                [&](auto vd){
                    return boost::get(boost::vertex_index_t(), _nw, vd);
                }
            );
            _dset_vertices->add_attribute("dim_name__0", "vertex_idx");
            _dset_vertices->add_attribute(
                "coords_mode__vertex_idx", "trivial"
            );
        }
 
    }

Member Function Documentation

create_edge_weight_dset()

template<typename NWType = NetworkUndirected>

std::shared_ptr< DataSet > Utopia::Models::Opinionet::Opinionet< NWType >::create_edge_weight_dset ( )

inlineprivate

                                                     {
        if constexpr (Utils::is_directed<NWType>()) {
            return this->create_dset(
                "edge_weights", _dgrp_nw, {boost::num_edges(_nw)}
            );
        }
        else {
            return 0;
        }
    }

initialize_interaction()

template<typename NWType = NetworkUndirected>

Interaction_type Utopia::Models::Opinionet::Opinionet< NWType >::initialize_interaction ( )

inlineprivate

                                              {
        if (get_as<std::string>("interaction_function", this->_cfg)
            == "Deffuant")
        {
            return Interaction_type::Deffuant;
        }
        else {
            return Interaction_type::HegselmannKrause;
        }
    }

initialize_nw()

template<typename NWType = NetworkUndirected>

NWType Utopia::Models::Opinionet::Opinionet< NWType >::initialize_nw ( ) const

inlineprivate

                                 {
        this->_log->debug("Creating the network ...");
 
        auto g = Graph::create_graph<NWType>(this->_cfg["network"], *this->_rng);
 
        this->_log->debug("Network created.");
 
        return g;
    }

initialize_opinion_space()

template<typename NWType = NetworkUndirected>

Opinion_space_type Utopia::Models::Opinionet::Opinionet< NWType >::initialize_opinion_space ( )

inlineprivate

                                                  {
        if (get_as<std::string>("type", this->_cfg["opinion_space"])
            == "discrete")
        {
            return Opinion_space_type::discrete;
        }
        else {
            return Opinion_space_type::continuous;
        }
    }

initialize_properties()

template<typename NWType = NetworkUndirected>

void Utopia::Models::Opinionet::Opinionet< NWType >::initialize_properties ( )

inlineprivate

                                 {
        this->_log->debug("Initializing the properties ...");
 
        // Continuous opinion space: draw opinions from a continuous interval
        if (_opinion_space == Opinion_space_type::continuous) {
            const std::pair<double, double> opinion_interval =
                get_as<std::pair<double, double>>(
                    "interval", this->_cfg["opinion_space"]
                );
 
            if (opinion_interval.first >= opinion_interval.second) {
              throw std::invalid_argument("Error: The given opinion interval"
              " is invalid! Specify an interval of the kind [a, b], "
              "with a<b!");
            }
 
            for (const auto v : range<IterateOver::vertices>(_nw)) {
                _nw[v].opinion = Utils::get_rand<double>(
                    opinion_interval, *this->_rng);
            }
        }
        // Discrete opinion space: draw opinions from a discrete set
        else {
            const int opinion_values =
                get_as<int>("num_opinions", this->_cfg["opinion_space"]);
 
            for (const auto v : range<IterateOver::vertices>(_nw)) {
                _nw[v].opinion =
                    Utils::get_rand<int>(
                        std::make_pair<int, int>(0, opinion_values-1),
                        *this->_rng
                    );
            }
        }
 
        // For directed network: Initialize weights depending on the opinion
        // distances. In the undirected case, weights are not required.
        if constexpr (Utils::is_directed<NWType>()) {
            for (const auto v : range<IterateOver::vertices>(_nw)) {
                if (boost::out_degree(v, _nw) != 0) {
                    Utils::set_and_normalize_weights(v, _nw, _weighting);
                }
            }
        }
    }

initialize_rewiring()

template<typename NWType = NetworkUndirected>

Rewiring Utopia::Models::Opinionet::Opinionet< NWType >::initialize_rewiring ( )

inlineprivate

                                   {
        if (get_as<bool>("rewiring", this->_cfg["network"]["edges"])) {
            return Rewiring::RewiringOn;
        }
        else {
            return Rewiring::RewiringOff;
        }
    }

monitor()

template<typename NWType = NetworkUndirected>

void Utopia::Models::Opinionet::Opinionet< NWType >::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.

                    {
        double mean_opinion = 0.;
        double opinion_std = 0.;
        double min_opinion = std::numeric_limits<double>::infinity();
        double max_opinion = -std::numeric_limits<double>::infinity();
 
        double temp_op;
        for (const auto v : range<IterateOver::vertices>(_nw)) {
            temp_op = _nw[v].opinion;
            mean_opinion += temp_op;
 
            if (temp_op < min_opinion) {
                min_opinion = temp_op;
            }
 
            if (temp_op > max_opinion) {
                max_opinion = temp_op;
            }
        }
 
        mean_opinion /= boost::num_vertices(_nw);
 
        for (const auto v : range<IterateOver::vertices>(_nw)) {
            opinion_std += std::pow(_nw[v].opinion - mean_opinion, 2.);
        }
 
        opinion_std = std::sqrt(opinion_std / (boost::num_vertices(_nw) - 1.));
 
        this->_monitor.set_entry("mean_opinion", mean_opinion);
        this->_monitor.set_entry("opinion_std", opinion_std);
        this->_monitor.set_entry("min_opinion", min_opinion);
        this->_monitor.set_entry("max_opinion", max_opinion);
    }

perform_step()

template<typename NWType = NetworkUndirected>

void Utopia::Models::Opinionet::Opinionet< NWType >::perform_step ( )

inline

Iterate a single step Each step consists of an opinion update and edge rewiring.

Opinion update: Apply the interaction function to a randomly chosen vertex.

Rewiring, if enabled: Rewire a random edge based on selective exposure.

    {
        Revision::revision(
            _nw,
            _susceptibility,
            _tolerance,
            _weighting,
            _interaction,
            _opinion_space,
            _rewire,
            _uniform_prob_distr,
            *this->_rng
        );
    }

write_data()

template<typename NWType = NetworkUndirected>

void Utopia::Models::Opinionet::Opinionet< NWType >::write_data ( )

inline

Write data.

    {
        // Get the vertex iterators
        auto [v, v_end] = boost::vertices(_nw);
 
        // Write opinions
        _dset_opinion->write(
            v, v_end, [this](auto vd) { return _nw[vd].opinion; }
        );
 
        // Write edges
        if (_rewire == Rewiring::RewiringOn){
            // Adaptor tuple that allows to save the edge data
            const auto get_edge_data = std::make_tuple(
                std::make_tuple("_edges", "type",
                    std::make_tuple("source",
                        [](auto& ed, auto& _nw) {
                            return boost::get(
                                boost::vertex_index_t(), _nw,
                                boost::source(ed, _nw));
                        }
                    ),
                    std::make_tuple("target",
                        [](auto& ed, auto& _nw) {
                            return boost::get(
                                boost::vertex_index_t(), _nw,
                                boost::target(ed, _nw));
                        }
                    )
                )
            );
            // Save the edge data using the current time as label.
            save_edge_properties(
                _nw, _dgrp_nw, std::to_string(this->get_time()), get_edge_data
            );
        }
 
        // Write edge weights
        if constexpr (Utils::is_directed<NWType>()) {
 
            auto [e, e_end] = boost::edges(_nw);
 
            _dset_edge_weights->write(
                e, e_end, [this](auto ed) { return _nw[ed].weight; }
            );
        }
    }

Member Data Documentation

_dgrp_nw

template<typename NWType = NetworkUndirected>

const std::shared_ptr<DataGroup> Utopia::Models::Opinionet::Opinionet< NWType >::_dgrp_nw

private

_dset_edge_weights

template<typename NWType = NetworkUndirected>

const std::shared_ptr<DataSet> Utopia::Models::Opinionet::Opinionet< NWType >::_dset_edge_weights

private

_dset_opinion

template<typename NWType = NetworkUndirected>

const std::shared_ptr<DataSet> Utopia::Models::Opinionet::Opinionet< NWType >::_dset_opinion

private

_interaction

template<typename NWType = NetworkUndirected>

const Interaction_type Utopia::Models::Opinionet::Opinionet< NWType >::_interaction

private

Modes.

_nw

template<typename NWType = NetworkUndirected>

NWType Utopia::Models::Opinionet::Opinionet< NWType >::_nw

private

Network and model dynamics parameters.

_opinion_space

template<typename NWType = NetworkUndirected>

const Opinion_space_type Utopia::Models::Opinionet::Opinionet< NWType >::_opinion_space

private

_rewire

template<typename NWType = NetworkUndirected>

const Rewiring Utopia::Models::Opinionet::Opinionet< NWType >::_rewire

private

_susceptibility

template<typename NWType = NetworkUndirected>

const double Utopia::Models::Opinionet::Opinionet< NWType >::_susceptibility

private

_tolerance

template<typename NWType = NetworkUndirected>

const double Utopia::Models::Opinionet::Opinionet< NWType >::_tolerance

private

_uniform_prob_distr

template<typename NWType = NetworkUndirected>

std::uniform_real_distribution<double> Utopia::Models::Opinionet::Opinionet< NWType >::_uniform_prob_distr

private

A uniform probability distribution.

_weighting

template<typename NWType = NetworkUndirected>

const double Utopia::Models::Opinionet::Opinionet< NWType >::_weighting

private

---

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

• src/utopia/models/Opinionet/Opinionet.hh