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); }
/** * Links all the spots in the selection, in time-forward order. * * @param model the model to modify. * @param selectionModel the selection that contains the spots to link. */ public static void linkSpots(final Model model, final SelectionModel selectionModel) { /* * Configure tracker */ final TrackableObjectCollection<Spot> spots = new DefaultTOCollection<Spot>(selectionModel.getSpotSelection()); final Map<String, Object> settings = new HashMap<String, Object>(1); settings.put(KEY_LINKING_MAX_DISTANCE, Double.POSITIVE_INFINITY); final NearestNeighborTracker<Spot> tracker = new NearestNeighborTracker<Spot>(spots, settings); tracker.setNumThreads(1); /* * Execute tracking */ if (!tracker.checkInput() || !tracker.process()) { System.err.println("Problem while computing spot links: " + tracker.getErrorMessage()); return; } final SimpleWeightedGraph<Spot, DefaultWeightedEdge> graph = tracker.getResult(); /* * Copy found links in source model */ model.beginUpdate(); try { for (final DefaultWeightedEdge edge : graph.edgeSet()) { final Spot source = graph.getEdgeSource(edge); final Spot target = graph.getEdgeTarget(edge); model.addEdge(source, target, graph.getEdgeWeight(edge)); } } finally { model.endUpdate(); } }
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."); }
public EdgeBetweennessGraph(WeightedMultigraph<String, DefaultWeightedEdge> originalGraph) { super(DefaultWeightedEdge.class); // Constructor inherented from parent class // 1. Initialize the edge betweenness digraph // 1.1. Add vertices for (String thisVertex : originalGraph.vertexSet()) this.addVertex(thisVertex); // 1.2. Add edges for (DefaultWeightedEdge thisEdge : originalGraph.edgeSet()) { DefaultWeightedEdge newEdge = new DefaultWeightedEdge(); String sendingName = originalGraph.getEdgeSource(thisEdge); String receivingName = originalGraph.getEdgeTarget(thisEdge); this.addEdge(sendingName, receivingName, newEdge); this.setEdgeWeight(newEdge, 0.0); } // 1.3. Create corresponding unweighted graph // 1.3.1. Add vertices WeightedMultigraph<String, DefaultWeightedEdge> originalUnweightedGraph = new WeightedMultigraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class); for (String thisVertex : originalGraph.vertexSet()) originalUnweightedGraph.addVertex(thisVertex); // 1.3.2. Add edges for (DefaultWeightedEdge thisEdge : originalGraph.edgeSet()) { DefaultWeightedEdge newEdge = new DefaultWeightedEdge(); String sendingName = originalGraph.getEdgeSource(thisEdge); String receivingName = originalGraph.getEdgeTarget(thisEdge); originalUnweightedGraph.addEdge(sendingName, receivingName, newEdge); originalUnweightedGraph.setEdgeWeight(newEdge, 1.0); } for (String thisVertex : this.vertexSet()) { // 2. Create shortest-path graph for every vertex by Dijkstra algorithm Multigraph<String, DefaultEdge> shortestPathDigraph = DijkstraAlgorithm(originalUnweightedGraph, thisVertex); // 3. Calculate the contribution of current vertex's shortest-path graph to final edge // betweenness (Newman algorithm) SimpleWeightedGraph<String, DefaultWeightedEdge> edgeBetweennessDigraph = NewmanAlgorithm(shortestPathDigraph, thisVertex); // 4. Update final edge betweenness digraph with current vertex's shortest-path graph if (edgeBetweennessDigraph != null) for (DefaultWeightedEdge thisEdge : edgeBetweennessDigraph.edgeSet()) { String sourceVertex = edgeBetweennessDigraph.getEdgeSource(thisEdge); String targetVertex = edgeBetweennessDigraph.getEdgeTarget(thisEdge); double betweennessWeight = edgeBetweennessDigraph.getEdgeWeight(thisEdge); DefaultWeightedEdge edgeInWholeGraph = this.getEdge(sourceVertex, targetVertex); double newWeight = this.getEdgeWeight(edgeInWholeGraph) + betweennessWeight; this.setEdgeWeight(edgeInWholeGraph, newWeight); } } // 5. Revise the edge betweenness digraph with the original active power digraph for (DefaultWeightedEdge thisEdge : this.edgeSet()) { String sourceVertex = this.getEdgeSource(thisEdge); String targetVertex = this.getEdgeTarget(thisEdge); double betweennessWeight = this.getEdgeWeight(thisEdge); DefaultWeightedEdge edgeInWholeGraph = originalGraph.getEdge(sourceVertex, targetVertex); double newWeight = betweennessWeight / originalGraph.getEdgeWeight(edgeInWholeGraph); this.setEdgeWeight(thisEdge, newWeight); // System.out.println("Final edge betweenness between " + sourceVertex + " and " + // targetVertex + ": " + newWeight); } }
// 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; }