// select a node according to degrees
public Integer SelectNode_PA() throws IOException {
HashMap<Integer, Double> node_degree = new HashMap<Integer, Double>();
for (int n : G.vertexSet()) {
node_degree.put(n, (double) G.degreeOf(n));
}
RandomProb rp = new RandomProb<Integer>();
Integer selected_node = (Integer) (rp.randomPro(node_degree));
return selected_node;
}
public AIWorld(World gameWorld) {
synchronized (gameWorld) {
movementGraph = GraphGenerator.generateGraph(gameWorld);
}
logger.info(
"Initialized graph with "
+ movementGraph.edgeSet().size()
+ " edges and "
+ movementGraph.vertexSet().size()
+ " vertices");
world = new World(new Vector2(), true);
PhysicsHelper.createLoaderBodies(
world, Gdx.files.internal("data/world/world.json"), "strategicPoints");
strategicPoints = GraphGenerator.generateStrategicPoints(world);
logger.info("Loaded ai world and found " + strategicPoints.size() + " strategic points");
createGraphVisible();
EventManager.addListener(EventEnum.PARSER_AI_GRAPH_VISIBLE, this);
}
/** @return the largest connected component of the graph. */
public ArrayList<Cell> getLargestConnectedComponent() {
ArrayList<ArrayList<Cell>> components = new ArrayList<>();
boolean visited[][] = new boolean[rowCount][colCount];
for (int row = 0; row < rowCount; ++row)
for (int col = 0; col < colCount; ++col) visited[row][col] = false;
Queue<Cell> q;
Cell t = null, u = null;
for (Cell c : g.vertexSet()) {
if (!visited[c.getRow()][c.getCol()]) {
q = new LinkedList<Cell>();
ArrayList<Cell> component = new ArrayList<>();
visited[c.getRow()][c.getCol()] = true;
// Find all connected nodes
q.add(c);
component.add(c);
while (!q.isEmpty()) {
t = q.remove();
for (WeightedEdge e : g.edgesOf(t)) {
u = t.equals(g.getEdgeSource(e)) ? g.getEdgeTarget(e) : g.getEdgeSource(e);
if (!visited[u.getRow()][u.getCol()]) {
visited[u.getRow()][u.getCol()] = true;
q.add(u);
component.add(u);
}
}
}
components.add(component);
}
}
int largestSize = 0, largestIndex = 0;
for (int i = 0; i < components.size(); ++i) {
if (components.get(i).size() > largestSize) {
largestSize = components.get(i).size();
largestIndex = i;
}
}
filterGraph(components.get(largestIndex));
return components.get(largestIndex);
}
private void createGraphVisible() {
if (graphVisibleBodies == null) graphVisibleBodies = new ArrayList<Body>();
for (int i = 0; i < graphVisibleBodies.size(); i++)
world.destroyBody(graphVisibleBodies.get(i));
graphVisibleBodies.clear();
if (nodesVisible)
for (Vector2 node : movementGraph.vertexSet())
PhysicsHelper.createCircle(world, BodyType.StaticBody, .1f, 1, FactionType.NEUTRAL)
.setTransform(node, 0);
if (edgesVisible)
for (DefaultWeightedEdge edge : movementGraph.edgeSet()) {
Vector2 source = movementGraph.getEdgeSource(edge),
target = movementGraph.getEdgeTarget(edge);
PhysicsHelper.createEdge(
world,
BodyType.StaticBody,
source.x,
source.y,
target.x,
target.y,
1,
FactionType.NEUTRAL);
}
}
public static void main(String[] args) throws IOException {
System.out.println("Enter parameters: N p_w p_r steps:");
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String paras[] = reader.readLine().split(" ");
N = Integer.parseInt(paras[0]);
p_w = Float.parseFloat(paras[1]);
p_r = Float.parseFloat(paras[2]);
steps = Integer.parseInt(paras[3]);
} catch (IOException e) {
System.out.println("Error reading from user");
}
long start = System.currentTimeMillis();
int simulations = 1;
for (int t = 1; t <= simulations; t++) {
// Initialization, generate an empty network of N nodes
EIM dynamic = new EIM();
G = new SimpleWeightedGraph<Integer, DefaultWeightedEdge>(DefaultWeightedEdge.class);
for (int i = 0; i < N; i++) G.addVertex(i);
String para = "EIM_" + Integer.toString(t);
String folder = "files/" + "Networks" + "/";
File f = new File(folder);
if (f.exists() == false) {
f.mkdirs();
}
// distribution of social space
socialposition = dynamic.uniform(N);
for (int s = 0; s < steps; s++) {
int v = random.nextInt(N);
// LA process - weighted random walk + link with social distance
dynamic.localattach(v);
// GA process
// no edges, create one random link
if (G.edgesOf(v).size() == 0) {
dynamic.globalattach(v);
} else {
float prob = random.nextFloat();
if (prob < p_r) dynamic.globalattach(v);
}
// ND process
int d = random.nextInt(N);
if (G.edgesOf(d).size() > 0) {
float prob = random.nextFloat();
if (prob < p_d) {
Set<DefaultWeightedEdge> edges = new HashSet(G.edgesOf(d));
G.removeAllEdges(edges);
}
}
if (s % 100000 == 0) {
System.out.print("Steps:" + Integer.toString(s) + " ");
System.out.print("Edges:");
System.out.print(G.edgeSet().size() + " ");
System.out.println(
"Avg_degree: "
+ Float.toString((float) G.edgeSet().size() * 2 / G.vertexSet().size()));
}
}
// delete isolate nodes
ArrayList<Integer> nodelist = new ArrayList<Integer>();
for (int node : G.vertexSet()) nodelist.add(node);
for (int node : nodelist) {
if (G.degreeOf(node) == 0) G.removeVertex(node);
}
System.out.print("Nodes:");
System.out.println(G.vertexSet().size());
System.out.print("Edges:");
System.out.println(G.edgeSet().size());
// get largest connected component
Statistics stat = new Statistics();
Graph G_LCC = stat.largestConnectedComponent(G);
ExportGraph export = new ExportGraph();
export.exportWPairs((SimpleWeightedGraph<Integer, DefaultWeightedEdge>) G_LCC, para, folder);
System.out.print("Nodes in LCC:");
System.out.println(G_LCC.vertexSet().size());
System.out.print("Edges in LCC:");
System.out.println(G_LCC.edgeSet().size());
System.out.println("Avg_degree: " + Double.toString(stat.avg_degree(G_LCC)));
System.out.println("Avg_clustering: " + Double.toString(stat.avg_clustering(G_LCC)));
System.out.println(
"Degree assortativity: " + Double.toString(stat.assortativityCoefficient(G_LCC)));
}
long elapsedTimeMillis = System.currentTimeMillis() - start;
float elapsedTimeHour = elapsedTimeMillis / (60 * 60 * 1000F);
System.out.print("Elapsed time: ");
System.out.print(elapsedTimeHour);
System.out.println(" hours.");
}
// Create shortest-path graph for every vertex by depth-first traversal algorithm
private Multigraph<String, DefaultEdge> DijkstraAlgorithm(
WeightedMultigraph<String, DefaultWeightedEdge> originalGraph, String thisVertex) {
// 1. Simplify the multi-graph of the active power flow into a simple graph
SimpleWeightedGraph<String, DefaultWeightedEdge> originalSimpleGraph =
new SimpleWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class);
for (String curVertex : originalGraph.vertexSet()) originalSimpleGraph.addVertex(curVertex);
for (DefaultWeightedEdge curEdge : originalGraph.edgeSet()) {
String sourceVertex = originalGraph.getEdgeSource(curEdge);
String targetVertex = originalGraph.getEdgeTarget(curEdge);
if (originalSimpleGraph.containsEdge(sourceVertex, targetVertex)) {
DefaultWeightedEdge modifiedEdge = originalSimpleGraph.getEdge(sourceVertex, targetVertex);
double newEdgeWeight =
originalSimpleGraph.getEdgeWeight(modifiedEdge) + originalGraph.getEdgeWeight(curEdge);
originalSimpleGraph.setEdgeWeight(modifiedEdge, newEdgeWeight);
} else {
DefaultWeightedEdge newEdge = new DefaultWeightedEdge();
originalSimpleGraph.addEdge(sourceVertex, targetVertex, newEdge);
originalSimpleGraph.setEdgeWeight(newEdge, originalGraph.getEdgeWeight(curEdge));
}
}
// Issue (2010/10/25): Maybe larger amount of active power transfer still means weaker
// relationship between the two terminal buses of a certain branch,
// thus originalSimpleGraph other than inverseGraph should be used here.
// Use the inverse of active power to build a new weighted directed graph (the larger the active
// power is, the close the two buses will be)
// SimpleDirectedWeightedGraph<String, DefaultWeightedEdge> inverseGraph =
// new SimpleDirectedWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class);
// for (String curVertex : originalSimpleGraph.vertexSet())
// inverseGraph.addVertex(curVertex);
// for (DefaultWeightedEdge curEdge : originalSimpleGraph.edgeSet()) {
// String sourceVertex = originalSimpleGraph.getEdgeSource(curEdge);
// String targetVertex = originalSimpleGraph.getEdgeTarget(curEdge);
// DefaultWeightedEdge newEdge = new DefaultWeightedEdge();
// inverseGraph.addEdge(sourceVertex, targetVertex, newEdge);
// inverseGraph.setEdgeWeight(newEdge, 1 / originalSimpleGraph.getEdgeWeight(curEdge));
// }
// 2. Initialize the map of vertices and the corresponding weights (distance from current vertex
// to the first vertex)
HashMap<String, Double> mapVertexShortestDistance = new HashMap<String, Double>();
// for (String thisOriginalVertex : inverseGraph.vertexSet())
for (String thisOriginalVertex : originalSimpleGraph.vertexSet())
mapVertexShortestDistance.put(thisOriginalVertex, 10E10);
// The weight of the first vertex is zero
mapVertexShortestDistance.put(thisVertex, 0.0);
// 3. Depth-first traversing, update the shortest-path values
Stack<String> bfiVertices =
new Stack<String>(); // Stack to store passed vertices in a breadth-first traversing
// The map of a weighted edge and the flag of having been visited
// HashMap<DefaultWeightedEdge, Boolean> mapEdgeVisited = new HashMap<DefaultWeightedEdge,
// Boolean>();
// for (DefaultWeightedEdge thisEdge : inverseGraph.edgeSet())
// mapEdgeVisited.put(thisEdge, false);
String currentVertex = thisVertex;
bfiVertices.push(currentVertex);
// System.out.println(bfiVertices.toString());
while (!bfiVertices.isEmpty()) {
// Operate the following codes for those edges started with current vertex
boolean hasNewEdge = false;
// for (DefaultWeightedEdge curEdge : inverseGraph.outgoingEdgesOf(currentVertex)) {
for (DefaultWeightedEdge curEdge : originalSimpleGraph.edgesOf(currentVertex)) {
// if (!mapEdgeVisited.get(curEdge)) { // Used for those edges that have not been treated
// yet
// 3.1. Mark current edge as already been visited
// mapEdgeVisited.put(curEdge, true);
// String nextVertex = inverseGraph.getEdgeTarget(curEdge);
String nextVertex = originalSimpleGraph.getEdgeTarget(curEdge);
// 3.2. Update shortest-path values
double curSD = mapVertexShortestDistance.get(currentVertex);
// double edgeWeight = inverseGraph.getEdgeWeight(curEdge);
double edgeWeight = originalSimpleGraph.getEdgeWeight(curEdge);
double newSD = curSD + edgeWeight;
if (mapVertexShortestDistance.get(nextVertex) > newSD) {
hasNewEdge = true;
mapVertexShortestDistance.put(nextVertex, newSD);
// 3.3. Push the target vertex of current edge into the stack
bfiVertices.push(nextVertex);
// System.out.println(bfiVertices.toString());
break;
// System.out.println("New shortest path [" + nextVertex + "]: " + newSD);
}
// }
}
if (!hasNewEdge) {
bfiVertices.pop();
}
if (!bfiVertices.isEmpty()) currentVertex = bfiVertices.peek();
}
// 4. Create shortest-path digraph of current vertex
// 4.1. Initialize the shortest-path digraph
Multigraph<String, DefaultEdge> shortestPathGraph =
new Multigraph<String, DefaultEdge>(DefaultEdge.class);
// 4.2. Add all qualified edges
// for (DefaultWeightedEdge curEdge : inverseGraph.edgeSet()) {
for (DefaultWeightedEdge curEdge : originalSimpleGraph.edgeSet()) {
// 4.2.1. Evaluate if current edge is suitable
// String sourceVertex = inverseGraph.getEdgeSource(curEdge);
// String targetVertex = inverseGraph.getEdgeTarget(curEdge);
String sourceVertex = originalSimpleGraph.getEdgeSource(curEdge);
String targetVertex = originalSimpleGraph.getEdgeTarget(curEdge);
// if (Math.abs(inverseGraph.getEdgeWeight(curEdge) -
if (originalSimpleGraph.getEdgeWeight(curEdge) > 1.0E-5) {
if (Math.abs(
originalSimpleGraph.getEdgeWeight(curEdge)
- (mapVertexShortestDistance.get(targetVertex)
- mapVertexShortestDistance.get(sourceVertex)))
< 1.0E-5) {
// 4.2.2. Add suitable edge that found just now
DefaultEdge newEdge = new DefaultEdge();
if (!shortestPathGraph.containsVertex(sourceVertex))
shortestPathGraph.addVertex(sourceVertex);
if (!shortestPathGraph.containsVertex(targetVertex))
shortestPathGraph.addVertex(targetVertex);
shortestPathGraph.addEdge(sourceVertex, targetVertex, newEdge);
}
}
}
return shortestPathGraph;
}
