public void randomwalk(int v) { // weighted random walk RandomWalk rw = new RandomWalk(p_w); int status = rw.stay_move(); ArrayList<Integer> walkpath = new ArrayList<Integer>(); Integer u = v; walkpath.add(v); while (status == 1) // keep moving until status = 0 { u = rw.move(G, u); if (u == null) // no neighbors break; if (!walkpath.contains(u)) walkpath.add(u); status = rw.stay_move(); } // System.out.println("walking length: "+ Integer.toString(walkpath.size())); for (int i = 0; i < walkpath.size(); i++) for (int j = i + 1; j < walkpath.size(); j++) { int m = walkpath.get(i); int n = walkpath.get(j); if (!G.containsEdge(m, n)) { double distance = Math.abs(socialposition.get(m) - socialposition.get(n)); double prob = linkprob(distance, (j - i)); if (random.nextDouble() < prob) { G.setEdgeWeight((DefaultWeightedEdge) G.addEdge(m, n), 1); } } else { DefaultWeightedEdge edge = G.getEdge(m, n); G.setEdgeWeight(edge, G.getEdgeWeight(edge) + 1); } } return; }
// global attachment -- with prob 1 public void globalattach(int v) throws IOException { Integer u = random.nextInt(N); while (u == v) u = random.nextInt(N); if (!G.containsEdge(v, u)) { G.setEdgeWeight((DefaultWeightedEdge) G.addEdge(v, u), 1); } else { DefaultWeightedEdge edge = G.getEdge(v, u); G.setEdgeWeight(edge, G.getEdgeWeight(edge) + 1); } }
/** * Add edges connecting this cell and its 8 (or less) neighbors * * @param row * @param col */ private void addEdges(int row, int col) { System.out.println("Adding (" + row + ", " + col + ")"); // Add weighted edge // North if (row > 0 && g.containsVertex(cellContainer[row][col])) { g.addEdge(cellContainer[row][col], cellContainer[row - 1][col]); g.setEdgeWeight(g.getEdge(cellContainer[row][col], cellContainer[row - 1][col]), 1); // NE if (col < colCount - 1 && g.containsVertex(cellContainer[row - 1][col + 1])) { g.addEdge(cellContainer[row][col], cellContainer[row - 1][col + 1]); g.setEdgeWeight( g.getEdge(cellContainer[row][col], cellContainer[row - 1][col + 1]), Math.sqrt(2.0)); } } // East if (col < colCount - 1 && g.containsVertex(cellContainer[row][col + 1])) { g.addEdge(cellContainer[row][col], cellContainer[row][col + 1]); g.setEdgeWeight(g.getEdge(cellContainer[row][col], cellContainer[row][col + 1]), 1); // SE if (row < rowCount - 1 && g.containsVertex(cellContainer[row + 1][col + 1])) { g.addEdge(cellContainer[row][col], cellContainer[row + 1][col + 1]); g.setEdgeWeight( g.getEdge(cellContainer[row][col], cellContainer[row + 1][col + 1]), Math.sqrt(2.0)); } } // South if (row < rowCount - 1 && g.containsVertex(cellContainer[row + 1][col])) { g.addEdge(cellContainer[row][col], cellContainer[row + 1][col]); g.setEdgeWeight(g.getEdge(cellContainer[row][col], cellContainer[row + 1][col]), 1); // SW if (col > 0 && g.containsVertex(cellContainer[row + 1][col - 1])) { g.addEdge(cellContainer[row][col], cellContainer[row + 1][col - 1]); g.setEdgeWeight( g.getEdge(cellContainer[row][col], cellContainer[row + 1][col - 1]), Math.sqrt(2.0)); } } // West if (col > 0 && g.containsVertex(cellContainer[row][col - 1])) { g.addEdge(cellContainer[row][col], cellContainer[row][col - 1]); g.setEdgeWeight(g.getEdge(cellContainer[row][col], cellContainer[row][col - 1]), 1); // NW if (row > 0 && g.containsVertex(cellContainer[row - 1][col - 1])) { g.addEdge(cellContainer[row][col], cellContainer[row - 1][col - 1]); g.setEdgeWeight( g.getEdge(cellContainer[row][col], cellContainer[row - 1][col - 1]), Math.sqrt(2.0)); } } }
/** * 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); }