fiqus 2025.2.0__py3-none-any.whl → 2025.11.0__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)