Coverage for src/beamme/four_c/model_importer.py: 96%
92 statements
« prev ^ index » next coverage.py v7.10.7, created at 2025-09-29 11:30 +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 bme as _bme
36from beamme.core.coupling import Coupling as _Coupling
37from beamme.core.geometry_set import GeometrySetNodes as _GeometrySetNodes
38from beamme.core.mesh import Mesh as _Mesh
39from beamme.core.node import Node as _Node
40from beamme.four_c.input_file import InputFile as _InputFile
41from beamme.four_c.input_file import (
42 get_geometry_set_indices_from_section as _get_geometry_set_indices_from_section,
43)
44from beamme.four_c.input_file_mappings import (
45 INPUT_FILE_MAPPINGS as _INPUT_FILE_MAPPINGS,
46)
47from beamme.four_c.material import MaterialSolid as _MaterialSolid
48from beamme.utils.environment import cubitpy_is_available as _cubitpy_is_available
50if _cubitpy_is_available():
51 from cubitpy.cubit_to_fourc_input import (
52 get_input_file_with_mesh as _get_input_file_with_mesh,
53 )
56def import_cubitpy_model(
57 cubit, convert_input_to_mesh: bool = False
58) -> _Tuple[_InputFile, _Mesh]:
59 """Convert a CubitPy instance to a BeamMe InputFile.
61 Args:
62 cubit (CubitPy): An instance of a cubit model.
63 convert_input_to_mesh: If this is false, the cubit model will be
64 converted to plain FourCIPP input data. If this is true, an input
65 file with all the parameters will be returned and a mesh which
66 contains the mesh information from cubit converted to BeamMe
67 objects.
69 Returns:
70 A tuple with the input file and the mesh. If convert_input_to_mesh is
71 False, the mesh will be empty. Note that the input sections which are
72 converted to a BeamMe mesh are removed from the input file object.
73 """
75 input_file = _InputFile(sections=_get_input_file_with_mesh(cubit).sections)
77 if convert_input_to_mesh:
78 return _extract_mesh_sections(input_file)
79 else:
80 return input_file, _Mesh()
83def import_four_c_model(
84 input_file_path: _Path, convert_input_to_mesh: bool = False
85) -> _Tuple[_InputFile, _Mesh]:
86 """Import an existing 4C input file and optionally convert it into a BeamMe
87 mesh.
89 Args:
90 input_file_path: A file path to an existing 4C input file that will be
91 imported.
92 convert_input_to_mesh: If True, the input file will be converted to a
93 BeamMe mesh.
95 Returns:
96 A tuple with the input file and the mesh. If convert_input_to_mesh is
97 False, the mesh will be empty. Note that the input sections which are
98 converted to a BeamMe mesh are removed from the input file object.
99 """
101 input_file = _InputFile().from_4C_yaml(input_file_path=input_file_path)
103 if convert_input_to_mesh:
104 return _extract_mesh_sections(input_file)
105 else:
106 return input_file, _Mesh()
109def _element_from_dict(nodes: _List[_Node], element: dict, material_id_map: dict):
110 """Create a solid element from a dictionary from a 4C input file.
112 Args:
113 nodes: A list of nodes that are part of the element.
114 element: A dictionary with the element data.
115 material_id_map: A map between the global material ID and the BeamMe material object.
116 Returns:
117 A solid element object.
118 """
120 # Check which element to create.
121 if (
122 element["cell"]["type"]
123 not in _INPUT_FILE_MAPPINGS["element_four_c_string_to_type"]
124 ):
125 raise TypeError(
126 f"Could not create a BeamMe element for {element['data']['type']} {element['cell']['type']}!"
127 )
128 created_element = _INPUT_FILE_MAPPINGS["element_four_c_string_to_type"][
129 element["cell"]["type"]
130 ](nodes=nodes, data=element["data"])
132 # Check if we have to link this element to a material object (rigid spheres do not
133 # have a material).
134 if "MAT" in created_element.data:
135 created_element.data["MAT"] = material_id_map[created_element.data["MAT"]]
136 return created_element
139def _boundary_condition_from_dict(
140 geometry_set: _GeometrySetNodes,
141 bc_key: _Union[_conf.BoundaryCondition, str],
142 data: _Dict,
143) -> _BoundaryConditionBase:
144 """This function acts as a factory and creates the correct boundary
145 condition object from a dictionary parsed from an input file."""
147 del data["E"]
149 if bc_key in (
150 _bme.bc.dirichlet,
151 _bme.bc.neumann,
152 _bme.bc.locsys,
153 _bme.bc.beam_to_solid_surface_meshtying,
154 _bme.bc.beam_to_solid_surface_contact,
155 _bme.bc.beam_to_solid_volume_meshtying,
156 ) or isinstance(bc_key, str):
157 return _BoundaryCondition(geometry_set, data, bc_type=bc_key)
158 elif bc_key is _bme.bc.point_coupling:
159 return _Coupling(geometry_set, bc_key, data, check_overlapping_nodes=False)
160 else:
161 raise ValueError("Got unexpected boundary condition!")
164def _get_yaml_geometry_sets(
165 nodes: _List[_Node], geometry_key: _conf.Geometry, section_list: _List
166) -> _Dict[int, _GeometrySetNodes]:
167 """Add sets of points, lines, surfaces or volumes to the object."""
169 # Create the individual geometry sets
170 geometry_set_dict = _get_geometry_set_indices_from_section(section_list)
171 geometry_sets_in_this_section = {}
172 for geometry_set_id, node_ids in geometry_set_dict.items():
173 geometry_sets_in_this_section[geometry_set_id] = _GeometrySetNodes(
174 geometry_key, nodes=[nodes[node_id] for node_id in node_ids]
175 )
176 return geometry_sets_in_this_section
179def _extract_mesh_sections(input_file: _InputFile) -> _Tuple[_InputFile, _Mesh]:
180 """Convert an existing input file to a BeamMe mesh with mesh items, e.g.,
181 nodes, elements, element sets, node sets, boundary conditions, materials.
183 Args:
184 input_file: The input file object that contains the sections to be
185 converted to a BeamMe mesh.
186 Returns:
187 A tuple with the input file and the mesh. The input file will be
188 modified to remove the sections that have been converted to a
189 BeamMe mesh.
190 """
192 def _get_section_items(section_name):
193 """Return the items in a given section.
195 Since we will add the created BeamMe objects to the mesh, we
196 delete them from the plain data storage to avoid having
197 duplicate entries.
198 """
200 if section_name in input_file:
201 return input_file.pop(section_name)
202 else:
203 return []
205 # Go through all sections that have to be converted to full BeamMe objects
206 mesh = _Mesh()
208 # Add materials
209 material_id_map = {}
210 if "MATERIALS" in input_file:
211 for material_in_input_file in input_file.pop("MATERIALS"):
212 material_id = material_in_input_file.pop("MAT")
213 if not len(material_in_input_file) == 1:
214 raise ValueError(
215 f"Could not convert the material data {material_in_input_file} to a BeamMe material."
216 )
217 material_string = list(material_in_input_file.keys())[0]
218 material_data = list(material_in_input_file.values())[0]
219 material = _MaterialSolid(
220 material_string=material_string, data=material_data
221 )
222 material_id_map[material_id] = material
223 mesh.add(material)
225 # Add nodes
226 if "NODE COORDS" in input_file:
227 mesh.nodes = [_Node(node["COORD"]) for node in input_file.pop("NODE COORDS")]
229 # Add elements
230 if "STRUCTURE ELEMENTS" in input_file:
231 for element_in_input_file in input_file.pop("STRUCTURE ELEMENTS"):
232 nodes = [
233 mesh.nodes[node_id - 1]
234 for node_id in element_in_input_file["cell"]["connectivity"]
235 ]
236 mesh.elements.append(
237 _element_from_dict(
238 nodes=nodes,
239 element=element_in_input_file,
240 material_id_map=material_id_map,
241 )
242 )
244 # Add geometry sets
245 geometry_sets_in_sections: dict[str, dict[int, _GeometrySetNodes]] = {
246 key: {} for key in _bme.geo
247 }
248 for section_name in input_file.sections.keys():
249 if section_name.endswith("TOPOLOGY"):
250 section_items = _get_section_items(section_name)
251 if len(section_items) > 0:
252 # Get the geometry key for this set
253 for key, value in _INPUT_FILE_MAPPINGS[
254 "geometry_sets_geometry_to_condition_name"
255 ].items():
256 if value == section_name:
257 geometry_key = key
258 break
259 else:
260 raise ValueError(f"Could not find the set {section_name}")
261 geometry_sets_in_section = _get_yaml_geometry_sets(
262 mesh.nodes, geometry_key, section_items
263 )
264 geometry_sets_in_sections[geometry_key] = geometry_sets_in_section
265 mesh.geometry_sets[geometry_key] = list(
266 geometry_sets_in_section.values()
267 )
269 # Add boundary conditions
270 for (
271 bc_key,
272 geometry_key,
273 ), section_name in _INPUT_FILE_MAPPINGS["boundary_conditions"].items():
274 for item in _get_section_items(section_name):
275 geometry_set_id = item["E"]
276 geometry_set = geometry_sets_in_sections[geometry_key][geometry_set_id]
277 mesh.boundary_conditions.append(
278 (bc_key, geometry_key),
279 _boundary_condition_from_dict(geometry_set, bc_key, item),
280 )
282 return input_file, mesh