Merge pull request #310 from isteinbrecher/meshpy_to_yaml

Migrate main MeshPy functionality to YAML

Author: isteinbrecher

src/meshpy/core/boundary_condition.py

@@ -50,16 +50,13 @@ def __init__(self, geometry_set, bc_type=None, **kwargs):
         self.geometry_set = geometry_set
 
     @classmethod
-    def from_dat(cls, bc_key, line, **kwargs):
+    def from_dict(cls, geometry_sets, bc_key, bc_dict):
         """This function acts as a factory and creates the correct boundary
-        condition object from a line in the dat file.
+        condition object from a dictionary parsed from an input file."""
 
-        The geometry set is passed as integer (0 based index) and will
-        be connected after the whole input file is parsed.
-        """
-
-        # Split up the input line.
-        split = line.split()
+        geometry_set_id = int(bc_dict["E"]) - 1
+        geometry_set = geometry_sets[geometry_set_id]
+        del bc_dict["E"]
 
         if bc_key in (
             _mpy.bc.dirichlet,
@@ -74,22 +71,25 @@ def from_dat(cls, bc_key, line, **kwargs):
                 BoundaryCondition as _BoundaryCondition,
             )
 
-            return _BoundaryCondition(
-                int(split[1]) - 1, " ".join(split[2:]), bc_type=bc_key, **kwargs
+            boundary_condition = _BoundaryCondition(
+                geometry_set, bc_dict, bc_type=bc_key
             )
         elif bc_key is _mpy.bc.point_coupling:
             # Coupling condition.
             from meshpy.core.coupling import Coupling as _Coupling
 
-            return _Coupling(
-                int(split[1]) - 1,
+            boundary_condition = _Coupling(
+                geometry_set,
                 bc_key,
-                " ".join(split[2:]),
+                bc_dict,
                 check_overlapping_nodes=False,
                 check_at_init=False,
-                **kwargs,
             )
-        raise ValueError("Got unexpected boundary condition!")
+        else:
+            raise ValueError("Got unexpected boundary condition!")
+
+        boundary_condition.check()
+        return boundary_condition
 
 
 class BoundaryConditionContainer(_ContainerBase):

src/meshpy/core/coupling.py

@@ -108,15 +108,12 @@ def check(self):
                 "The nodes given to Coupling do not have the same position."
             )
 
-    def _get_dat(self):
-        """Return the dat line for this object.
+    def dump_to_list(self):
+        """Return a list with a single item representing this coupling
+        condition."""
 
-        If no explicit string was given, it depends on the coupling type
-        as well as the beam type.
-        """
-
-        if isinstance(self.coupling_dof_type, str):
-            string = self.coupling_dof_type
+        if isinstance(self.coupling_dof_type, dict):
+            bc_dict = self.coupling_dof_type
         else:
             # In this case we have to check which beams are connected to the node.
             # TODO: Coupling also makes sense for different beam types, this can
@@ -150,9 +147,9 @@ def _get_dat(self):
                             "Coupling beams of different types is not yet possible!"
                         )
 
-            string = beam_four_c_type.get_coupling_string(self.coupling_dof_type)
+            bc_dict = beam_four_c_type.get_coupling_dict(self.coupling_dof_type)
 
-        return f"E {self.geometry_set.i_global} {string}"
+        return [{"E": self.geometry_set.i_global, **bc_dict}]
 
 
 def coupling_factory(geometry, coupling_type, coupling_dof_type, **kwargs):

src/meshpy/core/element.py

@@ -21,7 +21,11 @@
 # THE SOFTWARE.
 """This module implements the class that represents one element in the Mesh."""
 
+from typing import List as _List
+
 from meshpy.core.base_mesh_item import BaseMeshItemFull as _BaseMeshItemFull
+from meshpy.core.node import Node as _Node
+from meshpy.utils.environment import fourcipp_is_available as _fourcipp_is_available
 
 
 class Element(_BaseMeshItemFull):
@@ -43,12 +47,15 @@ def __init__(self, nodes=None, material=None, **kwargs):
         self.vtk_cell_data = {}
 
     @classmethod
-    def from_dat(cls, input_line):
-        """Check the string to decide which element to use.
+    def from_legacy_string(cls, nodes: _List[_Node], input_line: str):
+        """Create an element from a legacy string."""
 
-        Nodes are linked with the 0 based index and will be connected to
-        the Node objects after the whole input file is parsed.
-        """
+        if _fourcipp_is_available():
+            raise ValueError(
+                "Port this functionality to create the element from the dict "
+                "representing the element, not the legacy string."
+                "TODO: pass the nodes array here, so we can directly link to the nodes"
+            )
 
         # Import solid element classes for creation of the element.
         from meshpy.core.element_volume import VolumeHEX8 as _VolumeHEX8
@@ -59,14 +66,16 @@ def from_dat(cls, input_line):
         from meshpy.four_c.element_volume import SolidRigidSphere as _SolidRigidSphere
 
         # Split up input line and get pre node string.
-        line_split = input_line[0].split()
-        dat_pre_nodes = " ".join(line_split[1:3])
+        line_split = input_line.split()
+        string_pre_nodes = " ".join(line_split[1:3])
 
         # Get a list of the element nodes.
-        element_nodes = []
+        # This is only here because we need the pre and post strings - can be
+        # removed when moving on from the legacy format.
+        dummy = []
         for i, item in enumerate(line_split[3:]):
             if item.isdigit():
-                element_nodes.append(int(item) - 1)
+                dummy.append(int(item) - 1)
             else:
                 break
         else:
@@ -75,56 +84,51 @@ def from_dat(cls, input_line):
             )
 
         # Get the post node string
-        dat_post_nodes = " ".join(line_split[3 + i :])
+        string_post_nodes = " ".join(line_split[3 + i :])
 
         # Depending on the number of nodes chose which solid element to return.
-        n_nodes = len(element_nodes)
+        n_nodes = len(nodes)
         match n_nodes:
             case 8:
                 return _VolumeHEX8(
-                    nodes=element_nodes,
-                    dat_pre_nodes=dat_pre_nodes,
-                    dat_post_nodes=dat_post_nodes,
+                    nodes=nodes,
+                    string_pre_nodes=string_pre_nodes,
+                    string_post_nodes=string_post_nodes,
                     comments=input_line[1],
                 )
             case 4:
                 return _VolumeTET4(
-                    nodes=element_nodes,
-                    dat_pre_nodes=dat_pre_nodes,
-                    dat_post_nodes=dat_post_nodes,
-                    comments=input_line[1],
+                    nodes=nodes,
+                    string_pre_nodes=string_pre_nodes,
+                    string_post_nodes=string_post_nodes,
                 )
             case 10:
                 return _VolumeTET10(
-                    nodes=element_nodes,
-                    dat_pre_nodes=dat_pre_nodes,
-                    dat_post_nodes=dat_post_nodes,
-                    comments=input_line[1],
+                    nodes=nodes,
+                    string_pre_nodes=string_pre_nodes,
+                    string_post_nodes=string_post_nodes,
                 )
             case 20:
                 return _VolumeHEX20(
-                    nodes=element_nodes,
-                    dat_pre_nodes=dat_pre_nodes,
-                    dat_post_nodes=dat_post_nodes,
-                    comments=input_line[1],
+                    nodes=nodes,
+                    string_pre_nodes=string_pre_nodes,
+                    string_post_nodes=string_post_nodes,
                 )
             case 27:
                 return _VolumeHEX27(
-                    nodes=element_nodes,
-                    dat_pre_nodes=dat_pre_nodes,
-                    dat_post_nodes=dat_post_nodes,
-                    comments=input_line[1],
+                    nodes=nodes,
+                    string_pre_nodes=string_pre_nodes,
+                    string_post_nodes=string_post_nodes,
                 )
             case 1:
                 return _SolidRigidSphere(
-                    nodes=element_nodes,
-                    dat_pre_nodes=dat_pre_nodes,
-                    dat_post_nodes=dat_post_nodes,
-                    comments=input_line[1],
+                    nodes=nodes,
+                    string_pre_nodes=string_pre_nodes,
+                    string_post_nodes=string_post_nodes,
                 )
             case _:
                 raise TypeError(
-                    f"Could not find a element type for {dat_pre_nodes}, with {n_nodes} nodes"
+                    f"Could not find a element type for {string_pre_nodes}, with {n_nodes} nodes"
                 )
 
     def flip(self):
@@ -149,9 +153,9 @@ def replace_node(self, old_node, new_node):
                 "The node that should be replaced is not in the current element"
             )
 
-    def add_element_specific_section(self, sections):
-        """Add element specific section (e.g. STRUCTURE KNOTVECTORS for NURBS
-        elements) to the sections dictionary."""
+    def dump_element_specific_section(self, yaml_dict):
+        """Add information of this element to specific section (e.g. STRUCTURE
+        KNOTVECTORS for NURBS elements)."""
 
     def get_vtk(self, vtk_writer_beam, vtk_writer_solid, **kwargs):
         """Add representation of this element to the vtk_writers for solid and

src/meshpy/core/element_beam.py

@@ -155,18 +155,18 @@ def check_node(node, pos, rot, arc_length, name):
         return created_nodes
 
     @classmethod
-    def get_coupling_string(cls, coupling_dof_type):
-        """Return the string to couple this beam to another beam."""
+    def get_coupling_dict(cls, coupling_dof_type):
+        """Return the dict to couple this beam to another beam."""
 
         match coupling_dof_type:
             case _mpy.coupling_dof.joint:
-                if cls.coupling_joint_string is None:
+                if cls.coupling_joint_dict is None:
                     raise ValueError(f"Joint coupling is not implemented for {cls}")
-                return cls.coupling_joint_string
+                return cls.coupling_joint_dict
             case _mpy.coupling_dof.fix:
-                if cls.coupling_fix_string is None:
+                if cls.coupling_fix_dict is None:
                     raise ValueError("Fix coupling is not implemented for {cls}")
-                return cls.coupling_fix_string
+                return cls.coupling_fix_dict
             case _:
                 raise ValueError(
                     f'Coupling_dof_type "{coupling_dof_type}" is not implemented!'

src/meshpy/core/element_volume.py

@@ -36,23 +36,21 @@ class VolumeElement(_Element):
     vtk_cell_type = None
     vtk_topology: list = []
 
-    def __init__(self, nodes=None, dat_pre_nodes="", dat_post_nodes="", **kwargs):
+    def __init__(self, nodes=None, string_pre_nodes="", string_post_nodes="", **kwargs):
         super().__init__(nodes=nodes, material=None, **kwargs)
-        self.dat_pre_nodes = dat_pre_nodes
-        self.dat_post_nodes = dat_post_nodes
+        self.string_pre_nodes = string_pre_nodes
+        self.string_post_nodes = string_post_nodes
 
-    def _get_dat(self):
-        """Return the dat line for this element."""
+    def dump_to_list(self):
+        """Return a list with the items representing this object (usually a
+        single item)."""
 
         # String with the node ids.
-        nodes_string = ""
-        for node in self.nodes:
-            nodes_string += f"{node.i_global} "
+        nodes_string = " ".join(str(node.i_global) for node in self.nodes)
 
-        # Return the dat line.
-        return (
-            f"{self.i_global} {self.dat_pre_nodes} {nodes_string} {self.dat_post_nodes}"
-        )
+        return [
+            f"{self.i_global} {self.string_pre_nodes} {nodes_string} {self.string_post_nodes}"
+        ]
 
     def get_vtk(self, vtk_writer_beam, vtk_writer_solid, **kwargs):
         """Add the representation of this element to the VTK writer as a

src/meshpy/core/geometry_set.py

@@ -30,6 +30,7 @@
 from meshpy.core.container import ContainerBase as _ContainerBase
 from meshpy.core.element_beam import Beam as _Beam
 from meshpy.core.node import Node as _Node
+from meshpy.utils.environment import fourcipp_is_available as _fourcipp_is_available
 
 
 class GeometrySetBase(_BaseMeshItemFull):
@@ -120,8 +121,13 @@ def get_all_nodes(self):
             'The "get_all_nodes" method has to be overwritten in the derived class'
         )
 
-    def _get_dat(self):
-        """Get the lines for the input file."""
+    def dump_to_list(self):
+        """Return a list with the legacy strings of this geometry set."""
+
+        if _fourcipp_is_available():
+            raise ValueError(
+                "Port this functionality to dump the geometry set to a suitable data format"
+            )
 
         # Sort the nodes based on the node GID.
         nodes = self.get_all_nodes()
@@ -264,26 +270,6 @@ def __init__(self, geometry_type, nodes=None, **kwargs):
         if nodes is not None:
             self.add(nodes)
 
-    @classmethod
-    def from_dat(cls, geometry_key, lines, comments=None):
-        """Get a geometry set from an input line in a dat file.
-
-        The geometry set is passed as integer (0 based index) and will
-        be connected after the whole input file is parsed.
-        """
-        nodes = []
-        for line in lines:
-            nodes.append(int(line.split()[1]) - 1)
-        return cls(geometry_key, nodes, comments=comments)
-
-    def replace_indices_with_nodes(self, nodes):
-        """After the set is imported from a dat file, replace the node indices
-        with the corresponding nodes objects."""
-        node_dict = {}
-        for node_id in self.nodes.keys():
-            node_dict[nodes[node_id]] = None
-        self.nodes = node_dict
-
     def add(self, value):
         """Add nodes to this object.