private static Map<Group, Integer> getGroupParallelisms(DirectedGraph<Node, IndexedEdge> graph, GraphGrouper grouper, Collection<Group> groups) { UndirectedGraph<Group, Object> equivs = new Pseudograph<>(Object.class); for(Group g: groups) { equivs.addVertex(g); Group parentGroup = grouper.nodeGroup(parent); if(parentGroup!=null && !parentGroup.equals(g)) { equivs.addEdge(parentGroup, g);
public static UndirectedGraph<Node, DefaultLink> asDefaultGraph(UndirectedGraph<Node, LabeledLink> graph) { if (graph == null) { logger.debug("graph is null."); return null; } UndirectedGraph<Node, DefaultLink> g = new WeightedMultigraph<>(DefaultLink.class); for (Node v : graph.vertexSet()) g.addVertex(v); for (DefaultLink e: graph.edgeSet()) g.addEdge(e.getSource(), e.getTarget(), e); return g; }
graph.addVertex(bus); if (bus1 != bus2 && !graph.containsEdge(bus1, bus2)) { graph.addEdge(bus1, bus2); for (Object e : new ArrayList<>(graph.edgeSet())) { PossibleTopology.Bus bus1 = graph.getEdgeSource(e); PossibleTopology.Bus bus2 = graph.getEdgeTarget(e); graph.removeEdge(e); for (Object e : graph.edgeSet()) { PossibleTopology.Bus bus1 = graph.getEdgeSource(e); PossibleTopology.Bus bus2 = graph.getEdgeTarget(e); uniqueTopo.getSwitches().add(new UniqueTopology.Switch(substationId + "_" + i++, bus1, bus2));
public DistanceGraph(ConnectionData data, Hierarchy hierarchy) { // this.data = data; this.hierarchy = hierarchy; allMethods = data.getAllMethods(); g = new SimpleGraph<MethodDescription, DefaultEdge>(DefaultEdge.class); Set<Tuple> connections = data.getConnections(); for (Tuple tuple : connections) { MethodDescription start = tuple.getStart(); MethodDescription end = tuple.getEnd(); if (!start.equals(end)) { if (!g.containsVertex(start)) { g.addVertex(start); } if (!g.containsVertex(end)) { g.addVertex(end); } g.addEdge(start, end); } } }
public void addProcessModelElement(ProcessModelElement processModelElement, ControlFlowOutputPort<?> statePort) { processModelElementGraph.addVertex(processModelElement); Set<ControlFlowOutputPort<?>> statesInvolved = getStatesInvolved(processModelElement); Set<ControlFlowInputPort<?>> inputs = processModelElement.getInputs(); for (ProcessModelElement otherProcessModelElement : processModelElementGraph.vertexSet()) { if (processModelElement != otherProcessModelElement) { Set<ControlFlowOutputPort<?>> otherStatesInvolved = getStatesInvolved(otherProcessModelElement); Set<ControlFlowOutputPort<?>> stateIntersection = new LinkedHashSet<ControlFlowOutputPort<?>>(statesInvolved); stateIntersection.retainAll(otherStatesInvolved); boolean stateCouplingExists = stateIntersection.size() > 0; Set<ControlFlowInputPort<?>> otherInputs = otherProcessModelElement.getInputs(); Set<ControlFlowInputPort<?>> inputIntersection = new LinkedHashSet<ControlFlowInputPort<?>>(inputs); inputIntersection.retainAll(otherInputs); boolean inputCouplingExists = inputIntersection.size() > 0; if (stateCouplingExists || inputCouplingExists) { ProcessModelGraphEdge edge = new ProcessModelGraphEdge(stateIntersection, inputIntersection); processModelElementGraph.addEdge(processModelElement, otherProcessModelElement, edge); } } } }
private void addEdgeBetweenSameGeographicalSpotNodes(UcteNetwork network, UndirectedGraph<UcteNodeCode, Object> graph) { // ...nodes with same geographical spot Multimap<String, UcteNode> nodesByGeographicalSpot = Multimaps.index(network.getNodes(), node -> node.getCode().getUcteCountryCode() + node.getCode().getGeographicalSpot()); for (Map.Entry<String, Collection<UcteNode>> entry : nodesByGeographicalSpot.asMap().entrySet()) { for (UcteNode n1 : entry.getValue()) { for (UcteNode n2 : entry.getValue()) { if (n1 != n2) { graph.addEdge(n1.getCode(), n2.getCode()); } } } } }
private UndirectedGraph<UcteNodeCode, Object> createSubstationGraph(UcteNetwork network) { UndirectedGraph<UcteNodeCode, Object> graph = new Pseudograph<>(Object.class); for (UcteNode node : network.getNodes()) { graph.addVertex(node.getCode()); } // in the same substation... addEdgeBetweenSameGeographicalSpotNodes(network, graph); addEdgeBetweenTransformers(network, graph); addEdgeForCouplerOrLowImpedanceLine(network, graph); return graph; }
public static DirectedGraph<Node, DefaultLink> asDirectedGraph(UndirectedGraph<Node, DefaultLink> undirectedGraph) { if (undirectedGraph == null) { logger.debug("graph is null."); return null; } DirectedGraph<Node, DefaultLink> g = new DirectedWeightedMultigraph<>(DefaultLink.class); for (Node v : undirectedGraph.vertexSet()) g.addVertex(v); for (DefaultLink e: undirectedGraph.edgeSet()) g.addEdge(e.getSource(), e.getTarget(), e); return g; }
tracksUpdated.clear(); final Set< Spot > vertexSet = lGraph.vertexSet(); if ( vertexSet.size() > 0 )
/** * Get the neighbors of a given node. * The category graph is treated as an undirected graph. * @param node the reference node. * @return The set of category nodes that are neighbors of this category. */ protected Set<Integer> getNeighbors(int node) { Set<Integer> neighbors = new HashSet<Integer>(); Set<DefaultEdge> edges = undirectedGraph.edgesOf(node); for (DefaultEdge edge : edges) { if (undirectedGraph.getEdgeSource(edge) != node) { neighbors.add(undirectedGraph.getEdgeSource(edge)); } if (undirectedGraph.getEdgeTarget(edge) != node) { neighbors.add(undirectedGraph.getEdgeTarget(edge)); } } return neighbors; }
/** * Returns the outdegree (or degree for undirected graphs) of the given * node. Used in Strahler. * * @param node The node. * @return The outdegree (or degree for undirected graphs) of the given * node. */ // public int outdegree(V node) { if (graph instanceof DirectedGraph) { return ((DirectedGraph) graph).outDegreeOf(node); } else if (graph instanceof UndirectedGraph) { return ((UndirectedGraph) graph).degreeOf(node); } return -1; } }
if (undirectedGraph.containsEdge(innerNode, outerNode)) { numberOfConnections++;
do { DefaultLink e = g5.edgesOf(source).toArray(new DefaultLink[0])[0]; target = this.graph.getEdgeTarget(e);
for (PossibleTopology.Bus bus : substation.getBuses()) { for (PossibleTopology.Equipment equipment : bus.getEquipments()) { graph.addVertex(new Vertex(equipment.getId(), substation.getId(), possibleTopology.getTopoHash())); while (it.hasNext()) { PossibleTopology.Equipment next = it.next(); graph.addEdge(new Vertex(first.getId(), substation.getId(), possibleTopology.getTopoHash()), new Vertex(next.getId(), substation.getId(), possibleTopology.getTopoHash())); Vertex v1 = new Vertex(branchId, substationId1, topoId); Vertex v2 = new Vertex(branchId, substationId2, topoId); if (graph.containsVertex(v1) && graph.containsVertex(v2)) { graph.addEdge(v1, v2); Vertex v1 = new Vertex(branchId, substationId1, topoId1); Vertex v2 = new Vertex(branchId, substationId2, topoId2); if (graph.containsVertex(v1) && graph.containsVertex(v2)) { graph.addEdge(v1, v2);
private void addEdgeForCouplerOrLowImpedanceLine(UcteNetwork network, UndirectedGraph<UcteNodeCode, Object> graph) { // ...nodes connected by a coupler or by a low impedance line for (UcteLine l : network.getLines()) { UcteNodeCode nodeCode1 = l.getId().getNodeCode1(); UcteNodeCode nodeCode2 = l.getId().getNodeCode2(); if (l.getStatus() == UcteElementStatus.BUSBAR_COUPLER_IN_OPERATION || l.getStatus() == UcteElementStatus.BUSBAR_COUPLER_OUT_OF_OPERATION) { graph.addEdge(nodeCode1, nodeCode2); } else { double z = Math.hypot(l.getResistance(), l.getReactance()); if (z < lineMinZ) { graph.addEdge(nodeCode1, nodeCode2); } } } }
tracksUpdated.clear(); final Set< Spot > vertexSet = lGraph.vertexSet(); if ( vertexSet.size() > 0 )
/** * Craete a toy graph based on String objects. * * @return a graph based on String objects. */ private static UndirectedGraph<String, DefaultEdge> createStringGraph() { UndirectedGraph<String, DefaultEdge> g = new SimpleGraph<String, DefaultEdge>(DefaultEdge.class); String v1 = "v1"; String v2 = "v2"; String v3 = "v3"; String v4 = "v4"; // add the vertices g.addVertex(v1); g.addVertex(v2); g.addVertex(v3); g.addVertex(v4); // add edges to create a circuit g.addEdge(v1, v2); g.addEdge(v2, v3); g.addEdge(v3, v4); g.addEdge(v4, v1); return g; } }
private void addEdgeBetweenTransformers(UcteNetwork network, UndirectedGraph<UcteNodeCode, Object> graph) { // ...nodes connected by a transformer for (UcteTransformer tfo : network.getTransformers()) { UcteNodeCode nodeCode1 = tfo.getId().getNodeCode1(); UcteNodeCode nodeCode2 = tfo.getId().getNodeCode2(); graph.addEdge(nodeCode1, nodeCode2); } }