[WIP] Testing area exporting for just conductors of general shape

Author: lmdiazangulo

src/AreaExporterService.py

@@ -20,16 +20,14 @@ def addComputedArea(self, geometry:str, label:str, area:float):
         self.computedAreas['geometries'].append(geometry)
 
     def addPhysicalModelForConductors(self, mappedElements:Dict[str,str]):
-        physicalGroups = gmsh.model.getPhysicalGroups(1)
+        physicalGroups = gmsh.model.getPhysicalGroups(2)
         for physicalGroup in physicalGroups:
             entityTags = gmsh.model.getEntitiesForPhysicalGroup(*physicalGroup)
             geometryName = gmsh.model.getPhysicalName(*physicalGroup)
-            if geometryName.startswith("Conductor_"):                
-                loop = gmsh.model.geo.addCurveLoop(entityTags)
-                surface = gmsh.model.geo.addPlaneSurface([loop])
-                gmsh.model.geo.synchronize()
-                area = gmsh.model.occ.getMass(2, surface)
-                gmsh.model.occ.remove([(2, surface)])
+            if geometryName.startswith("Conductor_") and geometryName[10:].isdigit():
+                area = 0.0
+                for tag in entityTags:
+                    area += gmsh.model.occ.getMass(2, tag)
 
                 label = ''
                 for key, geometry in mappedElements.items():

test/test_AreaExporterService.py

@@ -5,10 +5,12 @@
 import gmsh
 from src.mesher import Mesher
 from src.AreaExporterService import AreaExporterService
+
+
 class testAreaExporterService(unittest.TestCase):
     @staticmethod
-    def sumAreasFromList(areas:List[float]):
-        total:float = 0
+    def sumAreasFromList(areas: List[float]):
+        total: float = 0
         for area in areas:
             total += area
         return total
@@ -23,32 +25,65 @@ def setUp(self):
 
     def tearDown(self):
         gmsh.finalize()
+
     def inputFileFromCaseName(self, caseName) -> None:
         return self.testdataPath + caseName + '/' + caseName + ".step"
 
     def testAreaExporterReturnsTrueValues(self):
         caseName = 'five_wires'
-        mappedElements = Mesher().meshFromStep(self.inputFileFromCaseName(caseName), caseName)
+        mappedElements = Mesher().meshFromStep(
+            self.inputFileFromCaseName(caseName), caseName)
         areaExporter = AreaExporterService()
-        areaExporter.addPhysicalModelForConductors(mappedElements=mappedElements)
+        areaExporter.addPhysicalModelForConductors(
+            mappedElements=mappedElements)
         geometries = areaExporter.computedAreas['geometries']
 
-        internalElements = []
-        for geometry in geometries:
-            if geometry['geometry'] == "Conductor_0":
-                totalArea = geometry['area']
-            else:
-                internalElements.append(geometry['area'])
-        areaElements = self.sumAreasFromList(internalElements)
+        expectedDict = {
+            'geometries': [
+                {
+                    'area': 28.274334,
+                    'geometry': 'Conductor_0',
+                    'label': 'Conductor_0'
+                },
+                {
+                    'area': 0.785398,
+                    'geometry': 'Conductor_5',
+                    'label': 'Conductor_1'
+                },
+                {
+                    'area': 2.010619,
+                    'geometry': 'Conductor_1',
+                    'label': 'Conductor_002'
+                },
+                {
+                    'area': 0.785398,
+                    'geometry': 'Conductor_2',
+                    'label': 'Conductor_003'
+                },
+                {
+                    'area': 0.785398,
+                    'geometry': 'Conductor_3',
+                    'label': 'Conductor_004'
+                },
+                {
+                    'area': 0.785398,
+                    'geometry': 'Conductor_4',
+                    'label': 'Conductor_005'
+                },
+            ]
+        }
 
-        self.assertAlmostEqual(totalArea, areaElements, places=5)
+        self.maxDiff = None
+        self.assertDictEqual(areaExporter.computedAreas, expectedDict)
 
     def testJsonFormat(self) -> None:
         caseName = 'DielectricUnshieldedPair'
-        mappedElements = Mesher().meshFromStep(self.inputFileFromCaseName(caseName), caseName)
+        mappedElements = Mesher().meshFromStep(
+            self.inputFileFromCaseName(caseName), caseName)
         areaExporter = AreaExporterService()
-        areaExporter.addPhysicalModelForConductors(mappedElements=mappedElements)
-        
+        areaExporter.addPhysicalModelForConductors(
+            mappedElements=mappedElements)
+
         expectedDict = {
             'geometries': [
                 {
@@ -60,7 +95,7 @@ def testJsonFormat(self) -> None:
                     'area': 201.06193,
                     'geometry': 'Conductor_0',
                     'label': 'LeftConductor'
-                }            
+                }
             ]
         }
         self.maxDiff = None