Added graph for pecs in Shape Classification

Author: adrianarce-elemwave

src/Graph.py

@@ -0,0 +1,95 @@
+from typing import List, Tuple
+
+class Graph:
+    def __init__(self):
+        self._nodes:List = []     
+        self._edges:List[Tuple] = []
+
+    @property
+    def roots(self) -> List:
+        roots:List = []
+        for node in self._nodes:
+            isChild = False
+            for edge in self._edges:
+                if edge[-1] == node:
+                    isChild = True
+                    continue
+            if isChild == False:
+                roots.append(node)
+        return roots.copy()
+    
+    @property
+    def nodes(self) -> List:
+        return self._nodes.copy()
+
+    @property
+    def edges(self) -> List:
+        return self._edges.copy()
+
+    @nodes.setter
+    def nodes(self, nodes):
+        self._nodes = list(nodes)
+
+    @edges.setter
+    def edges(self, edges):
+        self._edges = [tuple(e) for e in edges]
+
+    def add_node(self, node):
+        if node not in self._nodes:
+            self._nodes.append(node)
+
+    def add_edge(self, source, destination):
+        if source not in self._nodes:
+            self.add_node(source)
+        if destination not in self._nodes:
+            self.add_node(destination)
+        if (source, destination) not in self._edges:
+            self._edges.append((source, destination))
+
+    def get_connections(self):
+        connections = {node: [] for node in self._nodes}
+        for source, destination in self._edges:
+            connections[source].append(destination)
+        return connections
+    
+    def getParentNodes(self) -> List:
+        return [edge[0] for edge in self._edges]
+    
+    def getChildNodes(self) -> List:
+        return [edge[-1] for edge in self._edges]
+    
+    #Necesita una revisión pero por ahora hace lo que necesito
+    def prune_to_longest_paths(self):
+        connections = self.get_connections()
+        roots = [n for n in self._nodes if n not in self.getChildNodes()]
+
+        longest_paths = []
+
+        def dfs(node, path):
+            path = path + [node]
+            if node not in connections or not connections[node]:
+                longest_paths.append(path)
+                return
+            for child in connections[node]:
+                dfs(child, path)
+
+        for root in roots:
+            dfs(root, [])
+
+        leaf_to_path = {}
+        for path in longest_paths:
+            leaf = path[-1]
+            if leaf not in leaf_to_path or len(path) > len(leaf_to_path[leaf]):
+                leaf_to_path[leaf] = path
+
+        new_nodes = set()
+        new_edges = set()
+        for path in leaf_to_path.values():
+            new_nodes.update(path)
+            new_edges.update([(path[i], path[i+1]) for i in range(len(path)-1)])
+
+        self._nodes = list(new_nodes)
+        self._edges = list(new_edges)
+
+    def __str__(self):
+        return f"Graph(Nodes: {self._nodes},\n Edges: {self._edges})"

src/ShapesClassification.py

@@ -1,18 +1,24 @@
 from enum import Enum
 import json
+import math
+from time import sleep
 from typing import Any, Tuple, List, Dict
 
 import gmsh
+
+from src.Graph import Graph
 from .BoundingBox import BoundingBox
 from itertools import chain
 import numpy as np
 
 class ShapesClassification:
+    _ROUND_VALUE:int = 6
+
     isOpenCase:bool
     crossSectionData: Dict
     pecs: Dict
     dielectrics: Dict
-
+    nestedGraph: Graph
 
     def __init__(self, shapes, jsonFile:str):
         gmsh.model.occ.synchronize()
@@ -25,7 +31,7 @@ def __init__(self, shapes, jsonFile:str):
         self.dielectrics = self.get_dielectrics(shapes)
         self.shieldReference = dict()
         self.vacuum = dict()
-
+        self.nestedGraph = self.__getNestedGraph()
         self.isOpenCase = self.isOpenProblem()
 
 
@@ -35,7 +41,7 @@ def getNumberFromName(entity_name: str, label: str):
         num = int(entity_name[ini:])
         return num
 
-    def get_pecs(self, entity_tags):
+    def get_pecs(self, entity_tags) -> Dict[str, Dict[str,any]]:
         pecNames = self.__getGeometryNamesByMaterialType('PEC')
         pecs = dict()
         for s in entity_tags:
@@ -46,7 +52,7 @@ def get_pecs(self, entity_tags):
 
         return pecs
 
-    def get_dielectrics(self, entity_tags):
+    def get_dielectrics(self, entity_tags) -> Dict[str, Dict[str,any]]:
         dielectricNames = self.__getGeometryNamesByMaterialType('Dielectric')
         dielectrics = dict()
         for s in entity_tags:
@@ -64,30 +70,11 @@ def __getGeometryNamesByMaterialType(self, materialType:str) -> List[str]:
             if geometry['material']['type'] == materialType
         ]
         return names
-
-    def isOpenProblem(self):
-        elements = list(chain(self.pecs.values()))
-        isOpenCase = True
-        for idx, element in enumerate(elements):
-            intersectWithAll = True
-            intersect = []
-            for otheridx, otherElement in enumerate(elements):
-                if element != otherElement:
-                    intersect = gmsh.model.occ.intersect(
-                        element, 
-                        otherElement,
-                        removeObject=False,
-                        tag=300+otheridx,
-                        removeTool=False
-                    )[0]    
-                if len(intersect) == 0:
-                    intersectWithAll = False
-                else:
-                    isOpenCase = False
-            if intersectWithAll:
-                print(element, otherElement)
-                self.shieldReference = {list(self.pecs.keys())[idx] : element}
-        return isOpenCase
+    
+    def isOpenProblem(self) -> None:
+        if len(self.nestedGraph.roots) > 1:
+            return True
+        return False
 
     def removeConductorsFromDielectrics(self):
         for num, diel in self.dielectrics.items():
@@ -208,4 +195,26 @@ def _buildDefaultVacuumDomain(self):
 
         return dict([[0, nearVacuum], [1, farVacuum]])
 
-    
+    def __getNestedGraph(self):
+        gmsh.model.occ.synchronize()
+        graph = Graph()
+        for key in self.pecs.keys():
+            graph.add_node(key)
+        for i, keyA in enumerate(self.pecs.keys()):
+            for j, keyB in enumerate(self.pecs.keys()):
+                if i < j:
+                    inter = gmsh.model.occ.intersect(
+                        self.pecs[keyA], 
+                        self.pecs[keyB],
+                        removeObject=False,
+                        removeTool=False
+                    )
+                    if len(inter[1][0]) == 0: #comprueba las intersecciones en las que interfiere el objeto
+                        continue
+                    else:
+                        if inter[1][0] == self.pecs[keyA]:
+                            graph.add_edge(keyB, keyA)
+                        elif inter[1][0] == self.pecs[keyB]:
+                            graph.add_edge(keyA, keyB)
+        graph.prune_to_longest_paths()
+        return graph

test/test_ShapesClassification.py

@@ -1,8 +1,11 @@
+from copy import copy
 import os
+from typing import Dict, List, Tuple
 import unittest
 import gmsh
 import json
 
+
 from src.ShapesClassification import ShapesClassification
 
 
@@ -52,15 +55,21 @@ def testDielectricShieldedPairClassification(self) -> None:
             'RightDielectric': [(2,4)],
             'LeftDielectric': [(2,5)],
         }
-        expectedShieldReference = {
-            'ExternalShield': [(2,2)],
-        }
         self.assertListEqual(self.shapeClassification.allShapes, expectedShapes)
         self.assertDictEqual(self.shapeClassification.pecs, expectedPecs)
         self.assertDictEqual(self.shapeClassification.dielectrics, expectedDielectrics)
-        self.assertDictEqual(self.shapeClassification.shieldReference, expectedShieldReference)
         self.assertFalse(self.shapeClassification.isOpenCase)
 
+    def testFusedConductors(self) -> None:
+        case = 'FusedConductor'
+        filepath = self.inputFileFromCaseName(case)
+        self.initShapeClassification(filepath)
+
+    def testComplexNesting(self) -> None:
+        case = 'ComplexNesting'
+        filepath = self.inputFileFromCaseName(case)
+        self.initShapeClassification(filepath)
+
     def testDielectricUnshieldedPairClassification(self) -> None:
         case = 'DielectricUnshieldedPair'
         filepath = self.inputFileFromCaseName(case)
@@ -71,16 +80,14 @@ def testDielectricUnshieldedPairClassification(self) -> None:
             (0, 1),(0, 1),(0, 2),(0, 2),(0, 3),(0, 3),(0, 4),(0, 4),
         ]
         expectedPecs = {
-            'RightConductor': [(2,1)],
-            'LeftConductor': [(2,2)],
+            'LeftConductor': [(2, 2)],
+            'RightConductor': [(2, 1)],
         }
         expectedDielectrics = {
             'RightDielectric': [(2,3)],
             'LeftDielectric': [(2,4)],
         }
-        expectedShieldReference = {}
         self.assertListEqual(self.shapeClassification.allShapes, expectedShapes)
         self.assertDictEqual(self.shapeClassification.pecs, expectedPecs)
         self.assertDictEqual(self.shapeClassification.dielectrics, expectedDielectrics)
-        self.assertDictEqual(self.shapeClassification.shieldReference, expectedShieldReference)
         self.assertTrue(self.shapeClassification.isOpenCase)

test/test_graph.py

@@ -0,0 +1,88 @@
+import unittest
+
+from src.Graph import Graph
+
+class TestGraph(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.graph = Graph()
+
+    def tearDown(self):
+        del self.graph
+
+    def test_addNode(self) -> None:
+        self.graph.add_node('A')
+        self.assertIn('A', self.graph.nodes)
+
+        self.graph.add_node('A')
+        self.assertEqual(self.graph.nodes.count('A'), 1)
+
+    def test_addEdge(self) -> None:
+        self.graph.add_edge('A', 'B')
+        self.assertIn(('A', 'B'), self.graph.edges)
+
+        self.assertIn('A', self.graph.nodes)
+        self.assertIn('B', self.graph.nodes)
+
+        self.graph.add_edge('A', 'B')
+        self.assertEqual(self.graph.edges.count(('A', 'B')), 1)
+
+    def test_settersAndGetters(self) -> None:
+        nodes = ['X', 'Y']
+        edges = [('X', 'Y')]
+        self.graph.nodes = nodes
+        self.graph.edges = edges
+        self.assertEqual(self.graph.nodes, nodes)
+        self.assertEqual(self.graph.edges, edges)
+
+    def test_GetConnections(self) -> None:
+        self.graph.add_edge('A', 'B')
+        self.graph.add_edge('A', 'C')
+        self.graph.add_node('D')  # no connections
+        connections = self.graph.get_connections()
+        expected = {
+            'A': ['B', 'C'],
+            'B': [],
+            'C': [],
+            'D': []
+        }
+        self.assertEqual(connections, expected)
+
+    def test_str(self) -> None:
+        self.graph.add_edge('A', 'B')
+        s = str(self.graph)
+        self.assertIn('A', s)
+        self.assertIn('B', s)
+        self.assertIn('Edges', s)
+
+    def testPruneToLongestPaths(self) -> None:
+        self.graph.nodes = ['A' ,'B', 'C', 'D', 'E', 'F', 'G']
+        self.graph.edges = [
+            ('A', 'B'), ('A', 'C'), ('A', 'D'), ('A', 'E'),
+            ('B', 'C'), ('B', 'E'),
+            ('C', 'E'),
+            ('F', 'G')
+        ]
+
+        expectedEdges = [
+            ('A', 'B'), ('A', 'D'),
+            ('B', 'C'),
+            ('C', 'E'),
+            ('F', 'G')
+        ]
+
+        self.graph.prune_to_longest_paths()
+        self.assertListEqual(sorted(self.graph.edges), sorted(expectedEdges))
+
+    def testGetRoots(self) -> None:
+        self.graph.nodes = ['A' ,'B', 'C', 'D', 'E', 'F', 'G']
+        self.graph.edges = [
+            ('A', 'B'), ('A', 'D'),
+            ('B', 'C'),
+            ('C', 'E'),
+            ('F', 'G')
+        ]
+        self.assertListEqual(self.graph.roots, ['A', 'F'])
+
+if __name__ == '__main__':
+    unittest.main()