DeGroot/Deffuant: Construct from settings

Easier and clearer. Also more private members.

Co-authored-by: Amrita Goswami <[email protected]>

include/model.hpp

@@ -13,8 +13,6 @@ class Model
 public:
     using AgentT = AgentT_;
 
-    std::optional<size_t> max_iterations = std::nullopt;
-
     Model() = default;
     Model( std::optional<size_t> max_iterations ) : max_iterations( max_iterations ){};
 
@@ -48,6 +46,7 @@ class Model
     virtual ~Model() = default;
 
 private:
+    std::optional<size_t> max_iterations = std::nullopt;
     size_t _n_iterations{};
 };
 

include/models/DeGroot.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "agents/simple_agent.hpp"
+#include "config_parser.hpp"
 #include "model.hpp"
 #include "network.hpp"
 #include <optional>
@@ -11,16 +12,16 @@ namespace Seldon
 class DeGrootModel : public Model<SimpleAgent>
 {
 public:
-    using AgentT           = SimpleAgent;
-    using NetworkT         = Network<AgentT>;
-    double convergence_tol = 1e-12;
+    using AgentT   = SimpleAgent;
+    using NetworkT = Network<AgentT>;
 
-    DeGrootModel( NetworkT & network );
+    DeGrootModel( Config::DeGrootSettings settings, NetworkT & network );
 
     void iteration() override;
     bool finished() override;
 
 private:
+    double convergence_tol{};
     std::optional<double> max_opinion_diff = std::nullopt;
     NetworkT & network;
     std::vector<AgentT> agents_current_copy;

include/models/DeffuantModel.hpp

@@ -2,16 +2,14 @@
 
 #include "agents/discrete_vector_agent.hpp"
 #include "agents/simple_agent.hpp"
+#include "config_parser.hpp"
 #include "model.hpp"
 #include "network.hpp"
 #include "util/math.hpp"
 #include <cstddef>
 #include <random>
 
 #include "network_generation.hpp"
-#include <set>
-#include <string>
-#include <utility>
 
 #include <vector>
 
@@ -25,12 +23,14 @@ class DeffuantModelAbstract : public Model<AgentT_>
     using AgentT   = AgentT_;
     using NetworkT = Network<AgentT>;
 
-    double homophily_threshold = 0.2;   // d in paper
-    double mu                  = 0.5;   // convergence parameter
-    bool use_network           = false; // for the basic Deffuant model
-
-    DeffuantModelAbstract( NetworkT & network, std::mt19937 & gen, bool use_network )
-            : Model<AgentT>(), use_network( use_network ), network( network ), gen( gen )
+    DeffuantModelAbstract(
+        const Config::DeffuantSettings & settings, NetworkT & network, std::mt19937 & gen, bool use_network )
+            : Model<AgentT>( settings.max_iterations ),
+              homophily_threshold( settings.homophily_threshold ),
+              mu( settings.mu ),
+              use_network( settings.use_network ),
+              network( network ),
+              gen( gen )
     {
         // Generate the network as a square lattice if use_network is true
         if( use_network )
@@ -103,6 +103,9 @@ class DeffuantModelAbstract : public Model<AgentT_>
     // bool finished() override;
 
 private:
+    double homophily_threshold{}; // d in paper
+    double mu{};                  // convergence parameter
+    bool use_network{};           // for the basic Deffuant model
     NetworkT & network;
     std::mt19937 & gen; // reference to simulation Mersenne-Twister engine
 };

include/simulation.hpp

@@ -70,9 +70,7 @@ class Simulation : public SimulationInterface
                 // DeGroot specific parameters
                 model = [&]()
                 {
-                    auto model             = std::make_unique<DeGrootModel>( network );
-                    model->max_iterations  = degroot_settings.max_iterations;
-                    model->convergence_tol = degroot_settings.convergence_tol;
+                    auto model = std::make_unique<DeGrootModel>( degroot_settings, network );
                     return model;
                 }();
 
@@ -88,10 +86,8 @@ class Simulation : public SimulationInterface
                 // Deffuant model specific parameters
                 model = [&]()
                 {
-                    auto model = std::make_unique<DeffuantModel>( network, gen, deffuant_settings.use_network );
-                    model->max_iterations      = deffuant_settings.max_iterations;
-                    model->homophily_threshold = deffuant_settings.homophily_threshold;
-                    model->mu                  = deffuant_settings.mu;
+                    auto model = std::make_unique<DeffuantModel>(
+                        deffuant_settings, network, gen, deffuant_settings.use_network );
                     return model;
                 }();
 

src/models/ActivityDrivenModel.cpp

@@ -181,7 +181,8 @@ void ActivityDrivenModel::update_network_mean()
         contact_prob_list[idx_agent] = weights; // set to zero
     }
 
-    auto probability_helper = []( double omega, size_t m ) {
+    auto probability_helper = []( double omega, size_t m )
+    {
         double p = 0;
         for( size_t i = 1; i <= m; i++ )
             p += ( std::pow( -omega, i + 1 ) + omega ) / ( omega + 1 );

src/models/DeGroot.cpp

@@ -1,12 +1,16 @@
 #include "models/DeGroot.hpp"
+#include "config_parser.hpp"
 #include <cmath>
 #include <iterator>
 
 namespace Seldon
 {
 
-DeGrootModel::DeGrootModel( NetworkT & network )
-        : Model<AgentT>(), network( network ), agents_current_copy( network.agents )
+DeGrootModel::DeGrootModel( Config::DeGrootSettings settings, NetworkT & network )
+        : Model<AgentT>( settings.max_iterations ),
+          convergence_tol( settings.convergence_tol ),
+          network( network ),
+          agents_current_copy( network.agents )
 {
     // For a strongly connected network, the number of SCCs should be 1
     // Print a warning if this is not true

test/test_deGroot.cpp

@@ -23,11 +23,15 @@ TEST_CASE( "Test the DeGroot Model Symmetric", "[DeGroot]" )
         { 0.2, 0.8 },
     };
 
+    auto settings = Config::DeGrootSettings();
+
     auto network = Network( std::move( neighbour_list ), std::move( weight_list ), Network::EdgeDirection::Incoming );
-    auto model   = DeGrootModel( network );
 
-    model.convergence_tol          = 1e-6;
-    model.max_iterations           = 100;
+    settings.convergence_tol = 1e-6;
+    settings.max_iterations  = 100;
+
+    auto model = DeGrootModel( settings, network );
+
     network.agents[0].data.opinion = 0.0;
     network.agents[1].data.opinion = 1.0;
 
@@ -36,10 +40,11 @@ TEST_CASE( "Test the DeGroot Model Symmetric", "[DeGroot]" )
         model.iteration();
     }
 
-    INFO( fmt::format( "N_iterations = {} (with convergence_tol {})\n", model.n_iterations(), model.convergence_tol ) );
+    INFO( fmt::format(
+        "N_iterations = {} (with convergence_tol {})\n", model.n_iterations(), settings.convergence_tol ) );
     for( size_t i = 0; i < n_agents; i++ )
     {
         INFO( fmt::format( "Opinion {} = {}\n", i, network.agents[i].data.opinion ) );
-        REQUIRE_THAT( network.agents[i].data.opinion, WithinAbs( 0.5, model.convergence_tol * 10.0 ) );
+        REQUIRE_THAT( network.agents[i].data.opinion, WithinAbs( 0.5, settings.convergence_tol * 10.0 ) );
     }
 }