describe the solver and mesher output data

Author: otvam

pypeec/run/mesher.py

@@ -197,16 +197,16 @@ def _run_finalize(n, d, c, domain_def, reference, data_geometry):
 
     # assemble the data
     data_geom = {
-        "n": n,
-        "d": d,
-        "s": s,
-        "c": c,
-        "voxel_status": voxel_status,
-        "pts_cloud": pts_cloud,
-        "domain_def": domain_def,
-        "graph_def": graph_def,
-        "connect_def": connect_def,
-        "reference": reference,
+        "d": d,  # tuple with the size of a single voxel
+        "n": n,  # tuple with the number of voxels composing structure
+        "s": s,  # tuple with the total size of the structure
+        "c": c,  # tuple with the center of the voxel structure
+        "voxel_status": voxel_status,  # dict with a summary of the voxel structure
+        "pts_cloud": pts_cloud,  # array with coordinates of the point cloud
+        "domain_def": domain_def,  # dict with the indices of the different domains
+        "graph_def": graph_def,  # list with the indices of the connected components
+        "connect_def": connect_def,  # dict describing the connected/adjacent domains
+        "reference": reference,  # dict with the faces and points of the original geometry
     }
 
     return data_geom

pypeec/run/solver.py

@@ -445,7 +445,7 @@ def _run_solver_sweep(data_solver, data_internal, data_param, sol_init):
         del fct_conv
 
         # compute convergence
-        has_converged = solver_ok and condition_ok
+        solution_ok = solver_ok and condition_ok
 
     # extract the solution
     with LOGGER.BlockTimer("extract_solution"):
@@ -572,17 +572,17 @@ def _run_solver_sweep(data_solver, data_internal, data_param, sol_init):
 
     # assign the results (will be merged in the solver output)
     data_sweep = {
-        "freq": freq,
-        "has_converged": has_converged,
-        "solver_ok": solver_ok,
-        "condition_ok": condition_ok,
-        "solver_status": solver_status,
-        "condition_status": condition_status,
-        "solver_convergence": solver_convergence,
-        "integral_total": integral_total,
-        "material_losses": material_losses,
-        "source_values": source_values,
-        "field_values": field_values,
+        "freq": freq,  # frequency of the solution
+        "solution_ok": solution_ok,  # boolean describing if the solution is good
+        "solver_ok": solver_ok,  # boolean describing if the iterative solver has converged
+        "condition_ok": condition_ok,  # boolean indicating if the equation system condition is good
+        "solver_status": solver_status,  # dict describing the iterative solver status
+        "condition_status": condition_status,  # dict describing the equation system condition
+        "solver_convergence": solver_convergence,  # dict with the solver convergence and residuum
+        "integral_total": integral_total,  # integral of the losses, energy, and power
+        "material_losses": material_losses,  # dict with the losses in the different materials
+        "source_values": source_values,  # dict with the terminal current, voltage, and power
+        "field_values": field_values,  # dict with the field variables
     }
 
     return data_sweep, sol
@@ -610,7 +610,7 @@ def _get_data(data_init, data_sweep, timestamp):
     # get status
     status = True
     for data_sweep_tmp in data_sweep.values():
-        status = status and data_sweep_tmp["has_converged"]
+        status = status and data_sweep_tmp["solution_ok"]
         status = status and data_sweep_tmp["solver_ok"]
         status = status and data_sweep_tmp["condition_ok"]
 

tests/code/test_generate.py

@@ -33,14 +33,14 @@ def _get_solver(data_sweep):
 
     # extract the data
     freq = data_sweep["freq"]
-    has_converged = data_sweep["has_converged"]
+    solution_ok = data_sweep["solution_ok"]
     P_total = data_sweep["integral_total"]["P_total"]
     W_total = data_sweep["integral_total"]["W_total"]
 
     # assemble results
     solver = {
         "freq": float(freq),
-        "has_converged": bool(has_converged),
+        "solution_ok": bool(solution_ok),
         "P_total": float(P_total),
         "W_total": float(W_total),
     }

tests/code/test_workflow.py

@@ -46,21 +46,21 @@ def _check_solver(self, solver, solver_ref, test_tol):
 
         # get the results
         freq_ref = solver_ref["freq"]
-        has_converged_ref = solver_ref["has_converged"]
+        solution_ok_ref = solver_ref["solution_ok"]
         P_total_ref = solver_ref["P_total"]
         W_total_ref = solver_ref["W_total"]
 
         # extract the solution
         freq = solver["freq"]
-        has_converged = solver["has_converged"]
+        solution_ok = solver["solution_ok"]
         P_total = solver["P_total"]
         W_total = solver["W_total"]
 
         # check solution
-        self.assertEqual(has_converged, has_converged_ref, msg="invalid convergence")
-        self.assertAlmostEqual(freq, freq_ref, delta=test_tol * freq_ref, msg="invalid frequency")
-        self.assertAlmostEqual(P_total, P_total_ref, delta=test_tol * P_total_ref, msg="invalid losses")
-        self.assertAlmostEqual(W_total, W_total_ref, delta=test_tol * W_total_ref, msg="invalid energy")
+        self.assertEqual(solution_ok, solution_ok_ref, msg="invalid solution status")
+        self.assertAlmostEqual(freq, freq_ref, delta=test_tol * freq_ref, msg="invalid frequency value")
+        self.assertAlmostEqual(P_total, P_total_ref, delta=test_tol * P_total_ref, msg="invalid loss value")
+        self.assertAlmostEqual(W_total, W_total_ref, delta=test_tol * W_total_ref, msg="invalid energy value")
 
     def _check_results(self, mesher, solver, mesher_ref, solver_ref, test_tol):
         """

tests/data/examples_png/gerber.json

@@ -10,7 +10,7 @@
     "solver": {
         "sim_default": {
             "freq": 1000000.0,
-            "has_converged": true,
+            "solution_ok": true,
             "P_total": 2.7868281646041186,
             "W_total": 1.9441629983823946e-07
         }

tests/data/examples_png/inductor_gap.json

@@ -10,7 +10,7 @@
     "solver": {
         "sim_default": {
             "freq": 0.0,
-            "has_converged": true,
+            "solution_ok": true,
             "P_total": 11.906591688172142,
             "W_total": 0.02042818007465582
         }

tests/data/examples_png/inductor_pot.json

@@ -10,7 +10,7 @@
     "solver": {
         "sim_default": {
             "freq": 0.0,
-            "has_converged": true,
+            "solution_ok": true,
             "P_total": 1.8095736575936958e-05,
             "W_total": 2.506167432430112e-08
         }

tests/data/examples_png/inductor_spiral.json

@@ -10,7 +10,7 @@
     "solver": {
         "sim_default": {
             "freq": 1000000.0,
-            "has_converged": true,
+            "solution_ok": true,
             "P_total": 1.1188705178196872,
             "W_total": 3.2557855644348145e-07
         }

tests/data/examples_png/iron_core.json

@@ -10,7 +10,7 @@
     "solver": {
         "sim_default": {
             "freq": 1000.0,
-            "has_converged": true,
+            "solution_ok": true,
             "P_total": 0.00014636971137275102,
             "W_total": 1.717903297278407e-08
         }

tests/data/examples_png/shield.json

@@ -10,7 +10,7 @@
     "solver": {
         "sim_default": {
             "freq": 0.0,
-            "has_converged": true,
+            "solution_ok": true,
             "P_total": 0.00037190323170274784,
             "W_total": 7.91342652253322e-09
         }