beamme.four_c.input_file

  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 defines the classes that are used to create an input file for
 234C."""
 24
 25import os as _os
 26from datetime import datetime as _datetime
 27from pathlib import Path as _Path
 28from typing import Callable as _Callable
 29from typing import Dict as _Dict
 30from typing import List as _List
 31
 32from fourcipp.fourc_input import FourCInput as _FourCInput
 33from fourcipp.fourc_input import sort_by_section_names as _sort_by_section_names
 34
 35from beamme.core.conf import INPUT_FILE_HEADER as _INPUT_FILE_HEADER
 36from beamme.core.conf import bme as _bme
 37from beamme.core.function import Function as _Function
 38from beamme.core.material import Material as _Material
 39from beamme.core.mesh import Mesh as _Mesh
 40from beamme.core.node import Node as _Node
 41from beamme.core.nurbs_patch import NURBSPatch as _NURBSPatch
 42from beamme.four_c.input_file_dump_item import dump_item_to_list as _dump_item_to_list
 43from beamme.four_c.input_file_dump_item import (
 44    dump_item_to_section as _dump_item_to_section,
 45)
 46from beamme.four_c.input_file_mappings import (
 47    INPUT_FILE_MAPPINGS as _INPUT_FILE_MAPPINGS,
 48)
 49from beamme.utils.environment import cubitpy_is_available as _cubitpy_is_available
 50from beamme.utils.environment import get_application_path as _get_application_path
 51from beamme.utils.environment import get_git_data as _get_git_data
 52
 53if _cubitpy_is_available():
 54    import cubitpy as _cubitpy
 55
 56
 57def get_geometry_set_indices_from_section(
 58    section_list: _List, *, append_node_ids: bool = True
 59) -> _Dict:
 60    """Return a dictionary with the geometry set ID as keys and the node IDs as
 61    values.
 62
 63    Args:
 64        section_list: A list with the legacy strings for the geometry pair
 65        append_node_ids: If the node IDs shall be appended, or only the
 66            dict with the keys should be returned.
 67    """
 68
 69    geometry_set_dict: _Dict[int, _List[int]] = {}
 70    for entry in section_list:
 71        id_geometry_set = entry["d_id"]
 72        index_node = entry["node_id"] - 1
 73        if id_geometry_set not in geometry_set_dict:
 74            geometry_set_dict[id_geometry_set] = []
 75        if append_node_ids:
 76            geometry_set_dict[id_geometry_set].append(index_node)
 77
 78    return geometry_set_dict
 79
 80
 81class InputFile(_FourCInput):
 82    """An item that represents a complete 4C input file."""
 83
 84    def __init__(self, sections=None):
 85        """Initialize the input file."""
 86
 87        super().__init__(sections=sections)
 88
 89        # Contents of NOX xml file.
 90        self.nox_xml_contents = ""
 91
 92        # Register converters to directly convert non-primitive types
 93        # to native Python types via the FourCIPP type converter.
 94        self.type_converter.register_numpy_types()
 95        self.type_converter.register_type(
 96            (_Function, _Material, _Node), lambda converter, obj: obj.i_global + 1
 97        )
 98
 99    def add(self, object_to_add, **kwargs):
100        """Add a mesh or a dictionary to the input file.
101
102        Args:
103            object: The object to be added. This can be a mesh or a dictionary.
104            **kwargs: Additional arguments to be passed to the add method.
105        """
106
107        if isinstance(object_to_add, _Mesh):
108            self.add_mesh_to_input_file(mesh=object_to_add, **kwargs)
109
110        else:
111            super().combine_sections(object_to_add)
112
113    def dump(
114        self,
115        input_file_path: str | _Path,
116        *,
117        nox_xml_file: str | None = None,
118        add_header_default: bool = True,
119        add_header_information: bool = True,
120        add_footer_application_script: bool = True,
121        validate=True,
122        validate_sections_only: bool = False,
123        sort_function: _Callable[[dict], dict] | None = _sort_by_section_names,
124        fourcipp_yaml_style: bool = True,
125    ):
126        """Write the input file to disk.
127
128        Args:
129            input_file_path:
130                Path to the input file that should be created.
131            nox_xml_file:
132                If this is a string, the NOX xml file will be created with this
133                name. If this is None, the NOX xml file will be created with the
134                name of the input file with the extension ".nox.xml".
135            add_header_default:
136                Prepend the default header comment to the input file.
137            add_header_information:
138                If the information header should be exported to the input file
139                Contains creation date, git details of BeamMe, CubitPy and
140                original application which created the input file if available.
141            add_footer_application_script:
142                Append the application script which creates the input files as a
143                comment at the end of the input file.
144            validate:
145                Validate if the created input file is compatible with 4C with FourCIPP.
146            validate_sections_only:
147                Validate each section independently. Required sections are no longer
148                required, but the sections must be valid.
149            sort_function:
150                A function which sorts the sections of the input file.
151            fourcipp_yaml_style:
152                If True, the input file is written in the fourcipp yaml style.
153        """
154
155        # Make sure the given input file is a Path instance.
156        input_file_path = _Path(input_file_path)
157
158        if self.nox_xml_contents:
159            if nox_xml_file is None:
160                nox_xml_file = input_file_path.name.split(".")[0] + ".nox.xml"
161
162            self["STRUCT NOX/Status Test"] = {"XML File": nox_xml_file}
163
164            # Write the xml file to the disc.
165            with open(input_file_path.parent / nox_xml_file, "w") as xml_file:
166                xml_file.write(self.nox_xml_contents)
167
168        # Add information header to the input file
169        if add_header_information:
170            self.add({"TITLE": self._get_header()})
171
172        super().dump(
173            input_file_path=input_file_path,
174            validate=validate,
175            validate_sections_only=validate_sections_only,
176            convert_to_native_types=False,  # conversion already happens during add()
177            sort_function=sort_function,
178            use_fourcipp_yaml_style=fourcipp_yaml_style,
179        )
180
181        if add_header_default or add_footer_application_script:
182            with open(input_file_path, "r") as input_file:
183                lines = input_file.readlines()
184
185                if add_header_default:
186                    lines = ["# " + line + "\n" for line in _INPUT_FILE_HEADER] + lines
187
188                if add_footer_application_script:
189                    application_path = _get_application_path()
190                    if application_path is not None:
191                        lines += self._get_application_script(application_path)
192
193                with open(input_file_path, "w") as input_file:
194                    input_file.writelines(lines)
195
196    def add_mesh_to_input_file(self, mesh: _Mesh):
197        """Add a mesh to the input file.
198
199        Args:
200            mesh: The mesh to be added to the input file.
201        """
202
203        # Perform some checks on the mesh.
204        if _bme.check_overlapping_elements:
205            mesh.check_overlapping_elements()
206
207        def _get_global_start_geometry_set(dictionary):
208            """Get the indices for the first "real" BeamMe geometry sets."""
209
210            start_indices_geometry_set = {}
211            for geometry_type, section_name in _INPUT_FILE_MAPPINGS[
212                "geometry_sets_geometry_to_condition_name"
213            ].items():
214                max_geometry_set_id = 0
215                if section_name in dictionary:
216                    section_list = dictionary[section_name]
217                    if len(section_list) > 0:
218                        geometry_set_dict = get_geometry_set_indices_from_section(
219                            section_list, append_node_ids=False
220                        )
221                        max_geometry_set_id = max(geometry_set_dict.keys())
222                start_indices_geometry_set[geometry_type] = max_geometry_set_id
223            return start_indices_geometry_set
224
225        def _get_global_start_node():
226            """Get the index for the first "real" BeamMe node."""
227
228            return len(self.sections.get("NODE COORDS", []))
229
230        def _get_global_start_element():
231            """Get the index for the first "real" BeamMe element."""
232
233            return sum(
234                len(self.sections.get(section, []))
235                for section in ["FLUID ELEMENTS", "STRUCTURE ELEMENTS"]
236            )
237
238        def _get_global_start_material():
239            """Get the index for the first "real" BeamMe material.
240
241            We have to account for materials imported from yaml files
242            that have arbitrary numbering.
243            """
244
245            # Get the maximum material index in materials imported from a yaml file
246            max_material_id = 0
247            section_name = "MATERIALS"
248            if section_name in self.sections:
249                for material in self.sections[section_name]:
250                    max_material_id = max(max_material_id, material["MAT"])
251            return max_material_id
252
253        def _get_global_start_function():
254            """Get the index for the first "real" BeamMe function."""
255
256            max_function_id = 0
257            for section_name in self.sections.keys():
258                if section_name.startswith("FUNCT"):
259                    max_function_id = max(
260                        max_function_id, int(section_name.split("FUNCT")[-1])
261                    )
262            return max_function_id
263
264        def _set_i_global(data_list, *, start_index=0):
265            """Set i_global in every item of data_list."""
266
267            # A check is performed that every entry in data_list is unique.
268            if len(data_list) != len(set(data_list)):
269                raise ValueError("Elements in data_list are not unique!")
270
271            # Set the values for i_global.
272            for i, item in enumerate(data_list):
273                item.i_global = i + start_index
274
275        def _set_i_global_elements(element_list, *, start_index=0):
276            """Set i_global in every item of element_list."""
277
278            # A check is performed that every entry in element_list is unique.
279            if len(element_list) != len(set(element_list)):
280                raise ValueError("Elements in element_list are not unique!")
281
282            # Set the values for i_global.
283            i = start_index
284            i_nurbs_patch = 0
285            for item in element_list:
286                # As a NURBS patch can be defined with more elements, an offset is applied to the
287                # rest of the items
288                item.i_global = i
289                if isinstance(item, _NURBSPatch):
290                    item.i_nurbs_patch = i_nurbs_patch
291                    offset = item.get_number_of_elements()
292                    i += offset
293                    i_nurbs_patch += 1
294                else:
295                    i += 1
296
297        def _dump_mesh_items(section_name, data_list):
298            """Output a section name and apply either the default dump or the
299            specialized the dump_to_list for each list item."""
300
301            # Do not write section if no content is available
302            if len(data_list) == 0:
303                return
304
305            list = []
306
307            for item in data_list:
308                _dump_item_to_list(list, item)
309
310            # If section already exists, retrieve from input file and
311            # add newly. We always need to go through fourcipp to convert
312            # the data types correctly.
313            if section_name in self.sections:
314                existing_entries = self.pop(section_name)
315                existing_entries.extend(list)
316                list = existing_entries
317
318            self.add({section_name: list})
319
320        # Add sets from couplings and boundary conditions to a temp container.
321        mesh.unlink_nodes()
322        start_indices_geometry_set = _get_global_start_geometry_set(self.sections)
323        mesh_sets = mesh.get_unique_geometry_sets(
324            geometry_set_start_indices=start_indices_geometry_set
325        )
326
327        # Assign global indices to all entries.
328        start_index_nodes = _get_global_start_node()
329        _set_i_global(mesh.nodes, start_index=start_index_nodes)
330
331        start_index_elements = _get_global_start_element()
332        _set_i_global_elements(mesh.elements, start_index=start_index_elements)
333
334        start_index_materials = _get_global_start_material()
335        _set_i_global(mesh.materials, start_index=start_index_materials)
336
337        start_index_functions = _get_global_start_function()
338        _set_i_global(mesh.functions, start_index=start_index_functions)
339
340        # Add material data to the input file.
341        _dump_mesh_items("MATERIALS", mesh.materials)
342
343        # Add the functions.
344        for function in mesh.functions:
345            self.add({f"FUNCT{function.i_global + 1}": function.data})
346
347        # If there are couplings in the mesh, set the link between the nodes
348        # and elements, so the couplings can decide which DOFs they couple,
349        # depending on the type of the connected beam element.
350        def get_number_of_coupling_conditions(key):
351            """Return the number of coupling conditions in the mesh."""
352            if (key, _bme.geo.point) in mesh.boundary_conditions.keys():
353                return len(mesh.boundary_conditions[key, _bme.geo.point])
354            else:
355                return 0
356
357        if (
358            get_number_of_coupling_conditions(_bme.bc.point_coupling)
359            + get_number_of_coupling_conditions(_bme.bc.point_coupling_penalty)
360            > 0
361        ):
362            mesh.set_node_links()
363
364        # Add the boundary conditions.
365        for (bc_key, geom_key), bc_list in mesh.boundary_conditions.items():
366            if len(bc_list) > 0:
367                section_name = (
368                    bc_key
369                    if isinstance(bc_key, str)
370                    else _INPUT_FILE_MAPPINGS["boundary_conditions"][(bc_key, geom_key)]
371                )
372                _dump_mesh_items(section_name, bc_list)
373
374        # Add additional element sections, e.g., for NURBS knot vectors.
375        for element in mesh.elements:
376            _dump_item_to_section(self, element)
377
378        # Add the geometry sets.
379        for geom_key, item in mesh_sets.items():
380            if len(item) > 0:
381                _dump_mesh_items(
382                    _INPUT_FILE_MAPPINGS["geometry_sets_geometry_to_condition_name"][
383                        geom_key
384                    ],
385                    item,
386                )
387
388        # Add the nodes and elements.
389        _dump_mesh_items("NODE COORDS", mesh.nodes)
390        _dump_mesh_items("STRUCTURE ELEMENTS", mesh.elements)
391        # TODO: reset all links and counters set in this method.
392
393    def _get_header(self) -> dict:
394        """Return the information header for the current BeamMe run.
395
396        Returns:
397            A dictionary with the header information.
398        """
399
400        header: dict = {"BeamMe": {}}
401
402        header["BeamMe"]["creation_date"] = _datetime.now().isoformat(
403            sep=" ", timespec="seconds"
404        )
405
406        # application which created the input file
407        application_path = _get_application_path()
408        if application_path is not None:
409            header["BeamMe"]["Application"] = {"path": str(application_path)}
410
411            application_git_sha, application_git_date = _get_git_data(
412                application_path.parent
413            )
414            if application_git_sha is not None and application_git_date is not None:
415                header["BeamMe"]["Application"].update(
416                    {
417                        "git_sha": application_git_sha,
418                        "git_date": application_git_date,
419                    }
420                )
421
422        # BeamMe information
423        beamme_git_sha, beamme_git_date = _get_git_data(
424            _Path(__file__).resolve().parent
425        )
426        if beamme_git_sha is not None and beamme_git_date is not None:
427            header["BeamMe"]["BeamMe"] = {
428                "git_SHA": beamme_git_sha,
429                "git_date": beamme_git_date,
430            }
431
432        # CubitPy information
433        if _cubitpy_is_available():
434            cubitpy_git_sha, cubitpy_git_date = _get_git_data(
435                _os.path.dirname(_cubitpy.__file__)
436            )
437
438            if cubitpy_git_sha is not None and cubitpy_git_date is not None:
439                header["BeamMe"]["CubitPy"] = {
440                    "git_SHA": cubitpy_git_sha,
441                    "git_date": cubitpy_git_date,
442                }
443
444        return header
445
446    def _get_application_script(self, application_path: _Path) -> list[str]:
447        """Get the script that created this input file.
448
449        Args:
450            application_path: Path to the script that created this input file.
451        Returns:
452            A list of strings with the script that created this input file.
453        """
454
455        application_script_lines = [
456            "# Application script which created this input file:\n"
457        ]
458
459        with open(application_path) as script_file:
460            application_script_lines.extend("# " + line for line in script_file)
461
462        return application_script_lines