STEM-Vibrations 0.1__tar.gz

STEM-Vibrations-0.1/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/PKG-INFO

@@ -0,0 +1,24 @@
+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: 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"
+Provides-Extra: docs
+Requires-Dist: Sphinx==6.2.1; extra == "docs"
+Requires-Dist: sphinx-rtd-theme==1.2.2; extra == "docs"

STEM-Vibrations-0.1/README.md

@@ -0,0 +1,35 @@
+```
+     _______..___________. _______ .___  ___.
+    /       ||           ||   ____||   \/   |
+   |   (----``---|  |----`|  |__   |  \  /  |
+    \   \        |  |     |   __|  |  |\/|  |
+.----)   |       |  |     |  |____ |  |  |  |
+|_______/        |__|     |_______||__|  |__|
+
+```
+
+# STEM: Soil and Track System Modeling Tool
+
+![Tests](https://github.com/StemVibrations/STEM/actions/workflows/tests.yml/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/stemvibrations/badge/?version=latest)](https://stemvibrations.readthedocs.io/badge=latest)
+[![codecov](https://codecov.io/gh/stemvibrations/stem/graph/badge.svg?token=0DMYCZF4BU)](https://codecov.io/gh/stemvibrations/stem)
+
+The STEM model is designed to create and analyse models of soil and track systems.
+The tool provides a set of commands for creating the geometry of the model, defining the soil and track properties, setting the boundary conditions and loads, generating the mesh, and performing post-processing on the results.
+
+## Installation
+
+STEM can be downloaded and installed on any system that supports Python.
+To install the STEM, follow the following steps:
+
+```python
+pip install git+https://github.com/StemVibrations/STEM.git
+```
+
+It is also needed to download Kratos Multiphysics. Kratos Multiphysics can be downloaded [here](https://github.com/StemVibrations/StemKratos).
+
+Further details about the installation can be found [here](https://stemvibrations.readthedocs.io/).
+
+## Usage
+
+To use STEM please refer to the tutorials available [here](https://stemvibrations.readthedocs.io/).

STEM-Vibrations-0.1/STEM_Vibrations.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+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: 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"
+Provides-Extra: docs
+Requires-Dist: Sphinx==6.2.1; extra == "docs"
+Requires-Dist: sphinx-rtd-theme==1.2.2; extra == "docs"

STEM-Vibrations-0.1/STEM_Vibrations.egg-info/SOURCES.txt

@@ -0,0 +1,63 @@
+LICENSE.md
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+STEM_Vibrations.egg-info/PKG-INFO
+STEM_Vibrations.egg-info/SOURCES.txt
+STEM_Vibrations.egg-info/dependency_links.txt
+STEM_Vibrations.egg-info/not-zip-safe
+STEM_Vibrations.egg-info/requires.txt
+STEM_Vibrations.egg-info/top_level.txt
+stem/__init__.py
+stem/__version__.py
+stem/additional_processes.py
+stem/boundary.py
+stem/default_materials.py
+stem/field_generator.py
+stem/geometry.py
+stem/globals.py
+stem/load.py
+stem/mesh.py
+stem/model.py
+stem/model_part.py
+stem/output.py
+stem/plot_utils.py
+stem/soil_material.py
+stem/solver.py
+stem/stem.py
+stem/structural_material.py
+stem/table.py
+stem/utils.py
+stem/water_processes.py
+stem/IO/__init__.py
+stem/IO/io_utils.py
+stem/IO/kratos_additional_processes_io.py
+stem/IO/kratos_boundaries_io.py
+stem/IO/kratos_io.py
+stem/IO/kratos_loads_io.py
+stem/IO/kratos_material_io.py
+stem/IO/kratos_output_io.py
+stem/IO/kratos_solver_io.py
+stem/IO/kratos_water_processes_io.py
+tests/test_additional_processes.py
+tests/test_default_materials.py
+tests/test_generator.py
+tests/test_geometry.py
+tests/test_globals.py
+tests/test_kratos_additional_processes_io.py
+tests/test_kratos_boundaries_io.py
+tests/test_kratos_io.py
+tests/test_kratos_loads_io.py
+tests/test_kratos_material_io.py
+tests/test_kratos_outputs_io.py
+tests/test_kratos_solver_io.py
+tests/test_kratos_water_processes_io.py
+tests/test_mesh.py
+tests/test_model.py
+tests/test_model_part.py
+tests/test_plot_utils.py
+tests/test_soil_material.py
+tests/test_structural_material.py
+tests/test_table.py
+tests/test_utils.py

STEM-Vibrations-0.1/STEM_Vibrations.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

STEM-Vibrations-0.1/STEM_Vibrations.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

STEM-Vibrations-0.1/STEM_Vibrations.egg-info/requires.txt

@@ -0,0 +1,15 @@
+numpy>=1.24
+scipy>=1.10.1
+plotly>=5.15.0
+
+[docs]
+Sphinx==6.2.1
+sphinx-rtd-theme==1.2.2
+
+[testing]
+pytest>=7.2
+pytest-cov>=4.0
+tox>=4.4
+mypy>=1.1
+beautifulsoup4>=4.12
+matplotlib==3.7.4

STEM-Vibrations-0.1/STEM_Vibrations.egg-info/top_level.txt

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

STEM-Vibrations-0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

STEM-Vibrations-0.1/setup.cfg

@@ -0,0 +1,43 @@
+[metadata]
+name = STEM-Vibrations
+version = attr: stem.__version__
+author = attr: stem.__author__
+description = STEM model
+long_description = file: ReadMe.md
+long_description_content_type = text/markdown
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: BSD License
+	Operating System :: OS Independent
+
+[options]
+packages = 
+	stem
+	stem.IO
+include_package_data = True
+install_requires = 
+	numpy>=1.24
+	scipy>=1.10.1
+	plotly>=5.15.0
+python_requires = >=3.8
+zip_safe = False
+find_links = 
+	git+https://github.com/StemVibrations/gmsh_utils
+	git+https://github.com/StemVibrations/RandomFields
+
+[options.extras_require]
+testing = 
+	pytest>=7.2
+	pytest-cov>=4.0
+	tox>=4.4
+	mypy>=1.1
+	beautifulsoup4>=4.12
+	matplotlib==3.7.4
+docs = 
+	Sphinx==6.2.1
+	sphinx-rtd-theme==1.2.2
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

STEM-Vibrations-0.1/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == '__main__':
+    setup()

STEM-Vibrations-0.1/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-Vibrations-0.1/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-Vibrations-0.1/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