/** Generate vertices for the graph representing the floor plan */ private void generateVertices() { for (int row = 0; row < rowCount; ++row) { for (int col = 0; col < colCount; ++col) { cellContainer[row][col] = new Cell(row, col, this); g.addVertex(cellContainer[row][col]); } } }
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."); }
/** * Compute the log-probability that each observation arises for each ant. This is represented by a * simple weighted graph, where the absence of an edge represents zero probability that the given * observation was caused by the given ant. Currently the log-prob is set to be a truncated iid * Gaussian around an ant location. * * @param probabilityGraph The probability graph being constructed. * @param edgeMap A sorted map of the edges in probabilityGraph. * @param thisObservedPosMap Observed points along with index. * @param thisParticlePosMap Current particle locations. * @param obsSums * @param antSums * @return Sum of edge weights */ private double computeLogProbabilityGraph( SimpleWeightedGraph<Vertex, DefaultWeightedComparableEdge> probabilityGraph, ValueSortedMap<DefaultWeightedComparableEdge, Double> edgeMap, HashMap<Vertex, Point> thisObservedPosMap, HashMap<Vertex, AntPath> thisParticlePathMap) { /** Initialize vertices. */ edgeMap.clear(); probabilityGraph.addVertex(falseNegative); probabilityGraph.addVertex(falsePositive); for (Vertex v : thisObservedPosMap.keySet()) { probabilityGraph.addVertex(v); DefaultWeightedComparableEdge edge = probabilityGraph.addEdge(v, falsePositive); probabilityGraph.setEdgeWeight(edge, falsePositiveLogProb); edgeMap.put(edge, falsePositiveLogProb); } for (Vertex v : thisParticlePathMap.keySet()) { probabilityGraph.addVertex(v); DefaultWeightedComparableEdge edge = probabilityGraph.addEdge(v, falseNegative); probabilityGraph.setEdgeWeight(edge, falseNegativeLogProb); edgeMap.put(edge, falseNegativeLogProb); } /** Compute probability of each observation given each ant path */ for (Entry<Vertex, Point> obsEntry : thisObservedPosMap.entrySet()) { for (Entry<Vertex, AntPath> parEntry : thisParticlePathMap.entrySet()) { double logprob = observationLogProbGivenAntPath(obsEntry.getValue(), parEntry.getValue()); if (logprob > logProbThreshold) { DefaultWeightedComparableEdge edge = probabilityGraph.addEdge(obsEntry.getKey(), parEntry.getKey()); probabilityGraph.setEdgeWeight(edge, logprob); edgeMap.put(edge, logprob); } } } /** Adjust probabilities according to log-probability of an AntPath existing. */ for (Entry<Vertex, AntPath> antEntry : thisParticlePathMap.entrySet()) { Set<DefaultWeightedComparableEdge> edge = probabilityGraph.edgesOf(antEntry.getKey()); double antProb = antEntry.getValue().getCurrentLogProb(); for (DefaultWeightedComparableEdge e : edge) { double ew = probabilityGraph.getEdgeWeight(e); probabilityGraph.setEdgeWeight(e, ew + antProb); // edgeMap.remove(edge); edgeMap.put(e, ew + antProb); } } /** * ANG -- to do Interaction effects: -- probability of false negative higher when multiple ants * in same area. however, there is a high probability that there will be SOME observation in the * area. -- probability of a false positive higher when there is one ant in a region. this is * because sometimes one ant is split into two. */ /** compute vertex sums */ // Utils.computeVertexSums(probabilityGraph); double totalLogProb = Utils.maxstar(edgeMap); return totalLogProb; }
// Calculate the contribution of current vertex's shortest-path graph to final edge betweenness // (Newman algorithm) // M. E. J. Newman and M. Girvan, Finding and evaluating community structure in networks, Physical // Review E69, 026113 (2004) private SimpleWeightedGraph<String, DefaultWeightedEdge> NewmanAlgorithm( Multigraph<String, DefaultEdge> shortestPathGraph, String thisVertex) { if (shortestPathGraph.edgeSet().size() == 0) // No outer degree return null; // 1. Initialize the edge betweenness digraph SimpleWeightedGraph<String, DefaultWeightedEdge> edgeBetweennessDigraph = new SimpleWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class); // Add vertices for (String curVertex : shortestPathGraph.vertexSet()) edgeBetweennessDigraph.addVertex(curVertex); // 2. Deal with corresponding edges // 2.1. Calculate vertex distance and weight // 2.1.1. Initialize related variables HashMap<String, Integer> mapVertexDistance = new HashMap<String, Integer>(); // Vertex distance for (String curVertex : shortestPathGraph.vertexSet()) mapVertexDistance.put(curVertex, 0); HashMap<String, Double> mapVertexWeight = new HashMap<String, Double>(); // Vertex weight for (String curVertex : shortestPathGraph.vertexSet()) mapVertexWeight.put(curVertex, 1.0); Queue<String> verticesQueue = new LinkedList<String>(); // Store the queue of operated vertices // 2.1.2. Traverse the shortest-path digraph, get corresponding vertex distance and weight verticesQueue.add(thisVertex); String currentVertex = thisVertex; while (!verticesQueue.isEmpty()) { // 2.1.2.1. Read the bottom vertex in the queue, deal with all adjacent edges for (DefaultEdge curEdge : shortestPathGraph.edgesOf(currentVertex)) { String targetVertex = shortestPathGraph.getEdgeTarget(curEdge); if (mapVertexDistance.get(targetVertex) == 0) { // Target vertex value hasn't been evaluated yet mapVertexDistance.put(targetVertex, mapVertexDistance.get(currentVertex) + 1); mapVertexWeight.put(targetVertex, mapVertexWeight.get(currentVertex)); verticesQueue.add(targetVertex); } // Target vertex value has already been set to source vertex distance plus 1 else if (mapVertexDistance.get(targetVertex) == (mapVertexDistance.get(currentVertex) + 1)) mapVertexWeight.put( targetVertex, mapVertexWeight.get(targetVertex) + mapVertexWeight.get(currentVertex)); } // 2.1.2.2. All adjacent edges have been treated, remove the bottom element verticesQueue.remove(); currentVertex = verticesQueue.peek(); } // 2.2. Calculate the contribution of every edges to the edge betweenness // 2.2.1. Sort the vertices descendingly by the distance to the first vertex List<Map.Entry<String, Integer>> listVertexDistance = new ArrayList<Map.Entry<String, Integer>>(mapVertexDistance.entrySet()); Collections.sort( listVertexDistance, new Comparator<Map.Entry<String, Integer>>() { // Sorting the list descendingly @Override public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) { return (o2.getValue().compareTo(o1.getValue())); } }); // 2.2.2. Traverse the shortest-path digraph with the sorted vertices list for (Map.Entry<String, Integer> thisVertexDistance : listVertexDistance) { currentVertex = thisVertexDistance.getKey(); for (DefaultEdge curEdge : shortestPathGraph.edgesOf(currentVertex)) { // 2.2.2.1. Get the source vertex String sourceVertex = shortestPathGraph.getEdgeSource(curEdge); String targetVertex = shortestPathGraph.getEdgeTarget(curEdge); String anotherVertex = ""; if (currentVertex.equals(sourceVertex)) anotherVertex = targetVertex; else if (currentVertex.equals(targetVertex)) anotherVertex = sourceVertex; // 2.2.2.2. Calculate the value of the sum of all adjacent edges plus 1 double totalSubWeights = 1.0; for (DefaultWeightedEdge curSubEdge : edgeBetweennessDigraph.edgesOf(currentVertex)) totalSubWeights += edgeBetweennessDigraph.getEdgeWeight(curSubEdge); // 2.2.2.3. The new edge weight is calculated as totalSubWeights * (the quotient of the // weights of the two terminals) double wi = mapVertexWeight.get(anotherVertex); double wj = mapVertexWeight.get(currentVertex); totalSubWeights /= wi / wj; // 2.2.2.4. Add new edge with correct weight into the edge betweenness digraph DefaultWeightedEdge newEdge = new DefaultWeightedEdge(); edgeBetweennessDigraph.addEdge(anotherVertex, currentVertex, newEdge); edgeBetweennessDigraph.setEdgeWeight(newEdge, totalSubWeights); } } return edgeBetweennessDigraph; }
// 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; }
/** * Reads the geometry and connectivity. * * @param filename the location of the gjf file */ public GJFfile(String filename) { super(filename); // read geometry String name = ""; List<Atom> contents = new ArrayList<>(); SimpleWeightedGraph<Atom, DefaultWeightedEdge> connectivity = new SimpleWeightedGraph<>(DefaultWeightedEdge.class); int blanks = 0; boolean lastBlank = false; boolean inGeometryBlock = false; for (List<String> line : fileContents) { // keep track of how many blanks we have seen if (line.size() == 1 && line.get(0).length() == 0) { if (lastBlank == false) { blanks++; lastBlank = true; } continue; } else lastBlank = false; // read the metadata if (blanks == 1) { for (String s : line) { String[] fields = s.split("@"); if (fields.length != 3) continue; String identifier = fields[1].toLowerCase(); String value = fields[2]; // System.out.println(s); // System.out.println(identifier + " : " + value); if (identifier.equals("o1")) O1Number = Integer.parseInt(value); else if (identifier.equals("o2")) O2Number = Integer.parseInt(value); else if (identifier.equals("n3")) N3Number = Integer.parseInt(value); else if (identifier.equals("cl1")) Cl1Number = Integer.parseInt(value); else if (identifier.equals("su2")) Su2Number = Integer.parseInt(value); else if (identifier.equals("ol3")) Ol3Number = Integer.parseInt(value); else if (identifier.equals("mem")) mem = Integer.parseInt(value); else if (identifier.equals("nprocshared")) nprocshared = Integer.parseInt(value); else if (identifier.equals("method")) method = value; else if (identifier.equals("basis")) basis = value; else System.out.println("unrecognized entry: " + s); } continue; } else if (blanks != 2) continue; // deal with the charge and multiplicity card (by ignoring it) if (line.size() == 2 && inGeometryBlock == false) { inGeometryBlock = true; continue; } if (line.size() != 4 && inGeometryBlock == false) throw new IllegalArgumentException( "unexpected text in geometry block in " + filename + ":\n" + line.toString()); // create atom // tinker atom types will be nonsense, of course Atom newAtom = new Atom( line.get(0), new Vector3D( Double.parseDouble(line.get(1)), Double.parseDouble(line.get(2)), Double.parseDouble(line.get(3))), 1); contents.add(newAtom); connectivity.addVertex(newAtom); } // read connectivity blanks = 0; lastBlank = false; for (List<String> line : fileContents) { // read the fourth block of text if (line.size() == 1 && line.get(0).length() == 0) { if (lastBlank == false) { blanks++; lastBlank = true; } continue; } else lastBlank = false; // only read connectivity lines if (blanks != 3) continue; Atom fromAtom = contents.get(Integer.parseInt(line.get(0)) - 1); for (int i = 1; i < line.size(); i += 2) { int toAtomIndex = Integer.parseInt(line.get(i)) - 1; Atom toAtom = contents.get(toAtomIndex); double bondOrder = Double.parseDouble(line.get(i + 1)); DefaultWeightedEdge thisEdge = connectivity.addEdge(fromAtom, toAtom); connectivity.setEdgeWeight(thisEdge, bondOrder); } } // create the molecule molecule = new Molecule(name, contents, connectivity, 0.0); }
/** * Insert a vertex to the graph whose row and col coordinates are as given. * * @param row * @param col */ private void addVertexAt(int row, int col) { g.addVertex(cellContainer[row][col]); addEdges(row, col); }