// Use this for initialization
void Start()
{
#if NO_CLUSTER
#else
isMaster = ClusterNetwork.IsMasterOfCluster();
#endif
}
// Update is called once per frame
void Update()
{
if (initialized)
{
#if NO_CLUSTER
#else
Color c = flashColor;
if (!ClusterNetwork.IsDisconnected())
{
c = Color.black;
}
foreach (Camera cam in this.cameras)
{
cam.backgroundColor = c;
}
#endif
}
else if (this.GetComponent <InitialisationScript>().isInitialized)
{
this.initialized = true;
this.cameras = new List <Camera>();
foreach (Camera cam in this.GetComponentsInChildren <Camera>())
{
if (cam.gameObject.name.Contains("Slave Camera"))
{
cameras.Add(cam);
}
}
}
}
static void Main(string[] args)
{
List <double> results;
List <double> modularity;
string line = "";
System.IO.File.Delete(Properties.Settings.Default.ResultFile);
for (double mod = Properties.Settings.Default.Modularity_From; mod <= Properties.Settings.Default.Modularity_To; mod += Properties.Settings.Default.Modularity_Step)
{
Console.WriteLine();
line = "";
for (double bias = Properties.Settings.Default.bias_from; bias <= Properties.Settings.Default.bias_to; bias += Properties.Settings.Default.bias_step)
{
results = new List <double>();
modularity = new List <double>();
System.Threading.Tasks.Parallel.For(0, Properties.Settings.Default.runs, j =>
{
ClusterNetwork net = new ClusterNetwork(Properties.Settings.Default.Nodes, Properties.Settings.Default.Edges, Properties.Settings.Default.Clusters, mod);
Console.WriteLine("Run {0}, created cluster network with modularity={1:0.00}", j, (net as ClusterNetwork).NewmanModularityUndirected);
/// TODO: Run experiment
});
line = string.Format(new CultureInfo("en-US").NumberFormat, "{0:0.000} {1:0.000} {2:0.000} {3:0.000} \t", MathNet.Numerics.Statistics.Statistics.Mean(modularity.ToArray()), bias, MathNet.Numerics.Statistics.Statistics.Mean(results.ToArray()), MathNet.Numerics.Statistics.Statistics.StandardDeviation(results.ToArray()));
System.IO.File.AppendAllText(Properties.Settings.Default.ResultFile, line + "\n");
Console.WriteLine("Finished spreading on cluster network for modularity = {0:0.00}, bias = {1:0.00}, Average = {2:0.00}", mod, bias, MathNet.Numerics.Statistics.Statistics.Mean(results.ToArray()));
}
System.IO.File.AppendAllText(Properties.Settings.Default.ResultFile, "\n");
}
}
public static bool isMaster()
{
#if UNITY_EDITOR || NO_CLUSTER
return(true);
#else
return(ClusterNetwork.IsMasterOfCluster());
#endif
}
private static void SaveKeepalived(ClusterNetwork networkConfig, ClusterNode[] nodesConfig)
{
if (networkConfig == null)
{
ConsoleLogger.Log("[cluster] keepalived not configured: missing network parameters");
return;
}
if (!networkConfig.Active)
{
ConsoleLogger.Log("[cluster] shared network is disabled");
return;
}
var ports = networkConfig.PortMapping;
if (!ports.Any())
{
ConsoleLogger.Log("[cluster] exit: !ports.Any()");
return;
}
ConsoleLogger.Log("[cluster] init keepalived");
const string keepalivedService = "keepalived.service";
if (Systemctl.IsActive(keepalivedService))
{
ConsoleLogger.Log("[cluster] stop service");
Systemctl.Stop(keepalivedService);
}
ConsoleLogger.Log("[cluster] set configuration file");
var lines = new string[] {
"vrrp_script chk_haproxy {",
" script \"killall -0 haproxy\"",
" interval 30",
" weight 2",
"}",
"",
"vrrp_instance RH_INT {",
$" interface {networkConfig.NetworkInterface}",
" state MASTER",
" virtual_router_id 51",
$" priority 100",
" virtual_ipaddress {",
$" {networkConfig.VirtualIpAddress}",
" }",
" track_script {",
" chk_haproxy",
" }",
"}",
};
File.WriteAllLines(keepalivedFileOutput, lines);
Keepalived.Stop();
Keepalived.Start(keepalivedFileOutput);
}
// Use this for initialization
void Start()
{
ClusterInput.AddInput("MouseTestX", "testDevice1", "10.0.1.28", 0, ClusterInputType.CustomProvidedInput);
ClusterInput.AddInput("MouseTestY", "testDevice2", "10.0.1.28", 0, ClusterInputType.CustomProvidedInput);
if (ClusterNetwork.IsMasterOfCluster())
{
Debug.Log("I am the cluster master");
}
else
{
Debug.Log("I am the cluster slave");
}
}
// Update is called once per frame
void Update()
{
if (ClusterNetwork.IsMasterOfCluster())
{
Vector3 mousepos = Input.mousePosition;
mousepos.x /= Screen.width;
mousepos.y /= Screen.height;
ClusterInput.SetAxis("MouseTestX", mousepos.x);
ClusterInput.SetAxis("MouseTestY", mousepos.y);
Debug.Log("SetAxis to" + mousepos.ToString());
}
Vector2 pos = new Vector2();
pos.x = ClusterInput.GetAxis("MouseTestX");
pos.y = ClusterInput.GetAxis("MouseTestY");
this.transform.position = new Vector3(pos.x, pos.y, 5.0f);
Debug.Log("getAxis" + pos.ToString());
}
public void TestClusterNetwork()
{
ClusterNetwork network = new ClusterNetwork(2000, 5000, 100, 0.9d, false);
Assert.LessOrEqual(Math.Abs(network.NewmanModularityUndirected - 0.9d), 0.02);
Assert.LessOrEqual(Math.Abs(network.EdgeCount - 5000), 200);
Assert.AreEqual(network.VertexCount, 2000);
Assert.AreEqual(network.ClusterIDs.Length, 100);
Assert.AreEqual(network.EdgeCount, network.InterClusterEdgeNumber + network.IntraClusterEdgeNumber);
try{
foreach (Edge e in network.IntraClusterEdges)
{
int id1 = network.GetClusterForNode(e.Source);
int id2 = network.GetClusterForNode(e.Target);
Assert.AreEqual(id1, id2);
}
foreach (Edge e in network.InterClusterEdges)
{
int id1 = network.GetClusterForNode(e.Source);
int id2 = network.GetClusterForNode(e.Target);
Assert.AreNotEqual(id1, id2);
}
foreach (Vertex v in network.Vertices)
{
int id = network.GetClusterForNode(v);
Assert.LessOrEqual(id, network.ClusterIDs.Length);
}
List <Vertex> vertices = new List <Vertex>();
foreach (int id in network.ClusterIDs)
{
vertices.AddRange(network.GetNodesInCluster(id));
}
Assert.AreEqual(vertices.Count, network.VertexCount);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
/// <summary>
/// Converts the <see cref="sourceValue" /> parameter to the <see cref="destinationType" /> parameter using <see cref="formatProvider"
/// /> and <see cref="ignoreCase" />
/// </summary>
/// <param name="sourceValue">the value to convert into an instance of <see cref="ClusterNetwork" />.</param>
/// <returns>
/// an instance of <see cref="ClusterNetwork" />, or <c>null</c> if there is no suitable conversion.
/// </returns>
public static object ConvertFrom(dynamic sourceValue)
{
if (null == sourceValue)
{
return(null);
}
try
{
ClusterNetwork.FromJsonString(typeof(string) == sourceValue.GetType() ? sourceValue : sourceValue.ToJsonString());
}
catch
{
// Unable to use JSON pattern
}
try
{
return(new ClusterNetwork
{
DomainServer = ClusterDomainServerTypeConverter.ConvertFrom(sourceValue.DomainServer),
ExternalDataServicesIp = sourceValue.ExternalDataServicesIp,
ExternalIp = sourceValue.ExternalIp,
ExternalSubnet = sourceValue.ExternalSubnet,
HttpProxyList = sourceValue.HttpProxyList,
HttpProxyWhitelist = sourceValue.HttpProxyWhitelist,
InternalSubnet = sourceValue.InternalSubnet,
MasqueradingIp = sourceValue.MasqueradingIp,
MasqueradingPort = sourceValue.MasqueradingPort,
NameServerIpList = sourceValue.NameServerIpList,
NfsSubnetWhitelist = sourceValue.NfsSubnetWhitelist,
NtpServerIpList = sourceValue.NtpServerIpList,
SmtpServer = SmtpServerTypeConverter.ConvertFrom(sourceValue.SmtpServer),
});
}
catch
{
}
return(null);
}
public static void Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Usage: ModularityComputation [network_file] [directed=false] [visualize=false] [reduce_to_LCC=false]");
return;
}
bool directed = false;
if (args.Length >= 2)
{
directed = Boolean.Parse(args[1]);
}
ClusterNetwork n = ClusterNetwork.LoadNetwork(args[0], directed);
if (args.Length > 3 && Boolean.Parse(args[3]) == true)
{
n.ReduceToLargestConnectedComponent();
}
if (directed)
{
Console.WriteLine("Q = {0:0.0000000}", n.NewmanModularityDirected);
}
else
{
Console.WriteLine("Q = {0:0.0000000}", n.NewmanModularityUndirected);
}
if (args.Length > 2 && Boolean.Parse(args[2]) == true)
{
NETGen.Visualization.NetworkVisualizer.Start(n, new NETGen.Layouts.FruchtermanReingold.FruchtermanReingoldLayout(10), new NETGen.Visualization.NetworkColorizer(), 800, 600);
NETGen.Visualization.NetworkVisualizer.Layout.DoLayout();
}
}
private static void SaveHaproxy(ClusterNetwork networkConfig, ClusterNode[] nodesConfig)
{
if (networkConfig == null)
{
ConsoleLogger.Warn("[cluster] haproxy not configured: missing network parameters");
return;
}
if (!networkConfig.Active)
{
ConsoleLogger.Warn("[cluster] shared network is disabled");
return;
}
var ports = networkConfig.PortMapping;
if (!ports.Any())
{
ConsoleLogger.Warn("[cluster] exit: !ports.Any()");
return;
}
ConsoleLogger.Log("[cluster] init haproxy");
var lines = new List <string> {
"global",
" daemon",
" log 127.0.0.1 local0",
" log 127.0.0.1 local1 notice",
" maxconn 4096",
" user haproxy",
" group haproxy",
"",
"defaults",
" log global",
" mode http",
" option httplog",
" option dontlognull",
" retries 3",
" option redispatch",
" maxconn 2000",
" timeout connect 5000",
" timeout client 50000",
" timeout server 50000",
""
};
//var localServices = Application.CurrentConfiguration.Cluster.Nodes.FirstOrDefault(_ => _.MachineUid == Application.CurrentConfiguration.Host.MachineUid.ToString()).Services;
//if(localServices != null) {
int errorStateCounter = 0;
for (var i = 0; i < ports.Length; i++)
{
var port = ports[i];
//port.ServicePort = localServices.FirstOrDefault(_ => _.Name == port.ServiceName)?.Port.ToString();
if (string.IsNullOrEmpty(port.ServicePort))
{
errorStateCounter++;
ConsoleLogger.Warn($"[cluster] haproxy source port is not defined for '{port.ServiceName}'");
continue;
}
if (string.IsNullOrEmpty(port.VirtualPort))
{
ConsoleLogger.Warn($"[cluster] haproxy virtual port is not defined for '{port.ServiceName}'");
errorStateCounter++;
continue;
}
var frontEndLabel = $"fe_in{port.ServicePort}_out{port.VirtualPort}";
var backEndLabel = $"be_in{port.ServicePort}_out{port.VirtualPort}";
ConsoleLogger.Log($"[cluster] {port.ServiceName} virtual port: {port.VirtualPort} as {port.ServicePort}");
lines.Add($"frontend {frontEndLabel}");
lines.Add(" mode http");
lines.Add($" bind {networkConfig.VirtualIpAddress}:{port.VirtualPort} transparent");
lines.Add(" stats enable");
lines.Add(" stats auth admin:Anthilla");
lines.Add(" option httpclose");
lines.Add(" option forwardfor");
lines.Add($" default_backend {backEndLabel}");
lines.Add("");
lines.Add($"backend {backEndLabel}");
lines.Add(" balance roundrobin");
lines.Add(" cookie JSESSIONID prefix");
//lines.Add(" option httpchk HEAD /check.txt HTTP/1.0");
for (var n = 0; n < nodesConfig.Length; n++)
{
var node = nodesConfig[n];
lines.Add($" server {node.Hostname} {node.PublicIp}:{port.ServicePort} check");
}
lines.Add("");
}
//}
//else {
// ConsoleLogger.Warn("[cluster] local service does not exist");
// return;
//}
if (errorStateCounter == ports.Length)
{
ConsoleLogger.Log("[cluster] failed to configure haproxy: port mapping list is empty");
return;
}
File.WriteAllLines(haproxyFileOutput, lines);
Haproxy.Stop();
Haproxy.Start(haproxyFileOutput);
ConsoleLogger.Log("[cluster] haproxy started");
}
static void Main(string[] args)
{
try
{
// The resultfile is given as command line argument
//nodes = Int32.Parse(args[0]);
//edges = Int32.Parse(args[1]);
//clusters = Int32.Parse(args[2]);
resultfile = args[3];
} catch {
Console.WriteLine("Usage: mono Demo.exe [nodes] [edges] [clusters] [resultfile]");
return;
}
// Create a network of the given size and modularity ...
network = new ClusterNetwork(nodes, edges, clusters, 0.63d, true);
System.IO.StreamWriter sw = System.IO.File.CreateText("membership.dat");
int i = 0;
foreach (Vertex v in network.Vertices)
{
v.Label = (i++).ToString();
sw.WriteLine(network.GetClusterForNode(v).ToString());
}
sw.Close();
Network.SaveToEdgeFile(network, "network.edges");
Console.WriteLine("Created network with {0} vertices, {1} edges and modularity {2:0.00}", network.VertexCount, network.EdgeCount, network.NewmanModularityUndirected);
// Run the real-time visualization
NetworkColorizer colorizer = new NetworkColorizer();
//NetworkVisualizer.Start(network, new NETGen.Layouts.FruchtermanReingold.FruchtermanReingoldLayout(15), colorizer);
//NetworkVisualizer.Layout.DoLayoutAsync();
// Distribution of natural frequencies
double mean_frequency = 1d;
Normal normal = new Normal(mean_frequency, mean_frequency / 5d);
sync = new Kuramoto(network,
K,
colorizer,
new Func <Vertex, Vertex[]>(v => { return(new Vertex[] { v.RandomNeighbor }); })
);
foreach (Vertex v in network.Vertices)
{
sync.NaturalFrequencies[v] = normal.Sample();
}
foreach (int g in network.ClusterIDs)
{
pacemaker_mode[g] = false;
}
sync.OnStep += new Kuramoto.StepHandler(recordOrder);
Logger.AddMessage(LogEntryType.AppMsg, "Press enter to start synchronization experiment...");
Console.ReadLine();
// Run the simulation
sync.Run();
// Write the time series to the resultfile
if (resultfile != null)
{
sync.WriteTimeSeries(resultfile);
}
}
public override void RunSimulation()
{
empirical_network = ClusterNetwork.LoadNetwork(PrjName + "_network.edges", true);
simulated_network = ClusterNetwork.LoadNetwork(PrjName + "_network.edges", true);
//assign module membership deterministically for the simulated network
int my_V = 0;
int NClusters = simulated_network.GetClustersCount;
foreach (Vertex v in simulated_network.Vertices)
{
simulated_module_assignments[v] = my_V++ % NClusters;
}
//shuffle the dictionary to provide a randomized assignment making sure all modules are present
Random rand = new Random();
simulated_module_assignments = simulated_module_assignments.OrderBy(x => rand.Next()).ToDictionary(item => item.Key, item => item.Value);
//run the simulation
int time = 0;
//System.IO.StreamWriter file = new System.IO.StreamWriter(PrjName + "out.txt");
while (time < Steps)
{
Change();
time++;
//simulated_network.ResetClusters(simulated_module_assignments);
//file.WriteLine("{0} {1} {2} {3} {4}",T, simulated_network.NewmanModularityDirected, simulated_network.EdgeCount, simulated_network.InterClusterEdgeNumber, simulated_network.IntraClusterEdgeNumber);
//foreach(Vertex v in simulated_network.Vertices)
// simulated_module_assignments[v] = simulated_network.GetClusterForNode(v);
}
//file.Close();
//shrink the clusterIDs to account for the possibility of the existance of empty modules
simulated_network.ResetClusters(simulated_module_assignments);
//results
n_nodes = empirical_network.VertexCount;
n_edges = empirical_network.EdgeCount;
n_modules_e = empirical_network.GetClustersCount;
n_modules_s = simulated_network.GetClustersCount;
q_e = empirical_network.NewmanModularityDirected;
q_s = simulated_network.NewmanModularityDirected;
o_p = 0d;
o_m = 0d;
Vertex s_v;
Vertex s_w;
foreach (Vertex e_v in empirical_network.Vertices)
{
foreach (Vertex e_w in empirical_network.Vertices)
{
if (e_v != e_w)
{
s_v = simulated_network.SearchVertex(e_v.Label);
s_w = simulated_network.SearchVertex(e_w.Label);
if ((simulated_network.GetClusterForNode(s_v) == simulated_network.GetClusterForNode(s_w)) && (empirical_network.GetClusterForNode(e_v) == empirical_network.GetClusterForNode(e_w)))
{
o_p++;
}
else
{
if ((simulated_network.GetClusterForNode(s_v) != simulated_network.GetClusterForNode(s_w)) && (empirical_network.GetClusterForNode(e_v) != empirical_network.GetClusterForNode(e_w)))
{
o_m++;
}
}
}
}
}
o_p /= ((n_nodes * n_nodes) - n_nodes);
o_m /= ((n_nodes * n_nodes) - n_nodes);
av_module_s_e = empirical_network.GetAverageClusterSize;
av_module_s_s = simulated_network.GetAverageClusterSize;
sd_module_s_e = empirical_network.GetStandardDeviationClusterSize;
sd_module_s_s = simulated_network.GetStandardDeviationClusterSize;
av_n_module_s_e = empirical_network.GetAverageNodeClusterSize;
av_n_module_s_s = simulated_network.GetAverageNodeClusterSize;
sd_n_module_s_e = empirical_network.GetStandardDeviationNodeClusterSize;
sd_n_module_s_s = simulated_network.GetStandardDeviationNodeClusterSize;
n_inter_edges_e = empirical_network.InterClusterEdgeNumber;
n_intra_edges_e = empirical_network.IntraClusterEdgeNumber;
n_inter_edges_s = simulated_network.InterClusterEdgeNumber;
n_intra_edges_s = simulated_network.IntraClusterEdgeNumber;
}
private static AggregationResult RunAggregation(ClusterNetwork net, double bias)
{
Dictionary <Vertex, double> _attributes = new Dictionary <Vertex, double>();
Dictionary <Vertex, double> _aggregates = new Dictionary <Vertex, double>();
MathNet.Numerics.Distributions.Normal normal = new MathNet.Numerics.Distributions.Normal(0d, 5d);
AggregationResult result = new AggregationResult();
result.Modularity = net.NewmanModularityUndirected;
double average = 0d;
foreach (Vertex v in net.Vertices)
{
_attributes[v] = normal.Sample();
_aggregates[v] = _attributes[v];
average += _attributes[v];
}
average /= (double)net.VertexCount;
double avgEstimate = double.MaxValue;
result.FinalVariance = double.MaxValue;
result.FinalOffset = 0d;
for (int k = 0; k < Properties.Settings.Default.ConsensusRounds; k++)
{
foreach (Vertex v in net.Vertices.ToArray())
{
Vertex w = v.RandomNeighbor;
List <Vertex> intraNeighbors = new List <Vertex>();
List <Vertex> interNeighbors = new List <Vertex>();
ClassifyNeighbors(net, v, intraNeighbors, interNeighbors);
double r = net.NextRandomDouble();
if (r <= bias && interNeighbors.Count > 0)
{
w = interNeighbors.ElementAt(net.NextRandom(interNeighbors.Count));
}
_aggregates[v] = aggregate(_aggregates[v], _aggregates[w]);
_aggregates[w] = aggregate(_aggregates[v], _aggregates[w]);
}
avgEstimate = 0d;
foreach (Vertex v in net.Vertices.ToArray())
{
avgEstimate += _aggregates[v];
}
avgEstimate /= (double)net.VertexCount;
result.FinalVariance = 0d;
foreach (Vertex v in net.Vertices.ToArray())
{
result.FinalVariance += Math.Pow(_aggregates[v] - avgEstimate, 2d);
}
result.FinalVariance /= (double)net.VertexCount;
double intraVar = 0d;
foreach (int c in net.ClusterIDs)
{
double localavg = 0d;
double localvar = 0d;
foreach (Vertex v in net.GetNodesInCluster(c))
{
localavg += _aggregates[v];
}
localavg /= net.GetClusterSize(c);
foreach (Vertex v in net.GetNodesInCluster(c))
{
localvar += Math.Pow(_aggregates[v] - localavg, 2d);
}
localvar /= net.GetClusterSize(c);
intraVar += localvar;
}
intraVar /= 50d;
//Console.WriteLine("i = {0:0000}, Avg = {1:0.000}, Estimate = {2:0.000}, Intra-Var = {3:0.000}, Total Var = {4:0.000}", result.iterations, average, avgEstimate, intraVar, totalVar);
}
result.FinalOffset = average - avgEstimate;
return(result);
}
/// <summary>
/// Runs the cluster synchronization experiments, reading simulation parameters from the .config file
/// </summary>
public override void RunSimulation()
{
// Setup the experiment by creating the network and the synchronization module
ClusterNetwork net = new ClusterNetwork(nodes, edges, clusters, modularity_tgt, true);
Kuramoto sync = new Kuramoto(net, K);
// Couple to single random neighbor in each step
sync.CouplingSelector = new Func <Vertex, Vertex[]>(v => {
return(new Vertex[] { v.RandomNeighbor });
});
// Keeps track whether clusters have already switched to pacemaker mode
Dictionary <int, bool> pacemaker_mode = new Dictionary <int, bool>();
// Mixed distribution of natural frequencies
Normal group_avgs = new Normal(global_mean, global_mean * global_mean_width_factor);
foreach (int i in net.ClusterIDs)
{
double group_avg = group_avgs.Sample();
Normal group_dist = new Normal(group_avg, group_avg * cluster_width_factor);
foreach (Vertex v in net.GetNodesInCluster(i))
{
sync.NaturalFrequencies[v] = group_dist.Sample();
}
pacemaker_mode[i] = false;
}
// Set up handler that will be called AFTER each simulation step
sync.OnStep += new Kuramoto.StepHandler(
delegate(double t)
{
// Compute global order parameter
finalOrderParam = sync.GetOrder(net.Vertices.ToArray());
normalizerIntegratedOrder += finalOrderParam;
// Record order evolution
sync.AddDataPoint("GlobalOrder", finalOrderParam);
// Stop simulation if full ordered state is reached or time exceeded
if (finalOrderParam >= orderThres || t > timeThres)
{
sync.Stop();
}
// Output will only been shown when pyspg module is started in debug mode
//if(t % (sync.TimeDelta * 100d) == 0)
Logger.AddMessage(LogEntryType.SimMsg, string.Format("Time {0}, Order = {1:0.00}", t, finalOrderParam));
// Compute order parameter of individual clusters
foreach (int g in net.ClusterIDs)
{
double localOrder = sync.GetOrder(net.GetNodesInCluster(g));
sync.AddDataPoint(string.Format("ClusterOrder_{0}", g), localOrder);
// Switch to pacemaker mode if cluster order exceeds threshold
if (localOrder > orderThres && !pacemaker_mode[g])
{
pacemaker_mode[g] = true;
// Probabilistically switch border nodes to pacemaker mode
// Note: CouplingStrengths[... v, w ... ] is the strength by which phase advance of v is influenced when coupling to node w
foreach (Vertex v in net.GetNodesInCluster(g))
{
if (net.HasInterClusterConnection(v))
{
foreach (Vertex w in v.Neigbors)
{
if (!net.HasInterClusterConnection(w) && net.NextRandomDouble() <= pacemakerProb)
{
Logger.AddMessage(LogEntryType.AppMsg, string.Format("Vertex switched to pacemaker mode", g));
sync.CouplingStrengths[new Tuple <Vertex, Vertex>(v, w)] = 0d;
}
}
}
}
}
}
});
// compute coupling density in the initial situation
initialDensity = 0d;
foreach (var t in sync.CouplingStrengths.Keys)
{
initialDensity += sync.CouplingStrengths[t];
}
// Synchronously run the experiment (blocks execution until experiment is finished)
sync.Run();
// compute final coupling density
finalDensity = 0d;
foreach (var t in sync.CouplingStrengths.Keys)
{
finalDensity += sync.CouplingStrengths[t];
}
// Write time-series of the order parameters (global and cluster-wise) to a file
sync.WriteTimeSeries(dynamics);
// Set results
normalizerIntegratedOrder /= sync.Time;
time = sync.Time;
finalOrderParam = sync.GetOrder(net.Vertices.ToArray());
modularity_real = net.NewmanModularityUndirected;
}
