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

fiqus/parsers/ParserGetDPTimeTable.py

@@ -1,134 +1,134 @@
-import re
-import math
-
-
-class ParserGetDPTimeTable:
-    """
-    This class parses GetDP's TimeTable format output files.
-    """
-
-    def __init__(self, filePath):
-        self.time_values = []
-        self.values = []
-        # Parse data:
-        with open(filePath) as file:
-            # If the first line starts with #, we skip it.
-            first_line = file.readline()
-            if not first_line.startswith("#"):
-                number_of_entries = len(
-                    re.findall(r"(-?\d+\.?\d*e?[-+]*\d*)", first_line)
-                )
-                # readline() moves the cursor to the next line, so we need to go back to
-                # the beginning of the file.
-                file.seek(0)
-            else:
-                second_line = file.readline()
-                number_of_entries = len(
-                    re.findall(r"(-?\d+\.?\d*e?[-+]*\d*)", second_line)
-                )
-                # Seek to the second line
-                file.seek(len(first_line) + 1)
-
-            data = file.read()
-
-        entries = re.findall(r"(-?\d+\.?\d*e?[-+]*\d*)", data)
-        if number_of_entries == 2:
-            # Global scalar value:
-            time_index = 0
-            value_index = 1
-            self.data_type = "scalar"
-        elif number_of_entries == 6:
-            # Local scalar value probed at a point:
-            time_index = 1
-            value_index = 5
-            self.data_type = "scalar"
-        elif number_of_entries == 8:
-            # Local vector value probed at a point:
-            time_index = 1
-            value_index = [5, 6, 7]
-            self.data_type = "vector"
-        elif number_of_entries == 14:
-            # Local tensor value probed at a point:
-            time_index = 1
-            value_index = [[5, 6, 7], [8, 9, 10], [11, 12, 13]]
-            self.data_type = "tensor"
-        else:
-            raise ValueError(f"{filePath} contains an unexpected type of data.")
-
-        # Pack entries for each line:
-        entries = [
-            entries[i : i + number_of_entries]
-            for i in range(0, len(entries), number_of_entries)
-        ]
-
-        for entry in entries:
-            if self.data_type == "scalar":
-                self.time_values.append(float(entry[time_index]))
-                self.values.append(float(entry[value_index]))
-            elif self.data_type == "vector":
-                self.time_values.append(float(entry[time_index]))
-                self.values.append(
-                    (
-                        float(entry[value_index[0]]),
-                        float(entry[value_index[1]]),
-                        float(entry[value_index[2]]),
-                    )
-                )
-            elif self.data_type == "tensor":
-                self.time_values.append(float(entry[time_index]))
-                self.values.append(
-                    [
-                        [
-                            float(entry[value_index[0][0]]),
-                            float(entry[value_index[0][1]]),
-                            float(entry[value_index[0][2]]),
-                        ],
-                        [
-                            float(entry[value_index[1][0]]),
-                            float(entry[value_index[1][1]]),
-                            float(entry[value_index[1][2]]),
-                        ],
-                        [
-                            float(entry[value_index[2][0]]),
-                            float(entry[value_index[2][1]]),
-                            float(entry[value_index[2][2]]),
-                        ],
-                    ]
-                )
-
-    def get_equivalent_scalar_values(self):
-        """
-        Returns the same scalar if self.data_type is scalar.
-        Returns the magnitude of the vectors if self.data_type is vector.
-        Returns the von misses equivalents of the tensors if self.data_type is tensor.
-        """
-
-        if self.data_type == "scalar":
-            return self.values
-        elif self.data_type == "vector":
-            magnitudes = [
-                math.sqrt(v[0] ** 2 + v[1] ** 2 + v[2] ** 2)
-                for v in self.values
-            ]
-            return magnitudes
-        elif self.data_type == "tensor":
-            von_misses_equivalents = [
-                math.sqrt(
-                    0.5
-                    * (
-                        (v[0][0] - v[1][1]) ** 2
-                        + (v[1][1] - v[2][2]) ** 2
-                        + (v[2][2] - v[0][0]) ** 2
-                        + 6
-                        * (
-                            ((v[0][1] + v[1][0]) / 2) ** 2
-                            + ((v[1][2] + v[2][1]) / 2) ** 2
-                            + ((v[0][2] + v[2][0]) / 2) ** 2
-                        )
-                    )
-                )
-                for v in self.values
-            ]
-            return von_misses_equivalents
-        else:
-            raise RuntimeError("Data type not recognized.")
+import re
+import math
+
+
+class ParserGetDPTimeTable:
+    """
+    This class parses GetDP's TimeTable format output files.
+    """
+
+    def __init__(self, filePath):
+        self.time_values = []
+        self.values = []
+        # Parse data:
+        with open(filePath) as file:
+            # If the first line starts with #, we skip it.
+            first_line = file.readline()
+            if not first_line.startswith("#"):
+                number_of_entries = len(
+                    re.findall(r"(-?\d+\.?\d*e?[-+]*\d*)", first_line)
+                )
+                # readline() moves the cursor to the next line, so we need to go back to
+                # the beginning of the file.
+                file.seek(0)
+            else:
+                second_line = file.readline()
+                number_of_entries = len(
+                    re.findall(r"(-?\d+\.?\d*e?[-+]*\d*)", second_line)
+                )
+                # Seek to the second line
+                file.seek(len(first_line) + 1)
+
+            data = file.read()
+
+        entries = re.findall(r"(-?\d+\.?\d*e?[-+]*\d*)", data)
+        if number_of_entries == 2:
+            # Global scalar value:
+            time_index = 0
+            value_index = 1
+            self.data_type = "scalar"
+        elif number_of_entries == 6:
+            # Local scalar value probed at a point:
+            time_index = 1
+            value_index = 5
+            self.data_type = "scalar"
+        elif number_of_entries == 8:
+            # Local vector value probed at a point:
+            time_index = 1
+            value_index = [5, 6, 7]
+            self.data_type = "vector"
+        elif number_of_entries == 14:
+            # Local tensor value probed at a point:
+            time_index = 1
+            value_index = [[5, 6, 7], [8, 9, 10], [11, 12, 13]]
+            self.data_type = "tensor"
+        else:
+            raise ValueError(f"{filePath} contains an unexpected type of data.")
+
+        # Pack entries for each line:
+        entries = [
+            entries[i : i + number_of_entries]
+            for i in range(0, len(entries), number_of_entries)
+        ]
+
+        for entry in entries:
+            if self.data_type == "scalar":
+                self.time_values.append(float(entry[time_index]))
+                self.values.append(float(entry[value_index]))
+            elif self.data_type == "vector":
+                self.time_values.append(float(entry[time_index]))
+                self.values.append(
+                    (
+                        float(entry[value_index[0]]),
+                        float(entry[value_index[1]]),
+                        float(entry[value_index[2]]),
+                    )
+                )
+            elif self.data_type == "tensor":
+                self.time_values.append(float(entry[time_index]))
+                self.values.append(
+                    [
+                        [
+                            float(entry[value_index[0][0]]),
+                            float(entry[value_index[0][1]]),
+                            float(entry[value_index[0][2]]),
+                        ],
+                        [
+                            float(entry[value_index[1][0]]),
+                            float(entry[value_index[1][1]]),
+                            float(entry[value_index[1][2]]),
+                        ],
+                        [
+                            float(entry[value_index[2][0]]),
+                            float(entry[value_index[2][1]]),
+                            float(entry[value_index[2][2]]),
+                        ],
+                    ]
+                )
+
+    def get_equivalent_scalar_values(self):
+        """
+        Returns the same scalar if self.data_type is scalar.
+        Returns the magnitude of the vectors if self.data_type is vector.
+        Returns the von misses equivalents of the tensors if self.data_type is tensor.
+        """
+
+        if self.data_type == "scalar":
+            return self.values
+        elif self.data_type == "vector":
+            magnitudes = [
+                math.sqrt(v[0] ** 2 + v[1] ** 2 + v[2] ** 2)
+                for v in self.values
+            ]
+            return magnitudes
+        elif self.data_type == "tensor":
+            von_misses_equivalents = [
+                math.sqrt(
+                    0.5
+                    * (
+                        (v[0][0] - v[1][1]) ** 2
+                        + (v[1][1] - v[2][2]) ** 2
+                        + (v[2][2] - v[0][0]) ** 2
+                        + 6
+                        * (
+                            ((v[0][1] + v[1][0]) / 2) ** 2
+                            + ((v[1][2] + v[2][1]) / 2) ** 2
+                            + ((v[0][2] + v[2][0]) / 2) ** 2
+                        )
+                    )
+                )
+                for v in self.values
+            ]
+            return von_misses_equivalents
+        else:
+            raise RuntimeError("Data type not recognized.")

fiqus/parsers/ParserMSH.py

@@ -1,53 +1,53 @@
-import gmsh
-import statistics
-
-class ParserMSH:
-    def __init__(self, mesh_file_path):
-        """
-        Read msh file and returns mesh format and physical names as class attributes.
-        :param mesh_file_path: Full path to .msh file, including file name and extension.
-        """
-        self.mesh_file_path = mesh_file_path
-
-        self._mesh_format_markers = {'s': '$MeshFormat', 'e': '$EndMeshFormat'}
-        self._physical_name_markers = {'s': 'PhysicalNames', 'e': '$EndPhysicalNames'}
-
-        with open(mesh_file_path) as f:
-            self._contents = f.read()
-
-    def __get_content(self, markers_dict):
-        """
-        Gets text string between two markers specified in markers_dict
-        """
-        return self._contents[self._contents.find(markers_dict['s']) + len(markers_dict['s']):self._contents.find(markers_dict['e'])]
-
-    def get_average_mesh_quality(self):
-        """
-        Gets the lowest mesh quality from the mesh file
-        """
-        gmsh.initialize()
-        gmsh.open(self.mesh_file_path)
-
-        # SICN not implemented in 1D!
-        allElementsDim2 = gmsh.model.mesh.getElements(dim=2)[1]
-        allElementsDim3 = gmsh.model.mesh.getElements(dim=3)[1]
-        allElements = list(allElementsDim2[0]) + (list(allElementsDim3[0]) if allElementsDim3 else [])
-        lowestQuality = statistics.fmean(gmsh.model.mesh.getElementQualities(allElements))
-
-        gmsh.finalize()
-
-        return lowestQuality
-
-    @property
-    def mesh_format(self):
-        """
-        Parse mesh_generators field and assign it to the class attribute
-        """
-        return self.__get_content(self._mesh_format_markers)
-
-    @property
-    def physical_names(self):
-        """
-        Parse physical_names field and assign it to the class attribute
-        """
-        return self.__get_content(self._physical_name_markers)
+import gmsh
+import statistics
+
+class ParserMSH:
+    def __init__(self, mesh_file_path):
+        """
+        Read msh file and returns mesh format and physical names as class attributes.
+        :param mesh_file_path: Full path to .msh file, including file name and extension.
+        """
+        self.mesh_file_path = mesh_file_path
+
+        self._mesh_format_markers = {'s': '$MeshFormat', 'e': '$EndMeshFormat'}
+        self._physical_name_markers = {'s': 'PhysicalNames', 'e': '$EndPhysicalNames'}
+
+        with open(mesh_file_path) as f:
+            self._contents = f.read()
+
+    def __get_content(self, markers_dict):
+        """
+        Gets text string between two markers specified in markers_dict
+        """
+        return self._contents[self._contents.find(markers_dict['s']) + len(markers_dict['s']):self._contents.find(markers_dict['e'])]
+
+    def get_average_mesh_quality(self):
+        """
+        Gets the lowest mesh quality from the mesh file
+        """
+        gmsh.initialize()
+        gmsh.open(self.mesh_file_path)
+
+        # SICN not implemented in 1D!
+        allElementsDim2 = gmsh.model.mesh.getElements(dim=2)[1]
+        allElementsDim3 = gmsh.model.mesh.getElements(dim=3)[1]
+        allElements = list(allElementsDim2[0]) + (list(allElementsDim3[0]) if allElementsDim3 else [])
+        lowestQuality = statistics.fmean(gmsh.model.mesh.getElementQualities(allElements))
+
+        gmsh.finalize()
+
+        return lowestQuality
+
+    @property
+    def mesh_format(self):
+        """
+        Parse mesh_generators field and assign it to the class attribute
+        """
+        return self.__get_content(self._mesh_format_markers)
+
+    @property
+    def physical_names(self):
+        """
+        Parse physical_names field and assign it to the class attribute
+        """
+        return self.__get_content(self._physical_name_markers)

fiqus/parsers/ParserRES.py

@@ -1,143 +1,143 @@
-import pandas as pd
-import re
-from collections import defaultdict
-
-class ParserRES:
-
-    def __init__(self, res_file_path, write_data=None):
-        """
-        TO BE DONE!!
-        Read res file and returns its content as object attribute .pqv (postprocessed quantity value) that is a float
-        :param dat_file_path: Full path to .pos file, including file name and extension.
-        :return: nothing, keeps attribute pqv (postprocessed quantity value)
-        """
-        self._res_format_markers = {'s': '$ResFormat', 'e': '$EndResFormat'}
-        self._getdp_version_markers = {'s': '/* ', 'e': ','}
-        self._encoding_markers = {'s': ', ', 'e': ' */'}
-        # the 1.1 is hard-coded according to the GetDP documentation, 
-        # see https://getdp.info/doc/texinfo/getdp.html#File-formats
-        self._res_file_format = {'s': '1.1 ', 'e': '\n$EndResFormat'}
-
-        self.solution = defaultdict(dict)
-        
-        if write_data:
-            self._res_file_path = res_file_path
-            self._write_data = write_data
-            self._write_res_file()
-        else:
-            # read contents of .res file
-            with open(res_file_path) as f:
-                self._contents = f.read()
-            self._parse_res_file()
-
-
-    def __get_content_between_markers(self, markers_dict):
-            """
-            Gets text string between two markers specified in markers_dict
-            """
-            return self._contents[self._contents.find(markers_dict['s']) + len(markers_dict['s']):self._contents.find(markers_dict['e'])]
-
-    def _res_header(self):
-        """
-        Parse the header of the .res file.
-        Add the attributes: 
-        - getdp_version: GetDP version that created the .res file
-        - encoding: encoding of the .res file
-        - res_file_format: format of the .res file
-        """
-        self.getdp_version = self.__get_content_between_markers(self._getdp_version_markers)
-        self.encoding = self.__get_content_between_markers(self._encoding_markers)
-        self.res_file_format = self.__get_content_between_markers(self._res_file_format)
-
-    def _get_all_solution_blocks(self):
-        """
-        Add all unparsed solution blocks to the attribute _solution_blocks
-        using regular expressions. It is a list of lists which each sub-list 
-        containing exactly one solution block.
-        """
-        solution_string = self._contents[self._contents.find('$Solution'):]
-        self._solution_blocks = re.findall(r'\$Solution.*?\$EndSolution', solution_string, re.DOTALL)
-
-    def _parse_res_file_single_solution_block(self, solution_block_split_by_line):
-
-        # the first line is ignored 
-        header = solution_block_split_by_line[1]
-        header_split = header.split()
-        dof_data = int(header_split[0])
-        time_real = float(header_split[1])
-        time_imag = float(header_split[2])
-        time_step = int(header_split[3])
-        solution = [float(entry) for entry in solution_block_split_by_line[2:-1]]
-
-        if "time_real" not in self.solution: 
-            self.solution['time_real'] = [time_real]
-        else: 
-            self.solution['time_real'].append(time_real)
-
-        if "time_imag" not in self.solution: 
-            self.solution['time_imag'] = [time_imag]
-        else: 
-            self.solution['time_imag'].append(time_imag)
-
-        if "time_step" not in self.solution: 
-            self.solution['time_step'] = [time_step]
-        else: 
-            self.solution['time_step'].append(time_step)
-
-        if "dof_data" not in self.solution: 
-            self.solution['dof_data'] = [dof_data]
-        else: 
-            self.solution['dof_data'].append(dof_data)
-
-        if "solution" not in self.solution: 
-            self.solution['solution'] = [solution]
-        else: 
-            self.solution['solution'].append(solution)
-
-    @staticmethod
-    def __get_lines(data_str):
-        """
-        Converts text string into a list of lines
-        """
-        data_str = re.sub('\n', "'", data_str)
-        data_str = re.sub('"', '', data_str)
-        str_list = re.split("'", data_str)
-        return str_list
-
-    def _parse_res_file_solution_blocks(self):
-        """
-        
-        """
-        for solution_block in self._solution_blocks:
-            # split by line
-            solution_block_split_by_line = self.__get_lines(solution_block)
-            self._parse_res_file_single_solution_block(solution_block_split_by_line)
-
-    def _parse_res_file(self): 
-        self._res_header()
-        self._get_all_solution_blocks()
-        self._parse_res_file_solution_blocks()
-
-    def _write_res_file(self):
-        with open(self._res_file_path, "w") as f:
-            # write header
-            f.write(f"$ResFormat /* {self._write_data.getdp_version}, {self._write_data.encoding} */\n")
-            # write res file format
-            f.write(f"1.1 {self._write_data.res_file_format}\n")
-            f.write(f"$EndResFormat\n")
-
-            self._write_solution_block(f)
-
-    def _write_solution_block(self, f):
-        for time_real, time_imag, time_step, dof_data, solution in zip(self._write_data.solution['time_real'], self._write_data.solution['time_imag'], self._write_data.solution['time_step'], self._write_data.solution['dof_data'], self._write_data.solution['solution']):
-        
-            f.write(f"$Solution  /* DofData #{dof_data} */\n")
-            f.write(f"{dof_data} {time_real:.16g} {time_imag:.16g} {time_step}\n")
-            f.write('\n'.join('{0:.16g}'.format(sol_entry) for sol_entry in solution))
-            f.write(f"\n$EndSolution\n")
-
-# ==============================================================================
-#parsedRes = ParserRES('test.res')
-#ParserRES('test_written.res', write_data=parsedRes)
-#import filecmp 
+import pandas as pd
+import re
+from collections import defaultdict
+
+class ParserRES:
+
+    def __init__(self, res_file_path, write_data=None):
+        """
+        TO BE DONE!!
+        Read res file and returns its content as object attribute .pqv (postprocessed quantity value) that is a float
+        :param dat_file_path: Full path to .pos file, including file name and extension.
+        :return: nothing, keeps attribute pqv (postprocessed quantity value)
+        """
+        self._res_format_markers = {'s': '$ResFormat', 'e': '$EndResFormat'}
+        self._getdp_version_markers = {'s': '/* ', 'e': ','}
+        self._encoding_markers = {'s': ', ', 'e': ' */'}
+        # the 1.1 is hard-coded according to the GetDP documentation, 
+        # see https://getdp.info/doc/texinfo/getdp.html#File-formats
+        self._res_file_format = {'s': '1.1 ', 'e': '\n$EndResFormat'}
+
+        self.solution = defaultdict(dict)
+        
+        if write_data:
+            self._res_file_path = res_file_path
+            self._write_data = write_data
+            self._write_res_file()
+        else:
+            # read contents of .res file
+            with open(res_file_path) as f:
+                self._contents = f.read()
+            self._parse_res_file()
+
+
+    def __get_content_between_markers(self, markers_dict):
+            """
+            Gets text string between two markers specified in markers_dict
+            """
+            return self._contents[self._contents.find(markers_dict['s']) + len(markers_dict['s']):self._contents.find(markers_dict['e'])]
+
+    def _res_header(self):
+        """
+        Parse the header of the .res file.
+        Add the attributes: 
+        - getdp_version: GetDP version that created the .res file
+        - encoding: encoding of the .res file
+        - res_file_format: format of the .res file
+        """
+        self.getdp_version = self.__get_content_between_markers(self._getdp_version_markers)
+        self.encoding = self.__get_content_between_markers(self._encoding_markers)
+        self.res_file_format = self.__get_content_between_markers(self._res_file_format)
+
+    def _get_all_solution_blocks(self):
+        """
+        Add all unparsed solution blocks to the attribute _solution_blocks
+        using regular expressions. It is a list of lists which each sub-list 
+        containing exactly one solution block.
+        """
+        solution_string = self._contents[self._contents.find('$Solution'):]
+        self._solution_blocks = re.findall(r'\$Solution.*?\$EndSolution', solution_string, re.DOTALL)
+
+    def _parse_res_file_single_solution_block(self, solution_block_split_by_line):
+
+        # the first line is ignored 
+        header = solution_block_split_by_line[1]
+        header_split = header.split()
+        dof_data = int(header_split[0])
+        time_real = float(header_split[1])
+        time_imag = float(header_split[2])
+        time_step = int(header_split[3])
+        solution = [float(entry) for entry in solution_block_split_by_line[2:-1]]
+
+        if "time_real" not in self.solution: 
+            self.solution['time_real'] = [time_real]
+        else: 
+            self.solution['time_real'].append(time_real)
+
+        if "time_imag" not in self.solution: 
+            self.solution['time_imag'] = [time_imag]
+        else: 
+            self.solution['time_imag'].append(time_imag)
+
+        if "time_step" not in self.solution: 
+            self.solution['time_step'] = [time_step]
+        else: 
+            self.solution['time_step'].append(time_step)
+
+        if "dof_data" not in self.solution: 
+            self.solution['dof_data'] = [dof_data]
+        else: 
+            self.solution['dof_data'].append(dof_data)
+
+        if "solution" not in self.solution: 
+            self.solution['solution'] = [solution]
+        else: 
+            self.solution['solution'].append(solution)
+
+    @staticmethod
+    def __get_lines(data_str):
+        """
+        Converts text string into a list of lines
+        """
+        data_str = re.sub('\n', "'", data_str)
+        data_str = re.sub('"', '', data_str)
+        str_list = re.split("'", data_str)
+        return str_list
+
+    def _parse_res_file_solution_blocks(self):
+        """
+        
+        """
+        for solution_block in self._solution_blocks:
+            # split by line
+            solution_block_split_by_line = self.__get_lines(solution_block)
+            self._parse_res_file_single_solution_block(solution_block_split_by_line)
+
+    def _parse_res_file(self): 
+        self._res_header()
+        self._get_all_solution_blocks()
+        self._parse_res_file_solution_blocks()
+
+    def _write_res_file(self):
+        with open(self._res_file_path, "w") as f:
+            # write header
+            f.write(f"$ResFormat /* {self._write_data.getdp_version}, {self._write_data.encoding} */\n")
+            # write res file format
+            f.write(f"1.1 {self._write_data.res_file_format}\n")
+            f.write(f"$EndResFormat\n")
+
+            self._write_solution_block(f)
+
+    def _write_solution_block(self, f):
+        for time_real, time_imag, time_step, dof_data, solution in zip(self._write_data.solution['time_real'], self._write_data.solution['time_imag'], self._write_data.solution['time_step'], self._write_data.solution['dof_data'], self._write_data.solution['solution']):
+        
+            f.write(f"$Solution  /* DofData #{dof_data} */\n")
+            f.write(f"{dof_data} {time_real:.16g} {time_imag:.16g} {time_step}\n")
+            f.write('\n'.join('{0:.16g}'.format(sol_entry) for sol_entry in solution))
+            f.write(f"\n$EndSolution\n")
+
+# ==============================================================================
+#parsedRes = ParserRES('test.res')
+#ParserRES('test_written.res', write_data=parsedRes)
+#import filecmp 
 #print(filecmp.cmp('test.res', 'test_written.res'))