Coverage for src/beamme/four_c/model_importer.py: 96%
85 statements
« prev ^ index » next coverage.py v7.9.1, created at 2025-06-30 18:48 +0000
1# The MIT License (MIT)
2#
3# Copyright (c) 2018-2025 BeamMe Authors
4#
5# Permission is hereby granted, free of charge, to any person obtaining a copy
6# of this software and associated documentation files (the "Software"), to deal
7# in the Software without restriction, including without limitation the rights
8# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9# copies of the Software, and to permit persons to whom the Software is
10# furnished to do so, subject to the following conditions:
11#
12# The above copyright notice and this permission notice shall be included in
13# all copies or substantial portions of the Software.
14#
15# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21# THE SOFTWARE.
22"""This module contains functions to load and parse existing 4C input files."""
24from pathlib import Path as _Path
25from typing import Dict as _Dict
26from typing import List as _List
27from typing import Tuple as _Tuple
28from typing import Union as _Union
30import beamme.core.conf as _conf
31from beamme.core.boundary_condition import BoundaryCondition as _BoundaryCondition
32from beamme.core.boundary_condition import (
33 BoundaryConditionBase as _BoundaryConditionBase,
34)
35from beamme.core.conf import mpy as _mpy
36from beamme.core.coupling import Coupling as _Coupling
37from beamme.core.element_volume import VolumeHEX8 as _VolumeHEX8
38from beamme.core.element_volume import VolumeHEX20 as _VolumeHEX20
39from beamme.core.element_volume import VolumeHEX27 as _VolumeHEX27
40from beamme.core.element_volume import VolumeTET4 as _VolumeTET4
41from beamme.core.element_volume import VolumeTET10 as _VolumeTET10
42from beamme.core.element_volume import VolumeWEDGE6 as _VolumeWEDGE6
43from beamme.core.geometry_set import GeometrySetNodes as _GeometrySetNodes
44from beamme.core.mesh import Mesh as _Mesh
45from beamme.core.node import Node as _Node
46from beamme.four_c.element_volume import SolidRigidSphere as _SolidRigidSphere
47from beamme.four_c.input_file import InputFile as _InputFile
48from beamme.four_c.input_file import (
49 get_geometry_set_indices_from_section as _get_geometry_set_indices_from_section,
50)
51from beamme.four_c.input_file_mappings import (
52 INPUT_FILE_MAPPINGS as _INPUT_FILE_MAPPINGS,
53)
54from beamme.utils.environment import cubitpy_is_available as _cubitpy_is_available
56if _cubitpy_is_available():
57 from cubitpy.cubit_to_fourc_input import (
58 get_input_file_with_mesh as _get_input_file_with_mesh,
59 )
62def import_cubitpy_model(
63 cubit, convert_input_to_mesh: bool = False
64) -> _Tuple[_InputFile, _Mesh]:
65 """Convert a CubitPy instance to a BeamMe InputFile.
67 Args:
68 cubit (CubitPy): An instance of a cubit model.
69 convert_input_to_mesh: If this is false, the cubit model will be
70 converted to plain FourCIPP input data. If this is true, an input
71 file with all the parameters will be returned and a mesh which
72 contains the mesh information from cubit converted to BeamMe
73 objects.
75 Returns:
76 A tuple with the input file and the mesh. If convert_input_to_mesh is
77 False, the mesh will be empty. Note that the input sections which are
78 converted to a BeamMe mesh are removed from the input file object.
79 """
81 input_file = _InputFile(sections=_get_input_file_with_mesh(cubit).sections)
83 if convert_input_to_mesh:
84 return _extract_mesh_sections(input_file)
85 else:
86 return input_file, _Mesh()
89def import_four_c_model(
90 input_file_path: _Path, convert_input_to_mesh: bool = False
91) -> _Tuple[_InputFile, _Mesh]:
92 """Import an existing 4C input file and optionally convert it into a BeamMe
93 mesh.
95 Args:
96 input_file_path: A file path to an existing 4C input file that will be
97 imported.
98 convert_input_to_mesh: If True, the input file will be converted to a
99 BeamMe mesh.
101 Returns:
102 A tuple with the input file and the mesh. If convert_input_to_mesh is
103 False, the mesh will be empty. Note that the input sections which are
104 converted to a BeamMe mesh are removed from the input file object.
105 """
107 input_file = _InputFile().from_4C_yaml(input_file_path=input_file_path)
109 if convert_input_to_mesh:
110 return _extract_mesh_sections(input_file)
111 else:
112 return input_file, _Mesh()
115def _element_from_dict(nodes: _List[_Node], element: dict):
116 """Create a solid element from a dictionary from a 4C input file.
118 Args:
119 nodes: A list of nodes that are part of the element.
120 element: A dictionary with the element data.
121 Returns:
122 A solid element object.
123 """
125 # Depending on the number of nodes chose which solid element to return.
126 # TODO reuse element_type_to_four_c_string from beamme.core.element_volume
127 element_type = {
128 "HEX8": _VolumeHEX8,
129 "HEX20": _VolumeHEX20,
130 "HEX27": _VolumeHEX27,
131 "TET4": _VolumeTET4,
132 "TET10": _VolumeTET10,
133 "WEDGE6": _VolumeWEDGE6,
134 "POINT1": _SolidRigidSphere,
135 }
137 if element["cell"]["type"] not in element_type:
138 raise TypeError(
139 f"Could not create a BeamMe element for {element['data']['type']} {element['cell']['type']}!"
140 )
142 return element_type[element["cell"]["type"]](nodes=nodes, data=element["data"])
145def _boundary_condition_from_dict(
146 geometry_set: _GeometrySetNodes,
147 bc_key: _Union[_conf.BoundaryCondition, str],
148 data: _Dict,
149) -> _BoundaryConditionBase:
150 """This function acts as a factory and creates the correct boundary
151 condition object from a dictionary parsed from an input file."""
153 del data["E"]
155 if bc_key in (
156 _mpy.bc.dirichlet,
157 _mpy.bc.neumann,
158 _mpy.bc.locsys,
159 _mpy.bc.beam_to_solid_surface_meshtying,
160 _mpy.bc.beam_to_solid_surface_contact,
161 _mpy.bc.beam_to_solid_volume_meshtying,
162 ) or isinstance(bc_key, str):
163 return _BoundaryCondition(geometry_set, data, bc_type=bc_key)
164 elif bc_key is _mpy.bc.point_coupling:
165 return _Coupling(geometry_set, bc_key, data, check_overlapping_nodes=False)
166 else:
167 raise ValueError("Got unexpected boundary condition!")
170def _get_yaml_geometry_sets(
171 nodes: _List[_Node], geometry_key: _conf.Geometry, section_list: _List
172) -> _Dict[int, _GeometrySetNodes]:
173 """Add sets of points, lines, surfaces or volumes to the object."""
175 # Create the individual geometry sets
176 geometry_set_dict = _get_geometry_set_indices_from_section(section_list)
177 geometry_sets_in_this_section = {}
178 for geometry_set_id, node_ids in geometry_set_dict.items():
179 geometry_sets_in_this_section[geometry_set_id] = _GeometrySetNodes(
180 geometry_key, nodes=[nodes[node_id] for node_id in node_ids]
181 )
182 return geometry_sets_in_this_section
185def _extract_mesh_sections(input_file: _InputFile) -> _Tuple[_InputFile, _Mesh]:
186 """Convert an existing input file to a BeamMe mesh with mesh items, e.g.,
187 nodes, elements, element sets, node sets, boundary conditions, materials.
189 Args:
190 input_file: The input file object that contains the sections to be
191 converted to a BeamMe mesh.
192 Returns:
193 A tuple with the input file and the mesh. The input file will be
194 modified to remove the sections that have been converted to a
195 BeamMe mesh.
196 """
198 def _get_section_items(section_name):
199 """Return the items in a given section.
201 Since we will add the created BeamMe objects to the mesh, we
202 delete them from the plain data storage to avoid having
203 duplicate entries.
204 """
206 if section_name in input_file:
207 return input_file.pop(section_name)
208 else:
209 return []
211 # Go through all sections that have to be converted to full BeamMe objects
212 mesh = _Mesh()
214 # Add nodes
215 if "NODE COORDS" in input_file:
216 mesh.nodes = [_Node(node["COORD"]) for node in input_file.pop("NODE COORDS")]
218 # Add elements
219 if "STRUCTURE ELEMENTS" in input_file:
220 for element in input_file.pop("STRUCTURE ELEMENTS"):
221 nodes = [
222 mesh.nodes[node_id - 1] for node_id in element["cell"]["connectivity"]
223 ]
224 mesh.elements.append(_element_from_dict(nodes=nodes, element=element))
226 # Add geometry sets
227 geometry_sets_in_sections: dict[str, dict[int, _GeometrySetNodes]] = {
228 key: {} for key in _mpy.geo
229 }
230 for section_name in input_file.sections.keys():
231 if section_name.endswith("TOPOLOGY"):
232 section_items = _get_section_items(section_name)
233 if len(section_items) > 0:
234 # Get the geometry key for this set
235 for key, value in _INPUT_FILE_MAPPINGS["geometry_sets"].items():
236 if value == section_name:
237 geometry_key = key
238 break
239 else:
240 raise ValueError(f"Could not find the set {section_name}")
241 geometry_sets_in_section = _get_yaml_geometry_sets(
242 mesh.nodes, geometry_key, section_items
243 )
244 geometry_sets_in_sections[geometry_key] = geometry_sets_in_section
245 mesh.geometry_sets[geometry_key] = list(
246 geometry_sets_in_section.values()
247 )
249 # Add boundary conditions
250 for (
251 bc_key,
252 geometry_key,
253 ), section_name in _INPUT_FILE_MAPPINGS["boundary_conditions"].items():
254 for item in _get_section_items(section_name):
255 geometry_set_id = item["E"]
256 geometry_set = geometry_sets_in_sections[geometry_key][geometry_set_id]
257 mesh.boundary_conditions.append(
258 (bc_key, geometry_key),
259 _boundary_condition_from_dict(geometry_set, bc_key, item),
260 )
262 return input_file, mesh