Changed physical model to use mapped graph

Author: adrianarce-elemwave

src/Graph.py

@@ -1,4 +1,5 @@
-from typing import List, Tuple
+from collections import defaultdict, deque
+from typing import Dict, List, Tuple
 
 class Graph:
     def __init__(self):
@@ -91,5 +92,28 @@ def dfs(node, path):
         self._nodes = list(new_nodes)
         self._edges = list(new_edges)
 
+    def getAdyacencyTree(self) -> Dict:
+        tree = defaultdict(list)
+        for root in self.roots:
+            tree[''].append(root)
+        for parent, child in self._edges:
+            tree[parent].append(child)
+        return tree
+    
+    def getNodesByLevels(self) -> List:
+        adyacencyTree = self.getAdyacencyTree()
+        qeue = deque([('',0)])
+        nodeList = []
+        while qeue:
+            node,level = qeue.popleft()
+            nodeList.append(node)
+            for child in adyacencyTree[node]:
+                qeue.append((child, level+1))
+        return nodeList[1:] #Removes case 0 that is not part of nodes
+
+    def _reorderData(self) -> None:
+        self._edges = sorted(self._edges)
+        self._nodes = sorted(self._nodes)
+
     def __str__(self):
         return f"Graph(Nodes: {self._nodes},\n Edges: {self._edges})"

src/ShapesClassification.py

@@ -15,9 +15,9 @@ class ShapesClassification:
     _ROUND_VALUE:int = 6
 
     isOpenCase:bool
-    crossSectionData: Dict
-    pecs: Dict
-    dielectrics: Dict
+    crossSectionData: Dict[str,List[Dict[str,any]]]
+    pecs: Dict[str,List[Tuple[int,int]]]
+    dielectrics: Dict[str,List[Tuple[int,int]]]
     nestedGraph: Graph
 
     def __init__(self, shapes, jsonFile:str):
@@ -29,12 +29,11 @@ def __init__(self, shapes, jsonFile:str):
         self.crossSectionData = jsonData['CrossSection']
         self.pecs = self.get_pecs(shapes)
         self.dielectrics = self.get_dielectrics(shapes)
-        self.shieldReference = dict()
         self.vacuum = dict()
+        self.open = dict()
         self.nestedGraph = self.__getNestedGraph()
         self.isOpenCase = self.isOpenProblem()
 
-
     @staticmethod
     def getNumberFromName(entity_name: str, label: str):
         ini = entity_name.rindex(label) + len(label)
@@ -72,67 +71,51 @@ def __getGeometryNamesByMaterialType(self, materialType:str) -> List[str]:
         return names
 
     def isOpenProblem(self) -> None:
-        if len(self.nestedGraph.roots) > 1:
+        roots = self.nestedGraph.roots 
+        if len(roots) > 1: #Más de un componente pec/pec pec/dielectric dielectric/dielectric etc da al exterior
+            return True
+        if roots[0] in self.dielectrics.keys(): #El único root es un dielectrico
             return True
         return False
 
     def removeConductorsFromDielectrics(self):
         for num, diel in self.dielectrics.items():
             pec_surfs = []
             for num2, pec_surf in self.pecs.items():
-                if num2 == 0 and not self.isOpenCase:
+                if (num2 in self.nestedGraph.roots) and (not self.isOpenCase):
                     continue
                 pec_surfs.extend(pec_surf)
             self.dielectrics[num] = gmsh.model.occ.cut(diel, pec_surfs, removeTool=False)[0]
 
         gmsh.model.occ.synchronize()
 
     def ensureDielectricsDoNotOverlap(self):
-        for n1, diel1 in self.dielectrics.items():
-            others = list(
-                chain(
-                    *[x[1] for x in self.dielectrics.items() if x[0] != n1]
-                )
-            )
+        for currentKey in self.dielectrics.keys():
+
+            others = list(chain(*[tag for key, tag in self.dielectrics.items() if currentKey != key]))
 
             if len(others) == 0:
                 continue
 
-            self.dielectrics[n1] = gmsh.model.occ.cut(
-                self.dielectrics[n1], others, removeObject=True, removeTool=False)[0]
+            self.dielectrics[currentKey] = gmsh.model.occ.cut(
+                self.dielectrics[currentKey], others, removeObject=True, removeTool=False
+                )[0]
 
         gmsh.model.occ.synchronize()
 
     def buildVacuumDomain(self):
-        if self.isOpenCase and len(self.open) == 0:
+        if self.isOpenCase:
             self.vacuum = self._buildDefaultVacuumDomain()
-        elif self.isOpenCase and len(self.open) > 0:
-            self.vacuum = self._buildVacuumDomainFromOpenBoundary()
         else:
             self.vacuum = self._buildClosedVacuumDomain()
         return self.vacuum
 
-    def _buildVacuumDomainFromOpenBoundary(self) -> Dict[int, List[int]]:
-        dom = self.open[0]
-        
-        surfsToRemove = []
-        for num, surf in self.pecs.items():
-            surfsToRemove.extend(surf)
-
-        for _, surf in self.dielectrics.items():
-            surfsToRemove.extend(surf)
-
-        dom = gmsh.model.occ.cut(
-            dom, surfsToRemove, removeObject=False, removeTool=False)[0]
-        gmsh.model.occ.synchronize()
-
-        return dict([[0, dom]])
-    
     def _buildClosedVacuumDomain(self) -> Tuple[int, int]:
-        dom = self.pecs[0]
+        root = self.nestedGraph.roots[0]
+        dom = self.pecs[root]
         surfsToRemove = []
         for num, surf in self.pecs.items():
-            if num == 0:
+            if num == root:
                 continue
             surfsToRemove.extend(surf)
 
@@ -141,7 +124,7 @@ def _buildClosedVacuumDomain(self) -> Tuple[int, int]:
         dom = gmsh.model.occ.cut(
             dom, surfsToRemove, removeObject=False, removeTool=False)[0]
         gmsh.model.occ.synchronize()
-        return dict([[0, dom]])
+        return dict([['Vacuum_0', dom]])
 
     def _buildDefaultVacuumDomain(self):
         NEAR_REGION_BOUNDING_BOX_SCALING_FACTOR = 1.25
@@ -170,7 +153,7 @@ def _buildDefaultVacuumDomain(self):
             farVacuumDiameter, farVacuumDiameter))]
 
         gmsh.model.occ.synchronize()
-        self.open = dict([[0, gmsh.model.getBoundary(farVacuum)]])
+        self.open = dict([['OpenBoundary_0', gmsh.model.getBoundary(farVacuum)]])
 
         farVacuum = gmsh.model.occ.cut(
             farVacuum, nearVacuum, removeObject=True, removeTool=False)[0]
@@ -189,32 +172,47 @@ def _buildDefaultVacuumDomain(self):
         innerRegion = gmsh.model.getBoundary(nearVacuum, recursive=True)
         gmsh.model.mesh.setSize(innerRegion, minSide / 20)
 
-        
-       
         gmsh.model.occ.synchronize()
 
-        return dict([[0, nearVacuum], [1, farVacuum]])
+        return dict([['Vacuum_0', nearVacuum], ['Vacuum_1', farVacuum]])
 
     def __getNestedGraph(self):
         gmsh.model.occ.synchronize()
         graph = Graph()
-        for key in self.pecs.keys():
+        elements:Dict = {}
+        elements = {**self.pecs, **self.dielectrics}
+        for key in elements:
             graph.add_node(key)
-        for i, keyA in enumerate(self.pecs.keys()):
-            for j, keyB in enumerate(self.pecs.keys()):
+        for i, keyA in enumerate(elements):
+            for j, keyB in enumerate(elements):
                 if i < j:
                     inter = gmsh.model.occ.intersect(
-                        self.pecs[keyA], 
-                        self.pecs[keyB],
+                        elements[keyA], 
+                        elements[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]:
+                        if inter[1][0] == elements[keyA]:
                             graph.add_edge(keyB, keyA)
-                        elif inter[1][0] == self.pecs[keyB]:
+                        elif inter[1][0] == elements[keyB]:
                             graph.add_edge(keyA, keyB)
         graph.prune_to_longest_paths()
-        return graph
+        graph._reorderData()
+        return graph
+    
+    def getComponentsMappedByLevel(self) -> Dict[str,str]:
+        sortedNodes = self.nestedGraph.getNodesByLevels()
+        mappedElements = []
+        conductors = []
+        dielectrics = []
+        for node in sortedNodes:
+            if node in self.pecs.keys():
+                conductors.append((node, 'Conductor_{}'.format(len(conductors))))
+            if node in self.dielectrics.keys():
+                dielectrics.append((node, 'Dielectric_{}'.format(len(dielectrics))))
+        mappedElements.extend(conductors)
+        mappedElements.extend(dielectrics)
+        return {element[0]:element[1] for element in mappedElements}

src/mesher.py

@@ -1,4 +1,5 @@
-from typing import Tuple
+import os
+from typing import List, Tuple
 import gmsh
 from pathlib import Path
 from typing import Dict
@@ -31,23 +32,23 @@ def runFromInput(self, inputFile, runGui=False):
         caseName = Path(inputFile).stem
 
         gmsh.initialize()
-        self.meshFromStep(inputFile, caseName, self.DEFAULT_MESHING_OPTIONS)
-        self.exportGeometryAreas(caseName)
+        mappedElements = self.meshFromStep(inputFile, caseName, self.DEFAULT_MESHING_OPTIONS)
+        self.exportGeometryAreas(caseName, mappedElements)
         gmsh.write(caseName + '.msh')
         gmsh.write(caseName + '.vtk') # vtk export is just for debugging. 
         if runGui:
             gmsh.fltk.run()
 
         gmsh.finalize()
 
-    def meshFromStep(self, inputFile: str, caseName: str, meshingOptions=None):
+    def meshFromStep(self, inputFile: str, caseName: str, meshingOptions=None) -> Dict[str,str]:
         if meshingOptions is None:
             meshingOptions = Mesher.DEFAULT_MESHING_OPTIONS
 
         gmsh.model.add(caseName)
         allShapes = ShapesClassification(
             gmsh.model.occ.importShapes(inputFile, highestDimOnly=False),
-            inputFile.strip('.step') + '.json'
+            os.path.splitext(inputFile)[0] +'.json'
         )
 
         # --- Geometry manipulation ---
@@ -56,33 +57,40 @@ def meshFromStep(self, inputFile: str, caseName: str, meshingOptions=None):
         vacuumDomain = allShapes.buildVacuumDomain()
         # -- Boundaries
         pecBoundaries = self.extractBoundaries(allShapes.pecs)
-
+        mappedComponents = allShapes.getComponentsMappedByLevel()
+
+        for domain in vacuumDomain.keys():
+            mappedComponents[domain] = domain
+        for openRegion in allShapes.open.keys():
+            mappedComponents[openRegion] = openRegion
+        components = {
+            **pecBoundaries,
+            **allShapes.dielectrics,
+            **allShapes.open,
+            **vacuumDomain,
+        }
+        
         self.buildPhysicalModel(
-            pecBoundaries, 
-            allShapes.dielectrics,
-            allShapes.open,
-            vacuumDomain
+            components,
+            mappedComponents
         )
 
         for [opt, val] in meshingOptions.items():
             gmsh.option.setNumber(opt, val)
 
-        # --- Mesh generation ---
-        
         gmsh.model.mesh.generate(2)
+        return mappedComponents
 
-    def exportGeometryAreas(self, caseName:str):
+
+    def exportGeometryAreas(self, caseName:str, mappedElements:Dict[str,str]):
         exporter = AreaExporterService()
-        exporter.addPhysicalModelOfDimension(dimension=2)
-        exporter.addPhysicalModelOfDimension(dimension=1)
+        exporter.addPhysicalModelOfDimension(mappedElements, dimension=2)
+        exporter.addPhysicalModelOfDimension(mappedElements, dimension=1)
         exporter.exportToJson(caseName)
 
 
-    def buildPhysicalModel(self, pecBoundaries, dielectrics, openRegion, vacuumDomain):
-        self._addPhysicalGroup("Conductor_", pecBoundaries, dimensionTag=1)
-        self._addPhysicalGroup("OpenBoundary_", openRegion, dimensionTag=1)
-        self._addPhysicalGroup("Vacuum_", vacuumDomain, dimensionTag=2)
-        self._addPhysicalGroup("Dielectric_", dielectrics, dimensionTag=2)
+    def buildPhysicalModel(self, components:Dict[str,List[Tuple[int,int]]], labeMapping:Dict[str,str]):
+        self._createPhysicalGroups(components, labeMapping)
 
         allEnts = gmsh.model.get_entities()
         entsInPG = []
@@ -96,13 +104,13 @@ def buildPhysicalModel(self, pecBoundaries, dielectrics, openRegion, vacuumDomai
         gmsh.model.occ.synchronize()
 
 
-    def _addPhysicalGroup(self, physicalGroupName:str, objsDict:Dict, dimensionTag=1):
-        for num, objs in objsDict.items():
-            name = physicalGroupName + str(num)
-            tags = [x[1] for x in objs]
-            gmsh.model.addPhysicalGroup(dimensionTag, tags, name=name)
+    def _createPhysicalGroups(self, objsDict:Dict[str,List[Tuple[int,int]]], labelMapping:Dict[str,str]):
+        for name, elements in objsDict.items():
+            mappedName = labelMapping[name]
+            dimensionTag = elements[0][0]
+            tags = [x[1] for x in elements]
+            gmsh.model.addPhysicalGroup(dimensionTag, tags, name=mappedName)
 
-
     @staticmethod
     def getPhysicalGroupWithName(name: str):
         pGs = gmsh.model.getPhysicalGroups()

test/test_ShapesClassification.py

@@ -31,7 +31,7 @@ def inputFileFromCaseName(self, caseName):
         return self.testdataPath + caseName + '/' + caseName + ".step"
 
     def initShapeClassification(self, inputFile:str) -> None:
-        jsonFile = inputFile.strip('.step') + '.json'
+        jsonFile = os.path.splitext(inputFile)[0] +'.json'
         self.shapeClassification = ShapesClassification(
             gmsh.model.occ.importShapes(inputFile, highestDimOnly=False),
             jsonFile
@@ -90,4 +90,29 @@ def testDielectricUnshieldedPairClassification(self) -> None:
         self.assertListEqual(self.shapeClassification.allShapes, expectedShapes)
         self.assertDictEqual(self.shapeClassification.pecs, expectedPecs)
         self.assertDictEqual(self.shapeClassification.dielectrics, expectedDielectrics)
-        self.assertTrue(self.shapeClassification.isOpenCase)
+        self.assertTrue(self.shapeClassification.isOpenCase)
+
+    def test_partially_filled_coax_step_shapes(self):
+        case = 'partially_filled_coax'
+        filepath = self.inputFileFromCaseName(case)
+        self.initShapeClassification(filepath)
+
+        self.assertEqual(len(self.shapeClassification.pecs), 2)
+        self.assertEqual(len(self.shapeClassification.dielectrics), 1)
+
+    def test_five_wires_step_shapes(self):
+        case = 'five_wires'
+        filepath = self.inputFileFromCaseName(case)
+        self.initShapeClassification(filepath)
+
+        self.assertEqual(len(self.shapeClassification.pecs), 6)
+        self.assertEqual(len(self.shapeClassification.dielectrics), 5)
+
+    def test_three_wires_ribbon_step_shapes(self):
+        case = 'three_wires_ribbon'
+        filepath = self.inputFileFromCaseName(case)
+        self.initShapeClassification(filepath)
+
+        self.assertEqual(len(self.shapeClassification.open), 0)
+        self.assertEqual(len(self.shapeClassification.pecs), 3)
+        self.assertEqual(len(self.shapeClassification.dielectrics), 3)

test/test_graph.py

@@ -74,6 +74,19 @@ def testPruneToLongestPaths(self) -> None:
         self.graph.prune_to_longest_paths()
         self.assertListEqual(sorted(self.graph.edges), sorted(expectedEdges))
 
+    def testGetNodesByLevel(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')
+        ]
+
+        expectedList = ['A', 'F', 'B', 'D', 'G', 'C', 'E']
+        sortedNodes = self.graph.getNodesByLevels()
+        self.assertListEqual(sortedNodes, expectedList)
+
     def testGetRoots(self) -> None:
         self.graph.nodes = ['A' ,'B', 'C', 'D', 'E', 'F', 'G']
         self.graph.edges = [