fiqus 2026.1.0__py3-none-any.whl → 2026.1.2__py3-none-any.whl

tests/utils/fiqus_test_classes.py

@@ -4,13 +4,15 @@ import filecmp
 import gmsh
 import logging
 import shutil
-from typing import Union, Tuple, Literal
+from typing import Union, Tuple, Literal, List
 import ruamel.yaml
 import numpy as np
+import csv
 
 from fiqus.data.DataFiQuS import FDM
 from fiqus.MainFiQuS import MainFiQuS
 from fiqus.utils.Utils import GmshUtils
+from fiqus.parsers.ParserCOND import ParserCOND
 from fiqus.parsers.ParserMSH import ParserMSH
 from fiqus.utils.Utils import FilesAndFolders as FFs
 
@@ -80,21 +82,21 @@ class BaseClassesForTests(unittest.TestCase):
         return fdm
 
     def run_fiqus(
-        self,
-        data_model: FDM,
-        model_name: str,
-        run_type: Literal[
-            "start_from_yaml",
-            "mesh_only",
-            "geometry_only",
-            "geometry_and_mesh",
-            "pre_process_only",
-            "mesh_and_solve_with_post_process_python",
-            "solve_with_post_process_python",
-            "solve_only",
-            "post_process_getdp_only",
-            "post_process_python_only",
-        ],
+            self,
+            data_model: FDM,
+            model_name: str,
+            run_type: Literal[
+                "start_from_yaml",
+                "mesh_only",
+                "geometry_only",
+                "geometry_and_mesh",
+                "pre_process_only",
+                "mesh_and_solve_with_post_process_python",
+                "solve_with_post_process_python",
+                "solve_only",
+                "post_process_getdp_only",
+                "post_process_python_only",
+            ],
     ) -> None:
         """
         This method runs FiQuS with the given model name and run type.
@@ -128,32 +130,59 @@ class BaseClassesForTests(unittest.TestCase):
         model_folder = os.path.join(self.outputs_folder, f"{model_name}_{run_type}")
         FFs.prep_folder(model_folder)
 
+        reference_geometry_folder = self.get_path_to_specific_reference_folder(
+            data_model, model_name, folder="Geometry"
+        )
+        reference_mesh_folder = self.get_path_to_specific_reference_folder(
+            data_model, model_name, folder="Mesh"
+        )
+        reference_solution_folder = self.get_path_to_specific_reference_folder(
+            data_model, model_name, folder="Solution"
+        )
+
+        output_geometry_folder = self.get_path_to_specific_output_folder(
+            data_model, model_name, run_type=run_type, folder="Geometry"
+        )
+        output_mesh_folder = self.get_path_to_specific_output_folder(
+            data_model, model_name, run_type=run_type, folder="Mesh"
+        )
+        output_solution_folder = self.get_path_to_specific_output_folder(
+            data_model, model_name, run_type=run_type, folder="Solution"
+        )
+
         # Depending on the run_type, copy the reference files to the model folder:
-        if run_type in ["geometry_only", "geometry_and_mesh", "start_from_yaml"]:
-            pass
-        else:
-            # Copy the reference geometry and mesh folders to the model folder:
-            reference_geometry_folder = self.get_path_to_specific_reference_folder(
-                data_model, model_name, folder="Geometry"
+        if run_type in ["geometry_only"]:
+            pass  # do not copy anything
+        elif run_type in ["mesh_only", 'mesh_and_solve_with_post_process_python']:
+            shutil.copytree(
+                reference_geometry_folder, output_geometry_folder, dirs_exist_ok=True,
+                ignore=shutil.ignore_patterns('Mesh*')
             )
-            reference_mesh_folder = self.get_path_to_specific_reference_folder(
-                data_model, model_name, folder="Mesh"
+        elif run_type in ["solve_only", "solve_with_post_process_python"]:
+            shutil.copytree(
+                reference_geometry_folder, output_geometry_folder, dirs_exist_ok=True,
+                ignore=shutil.ignore_patterns('Mesh*')
             )
-
-            output_geometry_folder = self.get_path_to_specific_output_folder(
-                data_model, model_name, run_type=run_type, folder="Geometry"
+            shutil.copytree(
+                reference_mesh_folder, output_mesh_folder, dirs_exist_ok=True,
+                ignore=shutil.ignore_patterns('Solution*')
             )
-            output_mesh_folder = self.get_path_to_specific_output_folder(
-                data_model, model_name, run_type=run_type, folder="Mesh"
+        elif run_type in ['post_process_python_only', 'post_process_getdp_only']:
+            shutil.copytree(
+                reference_geometry_folder, output_geometry_folder, dirs_exist_ok=True,
+                ignore=shutil.ignore_patterns('Mesh*')
             )
-
             shutil.copytree(
-                reference_geometry_folder, output_geometry_folder, dirs_exist_ok=True, ignore=shutil.ignore_patterns('Mesh*')
+                reference_mesh_folder, output_mesh_folder, dirs_exist_ok=True,
+                ignore=shutil.ignore_patterns('Solution*')
             )
             shutil.copytree(
-                reference_mesh_folder, output_mesh_folder, dirs_exist_ok=True, ignore=shutil.ignore_patterns('Solution*')
+                reference_solution_folder, output_solution_folder, dirs_exist_ok=True, ignore=None
+            )
+        else:  # "geometry_and_mesh", "start_from_yaml"
+            raise ValueError(
+                f"The test can not be run at the moment with run type set to {run_type}"
             )
-
         # Run FiQuS:
         if hasattr(self, "getdp_path"):
             MainFiQuS(
@@ -172,23 +201,24 @@ class BaseClassesForTests(unittest.TestCase):
             )
 
     def get_path_to_generated_file(
-        self,
-        data_model: FDM,
-        model_name: str,
-        file_name: str,
-        file_extension: str,
-        run_type: Literal[
-            "start_from_yaml",
-            "mesh_only",
-            "geometry_only",
-            "geometry_and_mesh",
-            "pre_process_only",
-            "mesh_and_solve_with_post_process_python",
-            "solve_with_post_process_python",
-            "solve_only",
-            "post_process_getdp_only",
-            "post_process_python_only",
-        ],
+            self,
+            data_model: FDM,
+            model_name: str,
+            file_name: str,
+            file_extension: str,
+            run_type: Literal[
+                "start_from_yaml",
+                "mesh_only",
+                "geometry_only",
+                "geometry_and_mesh",
+                "pre_process_only",
+                "mesh_and_solve_with_post_process_python",
+                "solve_with_post_process_python",
+                "solve_only",
+                "post_process_getdp_only",
+                "post_process_python_only",
+            ],
+            subfolder=None
     ) -> Union[str, os.PathLike]:
         """
         This method returns the path to the generated file with the given extension
@@ -200,6 +230,8 @@ class BaseClassesForTests(unittest.TestCase):
         :type file_name: str
         :param file_extension: file extension of the generated file
         :type file_extension: str
+        :param subfolder: additional folder inside specified 'folder'
+        :type subfolder: str
         :param run_type: run type to run FiQuS with
         :type run_type: Literal[
                 "start_from_yaml",
@@ -222,20 +254,29 @@ class BaseClassesForTests(unittest.TestCase):
             folder = "Mesh"
         elif run_type == "solve_only":
             folder = "Solution"
+        elif run_type == "solve_with_post_process_python":
+            folder = "Solution"
+        elif run_type == "post_process_python_only":
+            folder = "Solution"
         else:
             raise ValueError(
-                "The run type must be geometry_only, mesh_only, or solve_only!"
+                "The run type must be geometry_only, mesh_only, solve_only, solve_with_post_process_python, post_process_python_only!"
             )
 
         sections_folder = self.get_path_to_specific_output_folder(
             data_model, model_name, run_type, folder
         )
 
-        generated_file = os.path.join(
-            sections_folder,
-            f"{file_name}.{file_extension}",
-        )
-
+        if subfolder:
+            generated_file = os.path.join(
+                sections_folder, subfolder,
+                f"{file_name}.{file_extension}",
+            )
+        else:
+            generated_file = os.path.join(
+                sections_folder,
+                f"{file_name}.{file_extension}",
+            )
         # Check if the file exists:
         if not os.path.isfile(generated_file):
             raise FileNotFoundError(
@@ -245,14 +286,14 @@ class BaseClassesForTests(unittest.TestCase):
         return generated_file
 
     def get_path_to_specific_reference_folder(
-        self,
-        data_model: FDM,
-        model_name: str,
-        folder: Literal[
-            "Geometry",
-            "Mesh",
-            "Solution",
-        ],
+            self,
+            data_model: FDM,
+            model_name: str,
+            folder: Literal[
+                "Geometry",
+                "Mesh",
+                "Solution",
+            ],
     ):
         """
         This method returns the path to a specific reference folder (Geometry, Mesh, or
@@ -295,26 +336,26 @@ class BaseClassesForTests(unittest.TestCase):
         return reference_folder
 
     def get_path_to_specific_output_folder(
-        self,
-        data_model: FDM,
-        model_name: str,
-        run_type: Literal[
-            "start_from_yaml",
-            "mesh_only",
-            "geometry_only",
-            "geometry_and_mesh",
-            "pre_process_only",
-            "mesh_and_solve_with_post_process_python",
-            "solve_with_post_process_python",
-            "solve_only",
-            "post_process_getdp_only",
-            "post_process_python_only",
-        ],
-        folder: Literal[
-            "Geometry",
-            "Mesh",
-            "Solution",
-        ],
+            self,
+            data_model: FDM,
+            model_name: str,
+            run_type: Literal[
+                "start_from_yaml",
+                "mesh_only",
+                "geometry_only",
+                "geometry_and_mesh",
+                "pre_process_only",
+                "mesh_and_solve_with_post_process_python",
+                "solve_with_post_process_python",
+                "solve_only",
+                "post_process_getdp_only",
+                "post_process_python_only",
+            ],
+            folder: Literal[
+                "Geometry",
+                "Mesh",
+                "Solution",
+            ],
     ):
         """
         This method returns a specific path (Geometry, Mesh, or Solution) to the output
@@ -377,16 +418,17 @@ class BaseClassesForTests(unittest.TestCase):
         return output_folder
 
     def get_path_to_reference_file(
-        self,
-        data_model: FDM,
-        model_name: str,
-        file_name: str,
-        file_extension: str,
-        folder: Literal[
-            "Geometry",
-            "Mesh",
-            "Solution",
-        ],
+            self,
+            data_model: FDM,
+            model_name: str,
+            file_name: str,
+            file_extension: str,
+            folder: Literal[
+                "Geometry",
+                "Mesh",
+                "Solution",
+            ],
+            subfolder=None
     ) -> Union[str, os.PathLike]:
         """
         This method returns the path to the reference file with the given extension
@@ -404,26 +446,32 @@ class BaseClassesForTests(unittest.TestCase):
                 "Mesh",
                 "Solution",
             ]
+        :param subfolder: additional folder inside specified 'folder'
+        :type subfolder: str
         :return: path to the reference file
         :rtype: Union[str, os.PathLike]
         """
         reference_folder = self.get_path_to_specific_reference_folder(
             data_model, model_name, folder=folder
         )
-        reference_file = os.path.join(
-            reference_folder,
-            f"{file_name}.{file_extension}",
-        )
+        if subfolder:
+            reference_file = os.path.join(
+                reference_folder, subfolder,
+                f"{file_name}.{file_extension}", )
+        else:
+            reference_file = os.path.join(
+                reference_folder,
+                f"{file_name}.{file_extension}", )
 
         # Check if the file exists:
         if not os.path.isfile(reference_file):
             raise FileNotFoundError(
-                f"Could not find the reference file: {file_name}.{file_extension}!"
+                f"Could not find the reference file: {reference_file}!"
             )
 
         return reference_file
 
-    def compare_json_or_yaml_files(self, file_1, file_2, tolerance=0,excluded_keys=None):
+    def compare_json_or_yaml_files(self, file_1, file_2, tolerance=0, excluded_keys=None):
         """
         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.
@@ -463,6 +511,33 @@ class BaseClassesForTests(unittest.TestCase):
         else:
             self.compare_dicts(file_1_dictionary, file_2_dictionary, tolerance)
 
+    def compare_conductor_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.
+
+        :param file_1: path to the first file
+        :type file_1: Union[str, os.PathLike]
+        :param file_2: path to the second file
+        :type file_2: Union[str, os.PathLike]
+        :param tolerance: tolerance for numeric differences (default is 0)
+        :type tolerance: float
+        """
+        print('Comparing:')
+        print(f'Output file: {file_1}')
+        print(f'Reference file: {file_2}')
+        file_1_dictionary = ParserCOND().read_cond(file_1)
+        file_2_dictionary = ParserCOND().read_cond(file_2)
+
+        # Compare the dictionaries:
+        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 _remove_excluded_keys(self, data, excluded_keys):
         """
@@ -501,20 +576,27 @@ class BaseClassesForTests(unittest.TestCase):
                 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
+            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
+            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]}')
+                            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]}')
+                        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]:
+                if dict1[key] == dict2[key]:
+                    pass
+                elif isinstance(dict1[key], str):  # To handle precision errors in floats
+                    if not np.isclose(float(dict1[key]), float(dict2[key]), atol=tolerance):
+                        self.fail(f'Values for key {key} are not close: {float(dict1[key])} vs {float(dict2[key])}')
+                else:
                     self.fail(f'Values for key {key} are not equal: {dict1[key]} vs {dict2[key]}')
 
     def compare_pkl_files(self, file_1, file_2):
@@ -532,8 +614,9 @@ class BaseClassesForTests(unittest.TestCase):
             filecmp.cmp(file_1, file_2),
             msg=f"{file_1} did not match {file_2}!",
         )
-    
-    def filter_content(self, file_path, keywords, n):
+
+    @staticmethod
+    def filter_content(file_path, keywords, n):
         """
         Read a file and return its content as a string,
         excluding lines containing any of the specified keywords.
@@ -547,22 +630,53 @@ class BaseClassesForTests(unittest.TestCase):
             # Filter remaining lines
             return ''.join(line for line in f if not any(keyword in line for keyword in keywords))
 
-
     def compare_text_files(self, file_1, file_2, exclude_lines_keywords: list = None, exclude_first_n_lines: int = 0):
         """
-        This method compares the contents of two files. It is used to check that the
-        generated files are the same as the reference.
+        This method compares the contents of two files, normalizing the text to ignore
+        whitespaces and line skips. It is used to check that the generated files are the
+        same as the reference.
 
         :param file_1: path to the first file
         :type file_1: Union[str, os.PathLike]
         :param file_2: path to the second file
         :type file_2: Union[str, os.PathLike]
+        :param exclude_lines_keywords: List of keywords to exclude lines containing them.
+        :type exclude_lines_keywords: list
+        :param exclude_first_n_lines: Number of lines to exclude from the top.
+        :type exclude_first_n_lines: int
         """
-        if exclude_lines_keywords: 
-            # more complicated check that needs to loop through the lines
-            filtered_content1 = self.filter_content(file_1, exclude_lines_keywords, exclude_first_n_lines)
-            filtered_content2 = self.filter_content(file_2, exclude_lines_keywords, exclude_first_n_lines)
-            self.assertTrue(filtered_content1 == filtered_content2)
+        print(f'Comparing: {file_1} with {file_2}')
+        if exclude_lines_keywords:
+            # Normalize the content of both files
+            normalized_content_1 = self._normalize_file_content(file_1, exclude_lines_keywords, exclude_first_n_lines)
+            normalized_content_2 = self._normalize_file_content(file_2, exclude_lines_keywords, exclude_first_n_lines)
+
+            # Split the normalized content into lines
+            lines1 = normalized_content_1.splitlines()
+            lines2 = normalized_content_2.splitlines()
+
+            # Compare line by line and collect differences
+            differences = []
+            max_lines = max(len(lines1), len(lines2))
+            for i in range(max_lines):
+                line1 = lines1[i] if i < len(lines1) else "<No Line>"
+                line2 = lines2[i] if i < len(lines2) else "<No Line>"
+                if line1 != line2:
+                    differences.append(
+                        f"Line {i + 1}:\n  File 1: {line1[:100]}\n  File 2: {line2[:100]}"
+                    )
+                    break
+
+            # If there are differences, include them in the assertion message
+            if differences:
+                diff_message = "\n".join(differences)
+                self.assertEqual(
+                    normalized_content_1,
+                    normalized_content_2,
+                    msg=f"{file_1} did not match {file_2}!\nDifferences:\n{diff_message[0:100]}"
+                )
+            else:
+                print("Files match!")
         else:
             # Compare the files with a binary check
             self.assertTrue(
@@ -570,12 +684,91 @@ class BaseClassesForTests(unittest.TestCase):
                 msg=f"{file_1} did not match {file_2}!",
             )
 
+    def _normalize_file_content(self, file_path, exclude_lines_keywords, exclude_first_n_lines):
+        """
+        Normalize the content of a file by:
+        - Removing extra spaces and tabs
+        - Ignoring line breaks
+        - Excluding lines with specific keywords
+        - Skipping the first n lines
+
+        :param file_path: Path to the file to normalize
+        :type file_path: Union[str, os.PathLike]
+        :param exclude_lines_keywords: List of keywords to exclude lines containing them.
+        :type exclude_lines_keywords: list
+        :param exclude_first_n_lines: Number of lines to exclude from the top.
+        :type exclude_first_n_lines: int
+        :return: Normalized content as a single string
+        :rtype: str
+        """
+        with open(file_path, 'r', encoding='utf-8') as f:
+            # Skip the first n lines
+            lines = f.readlines()[exclude_first_n_lines:]
+
+        # Filter out lines containing any of the specified keywords
+        if exclude_lines_keywords:
+            lines = [line for line in lines if not any(keyword in line for keyword in exclude_lines_keywords)]
+
+        # Normalize the lines by removing extra spaces and joining them into a single string
+        normalized_content = ''.join(' '.join(line.split()) for line in lines)
+        return normalized_content
+
+    def compare_csv_files(self, file_1: Union[str, os.PathLike], file_2: Union[str, os.PathLike],
+                          exclude_lines_keywords: List[str] = None, exclude_first_n_lines: int = 0,
+                          tolerance: float = 0.0):
+        """
+        Compare two CSV files while allowing for numerical differences within a specified tolerance.
+
+        :param file_1: Path to the first CSV file.
+        :param file_2: Path to the second CSV file.
+        :param exclude_lines_keywords: List of keywords; lines containing these will be excluded.
+        :param exclude_first_n_lines: Number of lines to exclude from the top.
+        :param tolerance: Acceptable numerical difference between corresponding values.
+        """
+        print(f'Comparing: {file_1} with {file_2}')
+
+        # Read and filter files
+        filtered_content1 = self._filter_csv_content(file_1, exclude_lines_keywords, exclude_first_n_lines)
+        filtered_content2 = self._filter_csv_content(file_2, exclude_lines_keywords, exclude_first_n_lines)
+
+        # Check that the number of lines match
+        self.assertEqual(len(filtered_content1), len(filtered_content2),
+                         msg=f"File lengths do not match: {len(filtered_content1)} vs {len(filtered_content2)}")
+
+        for row1, row2 in zip(filtered_content1, filtered_content2):
+            self.assertEqual(len(row1), len(row2), msg=f"Row lengths do not match: {row1} vs {row2}")
+            for val1, val2 in zip(row1, row2):
+                if self._is_number(val1) and self._is_number(val2):
+                    if np.isnan(float(val1)) and np.isnan(float(val2)):
+                        continue  # Consider NaN values as equal
+                    self.assertTrue(np.isclose(float(val1), float(val2), atol=tolerance),
+                                    msg=f"Values {val1} and {val2} differ beyond tolerance {tolerance} for file {file_1} and {file_2}")
+                else:
+                    self.assertEqual(val1, val2, msg=f"String values do not match: {val1} vs {val2}")
+
+    def _filter_csv_content(self, file_path, exclude_lines_keywords, exclude_first_n_lines):
+        """Helper method to read CSV file and filter lines based on keywords and line numbers."""
+        with open(file_path, newline='', encoding='utf-8') as f:
+            reader = csv.reader(f)
+            content = [row for i, row in enumerate(reader)
+                       if i >= exclude_first_n_lines and
+                       (not exclude_lines_keywords or not any(kw in ','.join(row) for kw in exclude_lines_keywords))]
+        return content
+
+    def _is_number(self, value):
+        """Helper method to check if a value is a number."""
+        try:
+            float(value)
+            return True
+        except ValueError:
+            return False
+
 
 class FiQuSGeometryTests(BaseClassesForTests):
     def generate_geometry(
-        self,
-        data_model: FDM,
-        model_name: str,
+            self,
+            data_model: FDM,
+            model_name: str,
     ) -> Tuple[Union[str, os.PathLike], Union[str, os.PathLike]]:
         """
         This method generates the geometry for the given model name.
@@ -591,9 +784,9 @@ class FiQuSGeometryTests(BaseClassesForTests):
         self.model_name = model_name
 
     def compare_number_of_entities(
-        self,
-        geometry_file_1: Union[str, os.PathLike],
-        geometry_file_2: Union[str, os.PathLike],
+            self,
+            geometry_file_1: Union[str, os.PathLike],
+            geometry_file_2: Union[str, os.PathLike],
     ):
         """
         This method compares the number of entities for each dimension in two geometry
@@ -630,29 +823,29 @@ class FiQuSGeometryTests(BaseClassesForTests):
             )
 
     def get_path_to_generated_file(
-        self, data_model: FDM, file_name: str, file_extension: str
+            self, data_model: FDM, model_name: str, file_extension: str
     ) -> Union[str, os.PathLike]:
         return super().get_path_to_generated_file(
             data_model,
             self.model_name,
-            file_name,
+            model_name,
             file_extension,
             run_type="geometry_only",
         )
 
     def get_path_to_reference_file(
-        self, data_model: FDM, file_name: str, file_extension: str
+            self, data_model: FDM, model_name: str, file_extension: str
     ) -> Union[str, os.PathLike]:
         return super().get_path_to_reference_file(
-            data_model, self.model_name, file_name, file_extension, folder="Geometry"
+            data_model, self.model_name, model_name, file_extension, folder="Geometry"
         )
 
 
 class FiQuSMeshTests(BaseClassesForTests):
     def generate_mesh(
-        self,
-        data_model: FDM,
-        model_name: str,
+            self,
+            data_model: FDM,
+            model_name: str,
     ) -> Tuple[Union[str, os.PathLike], Union[str, os.PathLike]]:
         """
         This method generates the mesh for the given model name.
@@ -666,7 +859,7 @@ class FiQuSMeshTests(BaseClassesForTests):
         self.model_name = model_name
 
     def compare_mesh_qualities(
-        self, mesh_file_1: Union[str, os.PathLike], mesh_file_2: Union[str, os.PathLike]
+            self, mesh_file_1: Union[str, os.PathLike], mesh_file_2: Union[str, os.PathLike]
     ):
         """
         This method compares the mesh qualities of two mesh files. It is used to check
@@ -697,25 +890,26 @@ class FiQuSMeshTests(BaseClassesForTests):
         )
 
     def get_path_to_generated_file(
-        self, data_model, file_name: str, file_extension: str
+            self, data_model, model_name: str, file_extension: str
     ) -> Union[str, os.PathLike]:
         return super().get_path_to_generated_file(
-            data_model, self.model_name, file_name, file_extension, run_type="mesh_only"
+            data_model, self.model_name, model_name, file_extension, run_type="mesh_only"
         )
 
     def get_path_to_reference_file(
-        self, data_model, file_name: str, file_extension: str
+            self, data_model, model_name: str, file_extension: str
     ) -> Union[str, os.PathLike]:
         return super().get_path_to_reference_file(
-            data_model, self.model_name, file_name, file_extension, folder="Mesh"
+            data_model, self.model_name, model_name, file_extension, folder="Mesh"
         )
 
 
 class FiQuSSolverTests(BaseClassesForTests):
     def solve(
-        self,
-        data_model: FDM,
-        model_name: str,
+            self,
+            data_model: FDM,
+            model_name: str,
+            run_type: str = "solve_only"
     ) -> Tuple[Union[str, os.PathLike], Union[str, os.PathLike]]:
         """
         This method solves the given model name.
@@ -725,11 +919,12 @@ class FiQuSSolverTests(BaseClassesForTests):
         :param model_name: name of the model to generate the mesh for
         :type model_name: str
         """
-        self.run_fiqus(data_model, model_name, "solve_only")
+        self.run_fiqus(data_model, model_name, run_type)
         self.model_name = model_name
 
     def compare_pos_files(
-        self, pos_file_1: Union[str, os.PathLike], pos_file_2: Union[str, os.PathLike], rel_tolerance: float = 1e-10, abs_tolerance: float = 0
+            self, pos_file_1: Union[str, os.PathLike], pos_file_2: Union[str, os.PathLike],
+            rel_tolerance: float = 1e-10, abs_tolerance: float = 0.0, n_top_values_only: int = 0
     ):
         """
         This method compares the contents of two pos files. It is used to check that
@@ -739,6 +934,12 @@ class FiQuSSolverTests(BaseClassesForTests):
         :type pos_file_1: Union[str, os.PathLike]
         :param pos_file_2: path to the second pos file
         :type pos_file_2: Union[str, os.PathLike]
+        :param rel_tolerance: relative tolerance
+        :type rel_tolerance: float
+        :param abs_tolerance: absolute tolerance
+        :type abs_tolerance: float
+        :param n_top_values_only: if > 0 then the number of top n values is compared
+        :type n_top_values_only: int
         """
         # Initialize gmsh:
         gmsh_utils = GmshUtils(verbose=False)
@@ -753,7 +954,7 @@ class FiQuSSolverTests(BaseClassesForTests):
             # Open the pos file:
             gmsh.open(pos_file)
             data_all_steps = []
-            
+
             while True:
                 # Save all available time steps up to 100:
                 try:
@@ -786,9 +987,19 @@ class FiQuSSolverTests(BaseClassesForTests):
             msg=f"{pos_file_1} and {pos_file_2} are not the same length!",
         )
 
-        # Convert to numppy array:
-        model_data1 = np.array(model_datas[0])
-        model_data2 = np.array(model_datas[1])
+        # Convert to numpy arrays:
+        if n_top_values_only > 0:
+            print(f"Only top {n_top_values_only} values are compared.")
+            model_data1 = np.sort(np.partition(np.array(model_datas[0]), -n_top_values_only)[-n_top_values_only:])
+            model_data2 = np.sort(np.partition(np.array(model_datas[1]), -n_top_values_only)[-n_top_values_only:])
+            data = np.column_stack((model_data1, model_data2))
+
+            csv_path = f"{os.path.splitext(pos_file_1)[0]}.csv"
+            print(f'Saving {csv_path}')
+            # np.savetxt(csv_path, data, delimiter=",", header="pos_file_1,pos_file_2", comments='')
+        else:
+            model_data1 = np.array(model_datas[0])
+            model_data2 = np.array(model_datas[1])
 
         # Compare the data:
         np.testing.assert_allclose(
@@ -799,19 +1010,57 @@ class FiQuSSolverTests(BaseClassesForTests):
         )
 
     def get_path_to_generated_file(
-        self, data_model, file_name: str, file_extension: str
+            self, data_model, model_name: str, file_extension: str, subfolder=None, run_type="solve_only"
     ) -> Union[str, os.PathLike]:
         return super().get_path_to_generated_file(
             data_model,
             self.model_name,
-            file_name,
+            model_name,
             file_extension,
-            run_type="solve_only",
+            run_type=run_type,
+            subfolder=subfolder
         )
 
     def get_path_to_reference_file(
-        self, data_model, file_name, file_extension
+            self, data_model, model_name, file_extension, subfolder=None
     ) -> Union[str, os.PathLike]:
         return super().get_path_to_reference_file(
-            data_model, self.model_name, file_name, file_extension, folder="Solution"
+            data_model, self.model_name, model_name, file_extension, folder="Solution", subfolder=subfolder
+        )
+
+
+class FiQuSPostProcessPythonTests(BaseClassesForTests):
+    def post_process_python(
+            self,
+            data_model: FDM,
+            model_name: str,
+    ) -> Tuple[Union[str, os.PathLike], Union[str, os.PathLike]]:
+        """
+        This method postprocess with python the given model name.
+
+        :param data_model: data model to run FiQuS with
+        :type data_model: FDM
+        :param model_name: name of the model to generate the mesh for
+        :type model_name: str
+        """
+        self.run_fiqus(data_model, model_name, "post_process_python_only")
+        self.model_name = model_name
+
+    def get_path_to_generated_file(
+            self, data_model, model_name: str, file_extension: str, subfolder=None
+    ) -> Union[str, os.PathLike]:
+        return super().get_path_to_generated_file(
+            data_model,
+            self.model_name,
+            model_name,
+            file_extension,
+            subfolder=subfolder,
+            run_type="post_process_python_only",
         )
+
+    def get_path_to_reference_file(
+            self, data_model, model_name, file_extension, subfolder=None
+    ) -> Union[str, os.PathLike]:
+        return super().get_path_to_reference_file(
+            data_model, self.model_name, model_name, file_extension, folder="Solution", subfolder=subfolder
+        )