fiqus 2024.5.2__py3-none-any.whl → 2024.6.0__py3-none-any.whl

tests/test_mesh_generators.py

@@ -49,6 +49,51 @@ class TestMeshGenerators(FiQuSMeshTests):
                 )
                 self.compare_json_or_yaml_files(regions_file, reference_regions_file)
 
+    def test_ConductorAC_Strand(self):
+        """
+        Checks if ConductorAC geometry generators work correctly by comparing the number
+        of entities in the generated geometry file to the reference file that was
+        checked manually.
+        """
+        model_names = [
+            "TEST_CAC_Strand_adaptiveMesh",
+            "TEST_CAC_Strand_hexFilaments",
+            "TEST_CAC_wireInChannel",
+        ]
+
+        for model_name in model_names:
+            with self.subTest(model_name=model_name):
+                data_model = self.get_data_model(model_name)
+
+                # data_model can be modified here if necessary
+                # Example:
+
+                # data_model.magnet.mesh.wi.axne = 30
+
+                self.generate_mesh(data_model, model_name)
+
+                # Compare the number of entities with the reference file:
+                mesh_file = self.get_path_to_generated_file(
+                    data_model=data_model, file_name=model_name, file_extension="msh"
+                )
+                reference_file = self.get_path_to_reference_file(
+                    data_model=data_model, file_name=model_name, file_extension="msh"
+                )
+                self.compare_mesh_qualities(mesh_file, reference_file)
+
+                # Compare the regions files:
+                regions_file = self.get_path_to_generated_file(
+                    data_model=data_model,
+                    file_name=model_name,
+                    file_extension="regions",
+                )
+                reference_regions_file = self.get_path_to_reference_file(
+                    data_model=data_model,
+                    file_name=model_name,
+                    file_extension="regions",
+                )
+                self.compare_json_or_yaml_files(regions_file, reference_regions_file)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_solvers.py

@@ -90,7 +90,59 @@ class TestSolvers(FiQuSSolverTests):
                         )
                         self.compare_pos_files(pos_file, reference_pos_file)
 
+    def test_ConductorAC_Strand(self):
+        """
+        Checks if ConductorAC_Strand solvers work correctly by comparing the results to the
+        reference results that were checked manually.
+        """
+        model_names = [
+            "TEST_CAC_Strand_hexFilaments",
+            "TEST_CAC_wireInChannel",
+        ]
+        for model_name in model_names:
+            with self.subTest(model_name=model_name):
+                data_model: FDM = self.get_data_model(model_name)
+
+                self.solve(data_model, model_name)
+
+                # Compare the pro files:
+                pro_file = self.get_path_to_generated_file(
+                    data_model=data_model,
+                    file_name=model_name,
+                    file_extension="pro",
+                )
+                reference_pro_file = self.get_path_to_reference_file(
+                    data_model=data_model,
+                    file_name=model_name,
+                    file_extension="pro",
+                )
+                self.compare_text_files(pro_file, reference_pro_file)
+
+                # Compare the magnetic flux density files:
+                pos_file = self.get_path_to_generated_file(
+                    data_model=data_model,
+                    file_name="b",
+                    file_extension="pos",
+                )
+                reference_pos_file = self.get_path_to_reference_file(
+                    data_model=data_model,
+                    file_name="b",
+                    file_extension="pos",
+                )
+                self.compare_pos_files(pos_file, reference_pos_file)
 
+                # Compare the current density files:
+                pos_file = self.get_path_to_generated_file(
+                    data_model=data_model,
+                    file_name="j",
+                    file_extension="pos",
+                )
+                reference_pos_file = self.get_path_to_reference_file(
+                    data_model=data_model,
+                    file_name="j",
+                    file_extension="pos",
+                )
+                self.compare_pos_files(pos_file, reference_pos_file)
 
 if __name__ == "__main__":
     unittest.main()

tests/utils/fiqus_test_classes.py

@@ -414,7 +414,7 @@ class BaseClassesForTests(unittest.TestCase):
 
         return reference_file
 
-    def compare_json_or_yaml_files(self, file_1, file_2):
+    def compare_json_or_yaml_files(self, file_1, file_2, tolerance=0):
         """
         This method compares the contents of two JSON or YAML files. It is used to
         check that the generated files are the same as the reference.
@@ -436,11 +436,47 @@ class BaseClassesForTests(unittest.TestCase):
             raise ValueError("The files must be JSON or YAML files!")
 
         # Compare the dictionaries:
-        self.assertDictEqual(
-            file_1_dictionary,
-            file_2_dictionary,
-            msg=f"{file_1} did not match {file_2}!",
-        )
+        if tolerance == 0:
+            self.assertDictEqual(
+                file_1_dictionary,
+                file_2_dictionary,
+                msg=f"{file_1} did not match {file_2}!",
+            )
+        else:
+            self.compare_dicts(file_1_dictionary, file_2_dictionary, tolerance)
+
+    def compare_dicts(self, dict1, dict2, tolerance):
+        """
+        This method compares the contents of two dictionaries, taking into account
+        floating point precision issues.
+
+        :param dict1: first dictionary to compare
+        :type dict1: dict
+        :param dict2: second dictionary to compare
+        :type dict2: dict
+        :param tolerance: tolerance for comparing floating point numbers
+        :type tolerance: float
+        """
+        for key in dict1.keys():
+            if key not in dict2:
+                self.fail(f'Key "{key}" not in both {dict1} and {dict2}')
+            if isinstance(dict1[key], dict):
+                self.compare_dicts(dict1[key], dict2[key], tolerance)
+            elif isinstance(dict1[key], float): # To handle precision errors in floats
+                if not np.isclose(dict1[key], dict2[key], atol=tolerance):
+                    self.fail(f'Values for key {key} are not close: {dict1[key]} vs {dict2[key]}')
+            elif isinstance(dict1[key], list): # To handle precision errors in lists of floats
+                if len(dict1[key]) != len(dict2[key]):
+                    self.fail(f'Lists for key {key} are not the same length')
+                for i in range(len(dict1[key])):
+                    if isinstance(dict1[key][i], float):
+                        if not np.isclose(dict1[key][i], dict2[key][i], atol=tolerance):
+                            self.fail(f'Values at index {i} for key {key} are not close: {dict1[key][i]} vs {dict2[key][i]}')
+                    elif dict1[key][i] != dict2[key][i]:
+                        self.fail(f'Values at index {i} for key {key} are not equal: {dict1[key][i]} vs {dict2[key][i]}')
+            else:
+                if dict1[key] != dict2[key]:
+                    self.fail(f'Values for key {key} are not equal: {dict1[key]} vs {dict2[key]}')
 
     def compare_pkl_files(self, file_1, file_2):
         """

tests/utils/generate_reference_files_ConductorAC.py

@@ -0,0 +1,57 @@
+import os
+import shutil
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../'))) # Add the path to the fiqus package to the system path
+from fiqus.data.DataFiQuS import FDM
+from fiqus.utils.Utils import FilesAndFolders as Util
+from fiqus import MainFiQuS as mf
+
+
+# Generate reference files for the models below:
+model_names = [
+    "TEST_CAC_Strand_adaptiveMesh",
+    "TEST_CAC_Strand_hexFilaments",
+    "TEST_CAC_wireInChannel",
+]
+# The run types for the models above:
+run_types = [
+    'geometry_and_mesh', 
+    'start_from_yaml', 
+    'start_from_yaml',
+]
+
+for model_name, run_type in zip(model_names, run_types):
+    # get path to the input file:
+    input_file = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)),
+        "_inputs",
+        model_name,
+        f"{model_name}.yaml",
+    )
+
+    # select _references folder as the output folder:
+    output_folder = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)), "_references", model_name
+    )
+
+    # if the output folder exists, remove it:
+    if os.path.exists(output_folder):
+        shutil.rmtree(output_folder)
+
+    # Create the output folder:
+    os.makedirs(output_folder)
+
+    # Cast input yaml file to FDM
+    data_model: FDM = Util.read_data_from_yaml(input_file, FDM)
+
+    data_model.run.overwrite = True
+
+    # Make the run type start_from_yaml:
+    data_model.run.type = run_type
+
+    fiqus_instance = mf.MainFiQuS(
+        fdm=data_model, model_folder=output_folder, input_file_path=input_file
+    )
+
+    # remove fiqus_instance to avoid memory issues:
+    del fiqus_instance

tests/utils/generate_reference_files_Pancake3D.py

@@ -0,0 +1,92 @@
+import os
+import shutil
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../'))) # Add the path to the fiqus package to the system path
+import fiqus.data.DataFiQuSPancake3D as Pancake3D
+from fiqus.data.DataFiQuS import FDM
+from fiqus.utils.Utils import FilesAndFolders as Util
+from fiqus import MainFiQuS as mf
+
+
+# Generate reference files for the models below:
+model_names = [
+    "TEST_Pancake3D_REF",
+    "TEST_Pancake3D_REFStructured",
+    "TEST_Pancake3D_TSA",
+    "TEST_Pancake3D_TSAStructured",
+    "TEST_Pancake3D_TSAInsulating"
+]
+
+for model_name in model_names:
+    input_file = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)),
+        "_inputs",
+        model_name,
+        f"{model_name}.yaml",
+    )
+    # select _references folder as the output folder:
+    output_folder = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)), "_references", model_name
+    )
+
+    # Cast input yaml file to FDM
+    data_model: FDM = Util.read_data_from_yaml(input_file, FDM)
+    data_model.magnet.postproc = Pancake3D.Pancake3DPostprocess()
+    data_model.run.overwrite = True
+    data_model.run.launch_gui = False
+
+    # if the output folder exists, remove it and create a new one:
+    if os.path.exists(output_folder):
+        shutil.rmtree(output_folder)
+        # Create the output folder:
+        os.makedirs(output_folder)
+
+    # Solve the same model three times with different solve types:
+    solve_types = [
+        "weaklyCoupled",
+        "stronglyCoupled",
+        "electromagnetic",
+    ]
+    for i, solve_type in enumerate(solve_types):
+        if i == 0:
+            # Make the run type start_from_yaml:
+            data_model.run.type = "start_from_yaml"
+        else:
+            # Make the run type solve_only:
+            data_model.run.type = "solve_only"
+
+        # data_model.run.type = "post_process"
+        # data_model.run.type = "solve_only"
+
+        data_model.magnet.solve.type = solve_type
+        data_model.run.solution = solve_type
+        if solve_type in ["weaklyCoupled", "stronglyCoupled"]:
+            data_model.magnet.solve.save = [
+                Pancake3D.Pancake3DSolveSaveQuantity(
+                    quantity="magneticField",
+                ),
+                Pancake3D.Pancake3DSolveSaveQuantity(
+                    quantity="currentDensity",
+                ),
+                Pancake3D.Pancake3DSolveSaveQuantity(
+                    quantity="temperature",
+                ),
+            ]
+        elif solve_type == "electromagnetic":
+            data_model.magnet.solve.save = [
+                Pancake3D.Pancake3DSolveSaveQuantity(
+                    quantity="magneticField",
+                ),
+                Pancake3D.Pancake3DSolveSaveQuantity(
+                    quantity="currentDensity",
+                ),
+            ]
+
+        fiqus_instance = mf.MainFiQuS(fdm=data_model, model_folder=output_folder)
+
+        # remove fiqus_instance to avoid memory issues:
+        del fiqus_instance
+
+        # # remove logs directory and run_log.csv inside the output folder:
+        # shutil.rmtree(os.path.join(output_folder, "logs"))
+        # os.remove(os.path.join(output_folder, "run_log.csv"))