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 SpreadingResult RunSpreading(ClusterNetwork net, double bias, int delay=0)
{
SpreadingResult res = new SpreadingResult();
Dictionary<Vertex, int> infectionTime = new Dictionary<Vertex, int>();
foreach (Vertex v in net.Vertices)
infectionTime[v] = int.MinValue;
List<Vertex> infected = new List<Vertex>();
Vertex seed = net.RandomVertex;
infected.Add(seed);
int i = 0;
while (infected.Count < net.VertexCount)
{
foreach (Vertex v in infected.ToArray())
{
// Biasing strategy
Vertex neighbor = v.RandomNeighbor;
double r = net.NextRandomDouble();
List<Vertex> intraNeighbors = new List<Vertex>();
List<Vertex> interNeighbors = new List<Vertex>();
ClassifyNeighbors(net, v, intraNeighbors, interNeighbors);
if (r <= bias && interNeighbors.Count > 0)
neighbor = interNeighbors.ElementAt(net.NextRandom(interNeighbors.Count));
if (neighbor != null && infectionTime[neighbor] == int.MinValue)
{
infectionTime[neighbor] = i;
infected.Add(neighbor);
}
}
if (delay > 0)
System.Threading.Thread.Sleep(delay);
i++;
}
res.Iterations = i;
res.Modularity = (net as ClusterNetwork).NewmanModularity;
return res;
}
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);
}
}
static void Main(string[] args)
{
GlobValues glob = new GlobValues();
string configFile, dir = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), inputPath, outputPath;
String[] path = dir.Split(new string[] { "Launch" }, StringSplitOptions.None);
inputPath = path[0] + "Launch" + Path.DirectorySeparatorChar + "input";
configFile = inputPath + Path.DirectorySeparatorChar + "config.param.txt";
// outputPath = path[0] + "Launch" + Path.DirectorySeparatorChar + "output";
Console.WriteLine("File is : " + configFile);
Console.WriteLine("Starting the program to generate the network based on modularity..");
try
{
// Read parameters from param.config file
read_parameters(configFile, glob);
}
catch
{
Console.WriteLine("Usage: mono Demo.exe [nodes] [edges] [clusters] [resultfile]");
return;
}
// Displays the information
Console.WriteLine("Given Parameter values");
Console.WriteLine("\n Nodes: " + glob.nodes + "\n Edges: " + glob.edges + "\n Clusters: " + glob.clusters + "\n Modularity MinValue: " + glob.modularityMinValue + "\n Modularity MaxValue: " + glob.modularityMaxValue);
Console.WriteLine(" Number of runs: " + glob.numberOfGraphs + "\n Coupling probability value: "+glob.couplingProb*100);
string sourceNetworkFile = inputPath = path[0] + "Launch" + Path.DirectorySeparatorChar + "Launch" + Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar + "Debug" + Path.DirectorySeparatorChar + "network.edges";
string sourceResultFile = inputPath = path[0] + "Launch" + Path.DirectorySeparatorChar + "Launch" + Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar + "Debug" + Path.DirectorySeparatorChar + "result.dat";
// For loop to make n number of Networks with the given size and modularity ...
double modularity = glob.modularityMinValue;
while (modularity <= glob.modularityMaxValue)
{
String outputFile = "Result_M" + modularity;
outputPath = path[0] + "Launch" + Path.DirectorySeparatorChar + outputFile;
System.IO.Directory.CreateDirectory(outputPath);
try
{
for (int n = 1; n <= glob.numberOfGraphs; n++)
{
network = new ClusterNetwork(glob.nodes, glob.edges, glob.clusters, modularity, true);
// Restricting the modularity value upto 1 decimal place
// modularity = Math.Round(network.NewmanModularityUndirected, 1);
String memberOutputFile = outputPath + Path.DirectorySeparatorChar + "membership.dat";
System.IO.StreamWriter sw = System.IO.File.CreateText(memberOutputFile);
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, modularity);
// To move a file or folder to a new location without renaming it. We rename the files after running the Kuramoto model.
string destinationResultFile = outputPath + Path.DirectorySeparatorChar + n + "_res_N" + network.VertexCount + "_E" + network.EdgeCount + "_C" + glob.clusters + "_M" + modularity + "_K" + glob.couplingStrength + ".dat";
string destinationNetworkFile = outputPath + Path.DirectorySeparatorChar + n + "_network_N" + network.VertexCount + "_E" + network.EdgeCount + "_C" + glob.clusters + "_M" + modularity + "_K" + glob.couplingStrength + ".edges";
System.IO.File.Move(outputPath + Path.DirectorySeparatorChar + "membership.dat", outputPath + Path.DirectorySeparatorChar + n + "_mem_N" + network.VertexCount + "_E" + network.EdgeCount + "_C" + glob.clusters + "_M" + modularity + "_K" + glob.couplingStrength + ".dat");
try
{
Console.WriteLine("Moving the generated files to output directory..");
System.IO.File.Move(sourceNetworkFile, destinationNetworkFile);
}
catch (IOException e)
{
Console.WriteLine(e.Message);
}
// Run the Kuramoto model here and store the results in the output directory
NetworkColorizer colorizer = new NetworkColorizer();
// Distribution of natural frequencies
double mean_frequency = 1d;
Normal normal = new Normal(mean_frequency, mean_frequency / 5d);
sync = new Kuramoto(network,
glob.couplingStrength,
glob.couplingProb,
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 (sourceResultFile != null)
sync.WriteTimeSeries(sourceResultFile);
// Moving results of kuramoto model into output directory
System.IO.File.Move(sourceResultFile, destinationResultFile);
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
}
modularity = modularity + 0.1;
}
// End line of the program
Console.WriteLine("Program ended successfully..");
}
public static void Main()
{
List<double> results;
List<double> modularity;
string line = "";
System.IO.File.Delete(Properties.Settings.Default.ResultFile);
int Nc = Properties.Settings.Default.clusterSize;
int c = Properties.Settings.Default.clusters;
double m = Properties.Settings.Default.m * Nc * c;
// what is the maximum p_i possible for the given parameters?
// in order to yield a connected network, at least ...
double inter_thresh = 1.2d * ((c * Math.Log(c)) / 2d); // ... inter edges are required
double intra_edges = m - inter_thresh; // the maximum number of expected intra edges
// this yields a maximum value for p_i of ...
double max_pi = intra_edges / (c * Combinatorics.Combinations(Nc, 2));
// Explore parameter space for parameters p_in and bias
for (double p_in = Properties.Settings.Default.p_in_from; p_in <= max_pi; p_in += Properties.Settings.Default.p_in_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>();
// Parallely start runs for this parameter set ...
System.Threading.Tasks.Parallel.For(0, Properties.Settings.Default.runs, j =>
{
// compute the parameter p_e that will give the desired edge number
double p_e = (m - c * MathNet.Numerics.Combinatorics.Combinations(Nc, 2) * p_in) / (Combinatorics.Combinations(c * Nc, 2) - c * MathNet.Numerics.Combinatorics.Combinations(Nc, 2));
if (p_e < 0)
throw new Exception("probability out of range");
// Create the network
ClusterNetwork net = null;
do
{
if (net != null)
Console.WriteLine("Network (inter = {0}, intra = {1} not connected ... ", net.InterClusterEdges, net.IntraClusterEdges);
net = new ClusterNetwork(Properties.Settings.Default.clusters, Properties.Settings.Default.clusterSize, p_in, p_e);
}
while (!net.Connected);
Console.WriteLine("Run {0}, created cluster network for p_in={1:0.00} with modularity={2:0.00}", j, p_in, (net as ClusterNetwork).NewmanModularity);
NETGen.Dynamics.EpidemicSynchronization.EpidemicSynchronization sync = new NETGen.Dynamics.EpidemicSynchronization.EpidemicSynchronization(
net,
null,
v => {
Vertex neighbor = v.RandomNeighbor;
double r = net.NextRandomDouble();
// classify neighbors
List<Vertex> intraNeighbors = new List<Vertex>();
List<Vertex> interNeighbors = new List<Vertex>();
ClassifyNeighbors(net, v, intraNeighbors, interNeighbors);
// biasing strategy ...
if (r <= bias && interNeighbors.Count > 0)
neighbor = interNeighbors.ElementAt(net.NextRandom(interNeighbors.Count));
return neighbor;
}
);
sync.Run();
NETGen.Dynamics.EpidemicSynchronization.SyncResults res = sync.Collect();
results.Add(res.time);
modularity.Add(net.NewmanModularity);
});
line = string.Format(new CultureInfo("en-US").NumberFormat, "{0} {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 runs for p_in = {0:0.00}, bias = {1:0.00}, Average time = {2:0.000000}", p_in, bias, MathNet.Numerics.Statistics.Statistics.Mean(results.ToArray()));
}
System.IO.File.AppendAllText(Properties.Settings.Default.ResultFile, "\n");
}
Console.ReadKey();
}
/// <summary>
/// Loads a network with known module structure
/// </summary>
/// <param name='file'>
/// The name of the edgelist file with line format "source,target,source_module,target_module"
/// </param>
public static ClusterNetwork LoadNetwork(string file, bool directed = false)
{
ClusterNetwork n = new ClusterNetwork();
string[] lines = System.IO.File.ReadAllLines(file);
Dictionary <string, int> moduleMapping = new Dictionary <string, int>();
foreach (string e in lines)
{
string[] components = e.Split(',');
Vertex v = null;
Vertex w = null;
// Create vertex v and assign module
if (!n.ContainsVertex(components[0]))
{
v = n.CreateVertex(components[0]);
if (!moduleMapping.ContainsKey(components[2]))
{
moduleMapping[components[2]] = moduleMapping.Count;
}
n._clusterAssignment[v] = moduleMapping[components[2]];
if (!n._clusters.ContainsKey(n._clusterAssignment[v]))
{
n._clusters[n._clusterAssignment[v]] = new List <Vertex>();
}
n._clusters[n._clusterAssignment[v]].Add(v);
}
else
{
v = n.SearchVertex(components[0]);
}
if (!n.ContainsVertex(components[1]))
{
w = n.CreateVertex(components[1]);
if (!moduleMapping.ContainsKey(components[3]))
{
moduleMapping[components[3]] = moduleMapping.Count;
}
n._clusterAssignment[w] = moduleMapping[components[3]];
if (!n._clusters.ContainsKey(n._clusterAssignment[w]))
{
n._clusters[n._clusterAssignment[w]] = new List <Vertex>();
}
n._clusters[n._clusterAssignment[w]].Add(w);
}
else
{
w = n.SearchVertex(components[1]);
}
Edge edge = n.CreateEdge(v, w, directed?EdgeType.DirectedAB:EdgeType.Undirected);
if (n._clusterAssignment[v] != n._clusterAssignment[w])
{
n.InterClusterEdges.Add(edge);
}
else
{
n.IntraClusterEdges.Add(edge);
}
}
return(n);
}
static void Main(string[] args)
{
List<double> results;
List<double> modularity;
string line = "";
System.IO.File.Delete(Properties.Settings.Default.ResultFile);
int Nc = Properties.Settings.Default.clusterSize;
int c = Properties.Settings.Default.clusters;
double m = Properties.Settings.Default.m * Nc * c;
// what is the maximum p_i possible for the given parameters?
// in order to yield a connected network, at least ...
double inter_thresh = 1.2d * ((c * Math.Log(c)) / 2d); // ... inter edges are required
double intra_edges = m - inter_thresh; // the maximum number of expected intra edges
// this yields a maximum value for p_i of ...
double max_pi = intra_edges / (c * Combinatorics.Combinations(Nc, 2));
for (double p_in = Properties.Settings.Default.p_in_from; p_in <= max_pi; p_in += Properties.Settings.Default.p_in_step)
{
Console.WriteLine();
line = "";
for(double bias = Properties.Settings.Default.bias_from; bias <= Properties.Settings.Default.bias_to; bias += Properties.Settings.Default.bias_step)
{
SpreadingResult res;
results = new List<double>();
modularity = new List<double>();
System.Threading.Tasks.Parallel.For(0, Properties.Settings.Default.runs, j =>
{
double p_e = (m - c * MathNet.Numerics.Combinatorics.Combinations(Nc, 2) * p_in) / (Combinatorics.Combinations(c * Nc, 2) - c * MathNet.Numerics.Combinatorics.Combinations(Nc, 2));
if (p_e < 0)
throw new Exception("probability out of range");
ClusterNetwork net = null;
do
{
if (net != null)
Console.WriteLine("Network (inter = {0}, intra = {1} not connected ... ", net.InterClusterEdges, net.IntraClusterEdges);
net = new ClusterNetwork(Properties.Settings.Default.clusters, Properties.Settings.Default.clusterSize, p_in, p_e);
}
while (!net.Connected);
Console.WriteLine("Run {0}, created cluster network for p_in={1:0.00} with modularity={2:0.00}", j, p_in, (net as ClusterNetwork).NewmanModularity);
res = RunSpreading(net, bias);
results.Add(res.Iterations);
modularity.Add(res.Modularity);
});
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 p_in = {0:0.00}, bias = {1:0.00}, Average = {2:0.00}", p_in, bias, MathNet.Numerics.Statistics.Statistics.Mean(results.ToArray()));
}
System.IO.File.AppendAllText(Properties.Settings.Default.ResultFile, "\n");
}
}
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);
}
/// <summary>
/// Loads a network with known module structure
/// </summary>
/// <param name='file'>
/// The name of the edgelist file with line format "source,target,source_module,target_module"
/// </param>
public static ClusterNetwork LoadNetwork(string file, bool directed = false)
{
ClusterNetwork n = new ClusterNetwork();
string[] lines = System.IO.File.ReadAllLines(file);
Dictionary<string, int> moduleMapping = new Dictionary<string, int>();
foreach(string e in lines)
{
string[] components = e.Split(',');
Vertex v = null;
Vertex w = null;
// Create vertex v and assign module
if (!n.ContainsVertex(components[0]))
{
v = n.CreateVertex(components[0]);
if(!moduleMapping.ContainsKey(components[2]))
moduleMapping[components[2]] = moduleMapping.Count;
n._clusterAssignment[v] = moduleMapping[components[2]];
if(!n._clusters.ContainsKey(n._clusterAssignment[v]))
n._clusters[n._clusterAssignment[v]] = new List<Vertex>();
n._clusters[n._clusterAssignment[v]].Add(v);
}
else
v = n.SearchVertex(components[0]);
if (!n.ContainsVertex(components[1]))
{
w = n.CreateVertex(components[1]);
if(!moduleMapping.ContainsKey(components[3]))
moduleMapping[components[3]] = moduleMapping.Count;
n._clusterAssignment[w] = moduleMapping[components[3]];
if(!n._clusters.ContainsKey(n._clusterAssignment[w]))
n._clusters[n._clusterAssignment[w]] = new List<Vertex>();
n._clusters[n._clusterAssignment[w]].Add(w);
}
else
w = n.SearchVertex(components[1]);
Edge edge = n.CreateEdge(v, w, directed?EdgeType.DirectedAB:EdgeType.Undirected);
if(n._clusterAssignment[v]!=n._clusterAssignment[w])
n.InterClusterEdges.Add(edge);
else
n.IntraClusterEdges.Add(edge);
}
return n;
}
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.NewmanModularity;
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;
}
static void Main(string[] args)
{
double bias;
try{
// The neighbor selection bias is given as command line argument
bias1 = double.Parse(args[0]);
bias2 = double.Parse(args[1]);
}
catch(Exception)
{
Console.WriteLine("Usage: mono ./DemoSimulation.exe [initial_bias] [secondary_bias]");
return;
}
// The number of clusters (c) and the nodes within a cluster (Nc)
int c = 20;
int Nc = 20;
// The number of desired edges
int m = 6 * c * Nc;
// In order to yield a connected network, at least ...
double inter_thresh = 3d * ((c * Math.Log(c)) / 2d);
// ... edges between communities are required
// So the maximum number of edges within communities we s create is ...
double intra_edges = m - inter_thresh;
Console.WriteLine("Number of intra_edge pairs = " + c * Combinatorics.Combinations(Nc, 2));
Console.WriteLine("Number of inter_edge pairs = " + (Combinatorics.Combinations(c * Nc, 2) - (c * Combinatorics.Combinations(Nc, 2))));
// Calculate the p_i necessary to yield the desired number of intra_edges
double pi = intra_edges / (c * Combinatorics.Combinations(Nc, 2));
// From this we can compute p_e ...
double p_e = (m - c * MathNet.Numerics.Combinatorics.Combinations(Nc, 2) * pi) / (Combinatorics.Combinations(c * Nc, 2) - c * MathNet.Numerics.Combinatorics.Combinations(Nc, 2));
Console.WriteLine("Generating cluster network with p_i = {0:0.0000}, p_e = {1:0.0000}", pi, p_e);
// Create the network ...
network = new NETGen.NetworkModels.Cluster.ClusterNetwork(c, Nc, pi, p_e);
// ... and reduce it to the GCC
network.ReduceToLargestConnectedComponent();
Console.WriteLine("Created network has {0} vertices and {1} edges. Modularity = {2:0.00}", network.VertexCount, network.EdgeCount, network.NewmanModularity);
// Run the OopenGL visualization
NetworkColorizer colorizer = new NetworkColorizer();
NetworkVisualizer.Start(network, new FruchtermanReingoldLayout(15), colorizer);
currentBias = bias1;
// Setup the synchronization simulation, passing the bias strategy as a lambda expression
sync = new EpidemicSynchronization(
network,
colorizer,
v => {
Vertex neighbor = v.RandomNeighbor;
double r = network.NextRandomDouble();
// classify neighbors
List<Vertex> intraNeighbors = new List<Vertex>();
List<Vertex> interNeighbors = new List<Vertex>();
ClassifyNeighbors(network, v, intraNeighbors, interNeighbors);
neighbor = intraNeighbors.ElementAt(network.NextRandom(intraNeighbors.Count));
// biasing strategy ...
if (r <= currentBias && interNeighbors.Count > 0)
neighbor = interNeighbors.ElementAt(network.NextRandom(interNeighbors.Count));
return neighbor;
},
0.9d);
Dictionary<int, double> _groupMus = new Dictionary<int, double>();
Dictionary<int, double> _groupSigmas = new Dictionary<int, double>();
MathNet.Numerics.Distributions.Normal avgs_normal = new MathNet.Numerics.Distributions.Normal(300d, 50d);
MathNet.Numerics.Distributions.Normal devs_normal = new MathNet.Numerics.Distributions.Normal(20d, 5d);
for(int i=0; i<c; i++)
{
double groupAvg = avgs_normal.Sample();
double groupStdDev = devs_normal.Sample();
foreach(Vertex v in network.GetNodesInCluster(i))
{
sync._MuPeriods[v] = groupAvg;
sync._SigmaPeriods[v] = groupStdDev;
}
}
sync.OnStep+=new EpidemicSynchronization.StepHandler(collectLocalOrder);
// Run the simulation synchronously
sync.Run();
Console.ReadKey();
// Collect and print the results
SyncResults res = sync.Collect();
Console.WriteLine("Order {0:0.00} reached after {1} rounds", res.order, res.time);
}
public static SIRResult RunSpreading(ClusterNetwork net, double bias, double k, int delay = 0)
{
SIRResult res = new SIRResult();
Dictionary<Vertex, bool> infections = new Dictionary<Vertex, bool>();
foreach (Vertex v in net.Vertices)
infections[v] = false;
List<Vertex> infected = new List<Vertex>();
List<Vertex> active = new List<Vertex>();
Vertex seed = net.RandomVertex;
infected.Add(seed);
active.Add(seed);
int i = 0;
while (active.Count > 0)
{
foreach (Vertex v in active.ToArray())
{
// Biasing strategy
Vertex neighbor = v.RandomNeighbor;
double r = net.NextRandomDouble();
// First classify neighbors as intra- or inter-cluster neighbors
List<Vertex> intraNeighbors = new List<Vertex>();
List<Vertex> interNeighbors = new List<Vertex>();
ClassifyNeighbors(net, v, intraNeighbors, interNeighbors);
Console.Write("Local choice: {0} intra, {1} inter neighbors, ", intraNeighbors.Count, interNeighbors.Count);
// with a probability given by bias select a random inter-cluster neighbor
if (r <= bias && interNeighbors.Count > 0)
neighbor = interNeighbors.ElementAt(net.NextRandom(interNeighbors.Count));
if (net.GetClusterForNode(neighbor) == net.GetClusterForNode(v))
Console.WriteLine("intra-cluster neighbor chosen!");
else
Console.WriteLine("inter-cluster neighbor chosen!");
if (neighbor != null && !infections[neighbor])
{
infections[neighbor] = true;
infected.Add(neighbor);
active.Add(neighbor);
}
else if (neighbor != null)
if (net.NextRandomDouble() <= 1d / (double) k)
active.Remove(v);
}
if (delay > 0)
System.Threading.Thread.Sleep(delay);
i++;
}
res.Duration = i;
res.InfectedRatio = (double)infected.Count / (double)net.VertexCount;
res.Modularity = (net as ClusterNetwork).NewmanModularity;
return res;
}
