STEM-Vibrations 0.1__py3-none-any.whl

STEM_Vibrations-0.1.dist-info/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, StemVibrations
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

STEM_Vibrations-0.1.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: STEM-Vibrations
+Version: 0.1
+Summary: STEM model
+Author: attr: stem.__author__
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy >=1.24
+Requires-Dist: scipy >=1.10.1
+Requires-Dist: plotly >=5.15.0
+Provides-Extra: docs
+Requires-Dist: Sphinx ==6.2.1 ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ==1.2.2 ; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: pytest >=7.2 ; extra == 'testing'
+Requires-Dist: pytest-cov >=4.0 ; extra == 'testing'
+Requires-Dist: tox >=4.4 ; extra == 'testing'
+Requires-Dist: mypy >=1.1 ; extra == 'testing'
+Requires-Dist: beautifulsoup4 >=4.12 ; extra == 'testing'
+Requires-Dist: matplotlib ==3.7.4 ; extra == 'testing'
+

STEM_Vibrations-0.1.dist-info/RECORD

@@ -0,0 +1,36 @@
+stem/__init__.py,sha256=e3S0EcDGJlWIp2hddSFjvt633jfeZ4W7VyAeLpfTWVM,37
+stem/__version__.py,sha256=PwBX7IH4ybiznTUqyIJs-zWWCn2QhIpgMVhe-qDkK6M,114
+stem/additional_processes.py,sha256=F8HRn-suP13lGbgJez5DHjWdScZKdnYkdKlJxOhm754,3930
+stem/boundary.py,sha256=TKR3NK0T9X0t1WrkoveOPQAZU_XN44xHD1kcwnR48fQ,8646
+stem/default_materials.py,sha256=RMUG8-EsdHuNQFsY5csZZD0jEpKPLop8IGHQveIPeK4,2693
+stem/field_generator.py,sha256=-BvEnoPYoHBsirJlJPnlFcHI86zCSqlp-esqhnxBo3Y,7589
+stem/geometry.py,sha256=phYvMCbCxdQLxVIZqQTn_b3tjjx1lelY88I2lRE3-Go,15863
+stem/globals.py,sha256=76J6d5DtDiQb2Cf6EtgFjyRp5Y1hAiHNDNduq9HnpeQ,5534
+stem/load.py,sha256=jZpNxJFH5EAxFD0Y1EgfRLRYp6dlNiTqJ308oSjC7YQ,13490
+stem/mesh.py,sha256=JNy6ArOmuXML6cfzUCNkjeL0iPBP2nJqHfXSmTVx7l8,7600
+stem/model.py,sha256=yfcb1xIgxMsbupP-7516MMeuAPUkVvS7bsxRa6Ax5JY,73097
+stem/model_part.py,sha256=RAhZdRDoXbr__7Kc-eYsxgn28lVpKhTHhZIGP1xiEtc,5624
+stem/output.py,sha256=8nTE_fMRWmqN12pFBjY2Z8_HYCVgGQy17AIU2yxHTM0,15556
+stem/plot_utils.py,sha256=4W7ZYmStGanuez4J_saK6IQf-Yj9qMB9saKl9Mo65Qc,14696
+stem/soil_material.py,sha256=X8pcra4tjQeIJIQ96AYU3bT4CnY3EsI7SxTw8ldbIlo,11106
+stem/solver.py,sha256=Wd0Ax1od1ixxe2rFI0oxK1Y_azrJcPXDSQInl63BjHM,18643
+stem/stem.py,sha256=Ifs5iYrS0vgXeApES2k49txj1GjlJKVsCzxBIeF34Y0,5416
+stem/structural_material.py,sha256=_Cdw7th173PqvX8luQJX4lCEEs2LojOPkVWG4e9dKGc,9775
+stem/table.py,sha256=EOu6lxahi_z_1ep0_GbEi55xzPGStHd673nOv5DLub4,1901
+stem/utils.py,sha256=myUcJmIo_TLZT9P6Q019Fef876gIHE7awqGr95aQUdE,21772
+stem/water_processes.py,sha256=rbrb8RH-Z_yIs2QkWxRMlvfjpKwSKUvNKzZ5lmfZQ4w,706
+stem/IO/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stem/IO/io_utils.py,sha256=z5wCnN9OHG7_ysrfVAEMxthbFIs2S8EBUeQfAm1FOO4,5543
+stem/IO/kratos_additional_processes_io.py,sha256=_z0_VmJZ7tRPQ1_a59WrdErRa8WWBbYQWt6uswFRND8,4230
+stem/IO/kratos_boundaries_io.py,sha256=-gfyKiVsBwcuNvDMagiJkYmcuIRPouvwiXp9XEDRr5A,2814
+stem/IO/kratos_io.py,sha256=BQCZXmwzm2thwABLSfzhOnZ9IVeQO3byRg2HANG-WIM,45874
+stem/IO/kratos_loads_io.py,sha256=7buV36IEuUcjiM-sU7ApMtgVry8_zajoEq9hvdR-BKE,4637
+stem/IO/kratos_material_io.py,sha256=KonYgIezy9Bg5kTAeORQXe1tSTC_4i_BQLp2-dFrcKs,17956
+stem/IO/kratos_output_io.py,sha256=yYQQ2XnjG2orX789phs6mBKu0m2EeR50EGM_zgnWZrk,12472
+stem/IO/kratos_solver_io.py,sha256=iaDbER1fMjs5eKvLmkzhDTubEcHD9s0wyD_yjBG1KGE,14713
+stem/IO/kratos_water_processes_io.py,sha256=hud32aclzf4xcdu_oK5ZZM1sAbS3WlnVVYHcvv9cuWI,2592
+STEM_Vibrations-0.1.dist-info/LICENSE.md,sha256=ItThzBSD9NsFiIjyl1NuS25EOwpbhoFf85S2wnDTAjY,1501
+STEM_Vibrations-0.1.dist-info/METADATA,sha256=WsKAuN0kUEkWyzc0evF7j54hKrLBpsIuTrs-qPV9YD0,890
+STEM_Vibrations-0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+STEM_Vibrations-0.1.dist-info/top_level.txt,sha256=_Fv_hT3iFjDmFwOMcKq7iIsbarreb2UO1-H2frEcwHU,5
+STEM_Vibrations-0.1.dist-info/RECORD,,

STEM_Vibrations-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

STEM_Vibrations-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+stem

stem/IO/io_utils.py

@@ -0,0 +1,119 @@
+from typing import Sequence, Dict, Any, List, Union, Optional, Tuple
+from pathlib import Path
+import json
+from copy import deepcopy
+
+from stem.table import Table
+from stem.boundary import BoundaryParametersABC
+from stem.load import LoadParametersABC
+
+class IOUtils:
+
+    @staticmethod
+    def write_json_file(output_folder: str, file_name: str, dictionary: Dict[Any, Any]):
+        """
+        Write a dictionary to a json file.
+
+        Args:
+            - output_folder (str): output folder path
+            - file_name (str): name of the json file
+            - dictionary (Dict[Any, Any]): dictionary to be written to the json file
+
+        """
+        # write json file
+        output_folder_pth = Path(output_folder)
+        output_folder_pth.mkdir(exist_ok=True, parents=True)
+
+        output_path_file = output_folder_pth.joinpath(file_name)
+        json.dump(dictionary, open(output_path_file, "w"), indent=4)
+
+    @staticmethod
+    def create_value_and_table(part_name: str, parameters: Union["LoadParametersABC", "BoundaryParametersABC"]) \
+            -> Tuple[List[float], List[int]]:
+        """
+        Assemble values and tables for the boundary condition from the `value` attribute of the boundary parameters.
+        If the displacement or rotation is time-dependent, a `table` is required. If the displacement or rotation is
+        constant, a `value` is required. Each direction (x,y,z), requires either a `table` or a `value`. When a `table`
+        is provided, the `value` is set to 0. If a `value` is provided, the `table` is set to 0.
+
+        Args:
+            - part_name (str): name of the model part on which the boundary is applied.
+            - parameters (Union[:class:`stem.load.LoadParametersABC`, \
+                                :class:`stem.boundary.BoundaryParametersABC`]): boundary parameters object.
+
+        Raises:
+            - ValueError: if table ids are not initialised.
+            - ValueError: when element in `parameters.value` is not of type int, float or Table.
+            - ValueError: when provided parameters class doesn't implement values (e.g. AbsorbingBoundary).
+
+        Returns:
+            - _value (List[float]): list of values for the boundary condition or load
+            - _table (List[int]): list of table ids for the boundary condition \
+                or load
+        """
+
+        _value: List[float] = []
+        _table: List[int] = []
+
+        if hasattr(parameters, "value"):
+
+            # check the values per direction
+            for vv in parameters.value:
+                # if a table is provided, the value is set to 0
+                if isinstance(vv, Table):
+                    if vv.id is None:
+                        raise ValueError(f"Table id is not initialised for values in {parameters.__class__.__name__}"
+                                         f" in model part: {part_name}.")
+                    _table.append(vv.id)
+                    _value.append(0.0)
+                # if a value is provided, the table is set to 0
+                elif isinstance(vv, (int, float)):
+                    _table.append(0)
+                    _value.append(float(vv))
+                else:
+                    raise ValueError(f"'value' attribute in {parameters.__class__.__name__} in model part "
+                                     f"`{part_name}`. The value ({vv}) is a `{vv.__class__.__name__}` object"
+                                     f" but only a Table, float or integer are valid inputs.")
+
+        else:
+            raise ValueError(f"Attribute `value` does not exist in class: {parameters.__class__.__name__}.")
+
+        return _value, _table
+
+    @staticmethod
+    def create_vector_constraint_table_process_dict(global_domain: str, part_name: str,
+                                                    parameters: Union[LoadParametersABC, BoundaryParametersABC],
+                                                    variable_name: str) -> Dict[str, Any]:
+        """
+        Creates a dictionary containing the vector constraint table process parameters. The vector constraint table
+        process is used for loads and boundary conditions. This process applies either a constant value or a
+        time-dependent table to the load or boundary condition.
+
+        Args:
+            - global_domain (str): name of the global domain
+            - part_name (str): name of the model part on which the load is applied
+            - parameters (Union[:class:`stem.load.LoadParametersABC`, \
+                                :class:`stem.boundary.BoundaryParametersABC`]): boundary parameters object.
+            - variable_name (str): name of the variable to which the boundary condition or load is applied
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the load parameters
+        """
+
+        # initialize load dictionary
+        load_dict: Dict[str, Any] = {
+            "python_module": "apply_vector_constraint_table_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name": "ApplyVectorConstraintTableProcess",
+            "Parameters": deepcopy(parameters.__dict__),
+        }
+
+        load_dict["Parameters"]["model_part_name"] = f"{global_domain}.{part_name}"
+        load_dict["Parameters"]["variable_name"] = variable_name
+
+        # get tables and values
+        _value, _table = IOUtils.create_value_and_table(part_name, parameters)
+        load_dict["Parameters"]["table"] = _table
+        load_dict["Parameters"]["value"] = _value
+
+        return load_dict

stem/IO/kratos_additional_processes_io.py

@@ -0,0 +1,115 @@
+from typing import Any, Dict, Union
+
+from stem.additional_processes import *
+
+
+class KratosAdditionalProcessesIO:
+    """
+    Class containing methods for additional Kratos processes
+
+    Attributes:
+        - domain (str): name of the Kratos domain
+
+    """
+
+    def __init__(self, domain: str):
+        """
+        Constructor of KratosBoundariesIO class
+
+        Args:
+            - domain (str): name of the Kratos domain
+
+        """
+        self.domain = domain
+
+    def __create_excavation_dict(
+        self, part_name: str, parameters: Excavation
+    ) -> Dict[str, Any]:
+        """
+        Creates a dictionary containing the parameters for the excavation process
+
+        Args:
+            - part_name (str): part name where the excavation is applied
+            - parameters (:class:`stem.additional_processes.Excavation`): excavation parameters object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the additional process parameters
+        """
+
+        # initialize boundary dictionary
+        process_dict: Dict[str, Any] = {
+            "python_module": "apply_excavation_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name":  "ApplyExcavationProcess",
+            "Parameters": {},
+        }
+
+        process_dict["Parameters"]["model_part_name"] = f"{self.domain}.{part_name}"
+        process_dict["Parameters"]["variable_name"] = "EXCAVATION"
+        process_dict["Parameters"]["deactivate_soil_part"] = parameters.deactivate_body_model_part
+
+        return process_dict
+
+    def __create_parameter_field_dict(
+        self, part_name: str, parameters: ParameterFieldParameters
+    ) -> Dict[str, Any]:
+        """
+        Creates a dictionary containing the parameters for the parameter field process
+
+        Args:
+            - part_name (str): part name where the parameter field is applied
+            - parameters (:class:`stem.additional_processes.ParameterFieldParameters`): parameter field parameters object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the additional process parameters
+        """
+
+        # initialize boundary dictionary
+        process_dict: Dict[str, Any] = {
+            "python_module": "set_parameter_field_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name":  "SetParameterFieldProcess",
+            "Parameters": {},
+        }
+
+        process_dict["Parameters"]["model_part_name"] = f"{self.domain}.{part_name}"
+        process_dict["Parameters"]["variable_name"] = parameters.property_name
+        process_dict["Parameters"]["func_type"] = parameters.function_type
+
+        # initialise to dummy
+        process_dict["Parameters"]["function"] = "dummy"
+        process_dict["Parameters"]["dataset"] = "dummy"
+
+        if parameters.function_type == "json_file":
+
+            process_dict["Parameters"]["dataset_file_name"] = parameters.field_file_name
+        elif parameters.function_type == "input":
+            process_dict["Parameters"]["function"] = parameters.tiny_expr_function
+        else:
+            raise ValueError(f"function type {parameters.function_type} not supported.")
+
+        return process_dict
+
+    def create_additional_processes_dict(
+        self, part_name: str, parameters: AdditionalProcessesParametersABC
+    ) -> Union[Dict[str, Any], None]:
+        """
+        Creates a dictionary containing the boundary parameters
+
+        Args:
+            - part_name (str): part name where the boundary condition is applied
+            - parameters (:class:`stem.additional_processes.AdditionalProcessesParametersABC`): additional process \
+                parameters object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the parameters for the additional process
+        """
+
+        # add boundary parameters to dictionary based on boundary type.
+
+        if isinstance(parameters, Excavation):
+            return self.__create_excavation_dict(part_name, parameters)
+        elif isinstance(parameters, ParameterFieldParameters):
+            return self.__create_parameter_field_dict(part_name, parameters)
+        else:
+            raise NotImplementedError

stem/IO/kratos_boundaries_io.py

@@ -0,0 +1,78 @@
+from copy import deepcopy
+from typing import Any, Dict, Union, List
+
+from stem.boundary import *
+from stem.IO.io_utils import IOUtils
+
+
+class KratosBoundariesIO:
+    """
+    Class containing methods to write boundary conditions to Kratos
+
+    Attributes:
+        - domain (str): name of the Kratos domain
+
+    """
+
+    def __init__(self, domain: str):
+        """
+        Constructor of KratosBoundariesIO class
+
+        Args:
+            - domain (str): name of the Kratos domain
+
+        """
+        self.domain = domain
+
+    def __create_absorbing_boundary_dict(
+        self, part_name: str, parameters: AbsorbingBoundary
+    ) -> Dict[str, Any]:
+        """
+        Creates a dictionary containing the absorbing boundary parameters
+
+        Args:
+            - part_name (str): part name where the boundary condition is applied
+            - parameters (:class:`stem.boundary.AbsorbingBoundary`): absorbing boundary parameters object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the boundary parameters
+        """
+
+        # initialize boundary dictionary
+        boundary_dict: Dict[str, Any] = {
+            "python_module": "set_absorbing_boundary_parameters_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name": "SetAbsorbingBoundaryParametersProcess",
+            "Parameters": deepcopy(parameters.__dict__),
+        }
+
+        boundary_dict["Parameters"]["model_part_name"] = f"{self.domain}.{part_name}"
+
+        return boundary_dict
+
+    def create_boundary_condition_dict(
+        self, part_name: str, parameters: BoundaryParametersABC
+    ) -> Union[Dict[str, Any], None]:
+        """
+        Creates a dictionary containing the boundary parameters
+
+        Args:
+            - part_name (str): part name where the boundary condition is applied
+            - parameters (:class:`stem.boundary.BoundaryParametersABC`): boundary parameters object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the boundary parameters
+        """
+
+        # add boundary parameters to dictionary based on boundary type.
+
+        if isinstance(parameters, DisplacementConstraint):
+            return IOUtils.create_vector_constraint_table_process_dict(self.domain, part_name, parameters,
+                                                                       "DISPLACEMENT")
+        elif isinstance(parameters, RotationConstraint):
+            return IOUtils.create_vector_constraint_table_process_dict(self.domain, part_name, parameters,
+                                                                       "ROTATION")
+        elif isinstance(parameters, AbsorbingBoundary):
+            return self.__create_absorbing_boundary_dict(part_name, parameters)
+        else:
+            raise NotImplementedError