UVEC 1.1.0__tar.gz

uvec-1.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023-2025, 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.

uvec-1.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.2
+Name: UVEC
+Version: 1.1.0
+Summary: User defined VEhiCle models [UVEC]
+Author: attr: UVEC.__author__
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Unix
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: matplotlib>=3.9.3
+Provides-Extra: testing
+Requires-Dist: pytest>=8.3; extra == "testing"
+Requires-Dist: pytest-cov>=6.0; extra == "testing"
+Requires-Dist: tox>=4.23; extra == "testing"
+Requires-Dist: mypy>=1.13; extra == "testing"
+Requires-Dist: yapf>=0.43; extra == "testing"
+
+![Tests](https://github.com/StemVibrations/vehicle_models/actions/workflows/workflow.yml/badge.svg)
+[![codecov](https://codecov.io/gh/StemVibrations/vehicle_models/graph/badge.svg?token=0SCPA6LAGT)](https://codecov.io/gh/StemVibrations/vehicle_models)
+
+
+# User defined VEhiCle models [UVEC]
+
+This repository contains the User defined VEhiCle models [UVEC] for STEM.
+
+At the moment, the following vehicle models are available:
+
+* `ten_dof_vehicle_2D`: 2-dimensional 10 degrees-of-freedom vehicle model (based on [Zhai and Sun, 1994](https://www.tandfonline.com/doi/abs/10.1080/00423119308969544))
+
+* `two_dof_vehicle_2D`: 2-dimensional 2 degrees-of-freedom vehicle model (based on [Lou and Zeng, 2004](https://onlinelibrary.wiley.com/doi/epdf/10.1002/nme.1207))
+
+
+Project structure:
+
+UVEC
+├── README.md
+├── requirements.txt
+├── setup.cfg
+├── UVEC
+│   |── __init__.py
+│   ├── uvec_ten_dof_vehicle_2D
+│   │   ├── __init__.py
+│   │   ├── ten_dof_vehicle_2D.py
+│   │   └── base_model.py
+│   ├── uvec_two_dof_vehicle_2D
+│   │   ├── __init__.py
+│   │   ├── ten_dof_vehicle_2D.py
+│   │   └── base_model.py

uvec-1.1.0/README.md

@@ -0,0 +1,31 @@
+![Tests](https://github.com/StemVibrations/vehicle_models/actions/workflows/workflow.yml/badge.svg)
+[![codecov](https://codecov.io/gh/StemVibrations/vehicle_models/graph/badge.svg?token=0SCPA6LAGT)](https://codecov.io/gh/StemVibrations/vehicle_models)
+
+
+# User defined VEhiCle models [UVEC]
+
+This repository contains the User defined VEhiCle models [UVEC] for STEM.
+
+At the moment, the following vehicle models are available:
+
+* `ten_dof_vehicle_2D`: 2-dimensional 10 degrees-of-freedom vehicle model (based on [Zhai and Sun, 1994](https://www.tandfonline.com/doi/abs/10.1080/00423119308969544))
+
+* `two_dof_vehicle_2D`: 2-dimensional 2 degrees-of-freedom vehicle model (based on [Lou and Zeng, 2004](https://onlinelibrary.wiley.com/doi/epdf/10.1002/nme.1207))
+
+
+Project structure:
+
+UVEC
+├── README.md
+├── requirements.txt
+├── setup.cfg
+├── UVEC
+│   |── __init__.py
+│   ├── uvec_ten_dof_vehicle_2D
+│   │   ├── __init__.py
+│   │   ├── ten_dof_vehicle_2D.py
+│   │   └── base_model.py
+│   ├── uvec_two_dof_vehicle_2D
+│   │   ├── __init__.py
+│   │   ├── ten_dof_vehicle_2D.py
+│   │   └── base_model.py

uvec-1.1.0/UVEC/__init__.py

@@ -0,0 +1 @@
+from .__version__ import __version__, __title__

uvec-1.1.0/UVEC/__version__.py

@@ -0,0 +1,3 @@
+__title__ = "UVEC"
+__version__ = "1.1.0"
+__author__ = "STEM team"

uvec-1.1.0/UVEC/get_path_uvec.py

@@ -0,0 +1,83 @@
+import os
+import json
+import site
+import sysconfig
+
+from .__version__ import __version__, __title__
+
+
+def editable_path(folder_path: str) -> str:
+    """
+    Collect the package location when installed in editable mode.
+
+    Args:
+        - folder_path (str): Path to the system package folder
+
+    Returns:
+        - str: Path to the package installed in editable mode
+
+    """
+    with open(os.path.join(folder_path, "direct_url.json"), "r") as f:
+        data = json.load(f)
+
+    path_package = data["url"].split("file://")[1]
+
+    with open(os.path.join(folder_path, "top_level.txt"), "r") as f:
+        packages = f.read().splitlines()
+
+    return os.path.join(path_package, packages[0])
+
+
+def is_installed_editable(package_name: str) -> bool:
+    """
+    Checks if the given package is installed in editable mode.
+    Returns True if installed in editable mode, otherwise False.
+
+    Args:
+        - package_name (str): Name of the package to check.
+
+    Returns:
+        - bool: True if installed in editable mode, otherwise False.
+    """
+
+    return os.path.isfile(os.path.join(site.getsitepackages()[0], f"__editable__.{package_name}.pth"))
+
+
+def get_package_path() -> str:
+    """
+    Gets the path to the current package in the site-packages directory.
+
+    Returns:
+        - str: Path to the package.
+    """
+
+    package_name = "-".join([__title__, __version__])
+    site_packages_path = sysconfig.get_paths()["purelib"]
+    dist_info_path = os.path.join(site_packages_path, f"{package_name}.dist-info")
+
+    is_editable = is_installed_editable(package_name)
+
+    if not is_editable:
+        # if installed in regular mode
+        site_packages_path = sysconfig.get_paths()["purelib"]
+        package_path = os.path.join(site_packages_path, __name__.split(".")[0])
+        return package_path
+    else:
+        # if installed in editable mode
+        return editable_path(dist_info_path)
+
+
+def get_path_file(uvec_name: str) -> str:
+    """
+    Sets the global path_file variable and performs the copy operation.
+
+    Args:
+        - uvec_name (str): Name of the uvec file to copy.
+
+    Returns:
+        - str: Global path to the uvec file.
+    """
+
+    package_path = get_package_path()
+
+    return os.path.join(package_path, uvec_name)

uvec-1.1.0/UVEC/uvec_ten_dof_vehicle_2D/__init__.py

@@ -0,0 +1,3 @@
+from UVEC.get_path_uvec import get_path_file
+
+UVEC_NAME = "uvec_ten_dof_vehicle_2D"

uvec-1.1.0/UVEC/uvec_ten_dof_vehicle_2D/base_model.py

@@ -0,0 +1,348 @@
+import numpy as np
+
+GRAVITY = 9.81
+
+
+class Cart():
+    """
+    Cart class
+
+    Attributes:
+        - bogies (list): list of bogies
+        - dofs (list): list of degrees of freedom
+    """
+
+    def __init__(self):
+        """
+        Initialise the cart
+        """
+        self.bogies = []
+        self.dofs = []
+
+
+class Bogie():
+    """
+    Bogie class
+
+    Attributes:
+        - wheels (list): list of wheels
+        - dofs (list): list of degrees of freedom
+    """
+
+    def __init__(self):
+        """
+        Initialise the bogie
+        """
+        self.wheels = []
+        self.dofs = []
+
+
+class Wheel():
+    """
+    Wheel class
+
+    Attributes:
+        - dofs (list): list of degrees of freedom
+    """
+
+    def __init__(self):
+        self.dofs = []
+
+
+class TrainModel():
+
+    def __init__(self):
+
+        self.n_carts = None
+        self.n_bogies = None
+        self.n_wheels = None
+
+        self.cart_inertia = None
+        self.cart_mass = None
+        self.cart_stiffness = None
+        self.cart_damping = None
+        self.bogie_distances = None
+        self.bogie_inertia = None
+        self.bogie_mass = None
+        self.wheel_inertia = None
+        self.wheel_mass = None
+        self.wheel_stiffness = None
+        self.wheel_damping = None
+        self.wheel_distances = None
+
+        self.carts = []
+
+        self.ndof = None
+        self.contact_dofs = []
+
+        self.contact_coeff = None
+        self.contact_power = None
+
+    def initialise(self):
+        """
+        Initialise the train system
+
+        :return:
+        """
+        self.generate_components()
+        self.set_dofs()
+
+    def calculate_n_elements(self):
+        """
+        Calculate the number of bogies and wheels in the train system
+
+        :return:
+        """
+
+        self.n_bogies = len(self.bogie_distances)
+        self.n_wheels = len(self.wheel_distances)
+
+    def generate_components(self):
+        """
+        Generate the train components, i.e. wheels, bogies and carts
+
+        :return:
+        """
+
+        self.calculate_n_elements()
+
+        for i in range(self.n_carts):
+            cart = Cart()
+            for j in range(self.n_bogies):
+                bogie = Bogie()
+                for k in range(len(self.wheel_distances)):
+                    wheel = Wheel()
+                    bogie.wheels.append(wheel)
+                cart.bogies.append(bogie)
+            self.carts.append(cart)
+
+    def set_dofs(self):
+        """
+        Set the degrees of freedom for each component and calculate the total number of degrees of freedom
+
+        :return:
+        """
+
+        i_dof = 0
+
+        for cart in self.carts:
+            # cart has displacement and rotation dof
+            cart.dofs = [i_dof, i_dof + 1]
+            i_dof += 2
+
+            for bogie in cart.bogies:
+                # bogie has displacement and rotation dof
+                bogie.dofs = [i_dof, i_dof + 1]
+                i_dof += 2
+
+                for wheel in bogie.wheels:
+                    # wheel has displacement dof
+                    wheel.dofs = [i_dof]
+                    self.contact_dofs.append(i_dof)
+                    i_dof += 1
+
+        self.ndof = i_dof
+
+    def generate_mass_matrix(self):
+        """
+        Generate the mass matrix
+        """
+
+        mass_matrix = np.zeros((self.ndof, self.ndof))
+
+        for cart in self.carts:
+            mass_matrix[cart.dofs[0], cart.dofs[0]] += self.cart_mass
+            mass_matrix[cart.dofs[1], cart.dofs[1]] += self.cart_inertia
+
+            for bogie in cart.bogies:
+                mass_matrix[bogie.dofs[0], bogie.dofs[0]] += self.bogie_mass
+                mass_matrix[bogie.dofs[1], bogie.dofs[1]] += self.bogie_inertia
+
+                for wheel in bogie.wheels:
+                    mass_matrix[wheel.dofs[0], wheel.dofs[0]] += self.wheel_mass
+
+        return mass_matrix
+
+    def generate_stiffness_matrix(self):
+        """
+        Generate stiffness matrix
+        """
+        stiffness_matrix = np.zeros((self.ndof, self.ndof))
+
+        for cart in self.carts:
+            stiffness_matrix[cart.dofs[0], cart.dofs[0]] += self.cart_stiffness * len(cart.bogies)
+
+            for b, bogie in enumerate(cart.bogies):
+                stiffness_matrix[cart.dofs[1], cart.dofs[1]] += self.cart_stiffness * self.bogie_distances[b]**2
+
+                stiffness_matrix[cart.dofs[0], bogie.dofs[0]] += -self.cart_stiffness
+                stiffness_matrix[bogie.dofs[0], cart.dofs[0]] += -self.cart_stiffness
+
+                stiffness_matrix[cart.dofs[1], bogie.dofs[0]] += self.cart_stiffness * self.bogie_distances[b]
+                stiffness_matrix[bogie.dofs[0], cart.dofs[1]] += self.cart_stiffness * self.bogie_distances[b]
+
+                stiffness_matrix[bogie.dofs[0], bogie.dofs[0]] += self.cart_stiffness
+
+                stiffness_matrix[bogie.dofs[0], bogie.dofs[0]] += self.wheel_stiffness * len(bogie.wheels)
+
+                for w, wheel in enumerate(bogie.wheels):
+
+                    stiffness_matrix[bogie.dofs[1], bogie.dofs[1]] += self.wheel_stiffness * self.wheel_distances[w]**2
+                    stiffness_matrix[bogie.dofs[0], wheel.dofs[0]] += -self.wheel_stiffness
+                    stiffness_matrix[wheel.dofs[0], bogie.dofs[0]] += -self.wheel_stiffness
+
+                    stiffness_matrix[bogie.dofs[1], wheel.dofs[0]] += self.wheel_stiffness * self.wheel_distances[w]
+                    stiffness_matrix[wheel.dofs[0], bogie.dofs[1]] += self.wheel_stiffness * self.wheel_distances[w]
+
+                    stiffness_matrix[wheel.dofs[0], wheel.dofs[0]] += self.wheel_stiffness
+
+        return stiffness_matrix
+
+    def generate_damping_matrix(self):
+        """
+        Generate damping matrix
+
+        :return:
+        """
+
+        damping_matrix = np.zeros((self.ndof, self.ndof))
+
+        for cart in self.carts:
+            damping_matrix[cart.dofs[0], cart.dofs[0]] += self.cart_damping * len(cart.bogies)
+
+            for b, bogie in enumerate(cart.bogies):
+                damping_matrix[cart.dofs[1], cart.dofs[1]] += self.cart_damping * self.bogie_distances[b]**2
+
+                damping_matrix[cart.dofs[0], bogie.dofs[0]] += -self.cart_damping
+                damping_matrix[bogie.dofs[0], cart.dofs[0]] += -self.cart_damping
+
+                damping_matrix[cart.dofs[1], bogie.dofs[0]] += self.cart_damping * self.bogie_distances[b]
+                damping_matrix[bogie.dofs[0], cart.dofs[1]] += self.cart_damping * self.bogie_distances[b]
+
+                damping_matrix[bogie.dofs[0], bogie.dofs[0]] += self.cart_damping
+
+                damping_matrix[bogie.dofs[0], bogie.dofs[0]] += self.wheel_damping * len(bogie.wheels)
+                for w, wheel in enumerate(bogie.wheels):
+                    damping_matrix[bogie.dofs[1], bogie.dofs[1]] += self.wheel_damping * self.wheel_distances[w]**2
+                    damping_matrix[bogie.dofs[0], wheel.dofs[0]] += -self.wheel_damping
+                    damping_matrix[wheel.dofs[0], bogie.dofs[0]] += -self.wheel_damping
+
+                    damping_matrix[bogie.dofs[1], wheel.dofs[0]] += self.wheel_damping * self.wheel_distances[w]
+                    damping_matrix[wheel.dofs[0], bogie.dofs[1]] += self.wheel_damping * self.wheel_distances[w]
+
+                    damping_matrix[wheel.dofs[0], wheel.dofs[0]] += self.wheel_damping
+
+        return damping_matrix
+
+    def generate_force_vector(self):
+        """
+        Generate force vector
+        """
+        force_vector = np.zeros(self.ndof)
+
+        for cart in self.carts:
+            force_vector[cart.dofs[0]] = -self.cart_mass * GRAVITY
+
+            for bogie in cart.bogies:
+                force_vector[bogie.dofs[0]] = -self.bogie_mass * GRAVITY
+
+                for wheel in bogie.wheels:
+                    force_vector[wheel.dofs[0]] = -self.wheel_mass * GRAVITY
+
+        return force_vector
+
+    def calculate_static_contact_force(self):
+        """
+        Calculate static contact force
+
+        :return:
+        """
+
+        contact_forces = []
+
+        # Calculate static contact force
+        for cart in self.carts:
+            distributed_load_cart = self.cart_mass * -GRAVITY / len(cart.bogies)
+
+            for bogie in cart.bogies:
+
+                distributed_load_bogie = (self.bogie_mass * -GRAVITY + distributed_load_cart) / len(bogie.wheels)
+
+                for _ in bogie.wheels:
+                    contact_force = self.wheel_mass * -GRAVITY + distributed_load_bogie
+                    contact_forces.append(contact_force)
+
+        return np.array(contact_forces)
+
+    def apply_dirichlet_bc(self, A, b, bc_indices):
+        """
+        Apply Dirichlet boundary conditions to a stiffness matrix and force vector.
+
+        :param A: The stiffness matrix.
+        :param b: The force vector.
+        :param bc_indices: The indices at which to apply the boundary conditions.
+
+        :returns: The modified stiffness matrix and force vector.
+        """
+
+        # Replace the i-th row of A with the unit vector.
+        for index in bc_indices:
+            # Replace the i-th row of A with the unit vector.
+            A[index, :] = 0.0
+            A[:, index] = 0.0
+            A[index, index] = 1.0
+
+            b[index] = 0.0
+
+        return A, b
+
+    def calculate_initial_displacement(self, K, F, u_wheels):
+        """
+        Calculate initial displacement
+
+        :param K: stiffness matrix
+        :param F: force vector
+        :param u_wheels: initial displacement of the wheels
+        :return:
+        """
+
+        # apply dirichlet boundary condition
+        u = np.zeros(self.ndof)
+        u[self.contact_dofs] = u_wheels
+
+        F_internal = K.dot(u)
+        F_total = F - F_internal
+
+        K_constr, F_constr, = self.apply_dirichlet_bc(np.copy(K), np.copy(F_total), self.contact_dofs)
+
+        # Solve the linear system.
+        u = np.linalg.solve(K_constr, F_constr)
+
+        # # add dirichlet boundary condition
+        u[self.contact_dofs] = u_wheels
+
+        return u
+
+    def generate_global_matrices(self):
+        """
+        Generate global matrices
+
+        and apply dirichlet boundary condition on elements without mass or inertia term
+        :return:
+        """
+
+        K = self.generate_stiffness_matrix()
+        C = self.generate_damping_matrix()
+        M = self.generate_mass_matrix()
+        F = self.generate_force_vector()
+
+        # dirichlet constraint on elements without mass or intertia term
+        tolerance = 1e-10
+        mask = np.abs(np.diag(M)) < tolerance
+
+        np.fill_diagonal(M, np.where(mask, 1, np.diag(M)))
+        np.fill_diagonal(K, np.where(mask, 1, np.diag(K)))
+        np.fill_diagonal(C, np.where(mask, 1, np.diag(C)))
+        F[mask] = 0
+
+        return K, C, M, F

uvec-1.1.0/UVEC/uvec_ten_dof_vehicle_2D/hertzian_contact.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+
+class HertzianContact():
+    """
+    Hertzian contact model
+
+    Attributes:
+        - contact_coeff (float): contact coefficient
+        - contact_power (float): contact power
+    """
+
+    def __init__(self):
+        """
+        Constructor of the HertzianContact class
+        """
+        self.contact_coeff = None  # contact coefficient
+        self.contact_power = None  # contact power
+
+    def calculate_contact_force(self, du: np.ndarray) -> np.ndarray:
+        """
+        Calculate contact force
+
+        Args:
+            - du (np.ndarray): contact deformation
+
+        Returns:
+            - np.ndarray: contact force
+        """
+
+        contact_force = np.sign(-du) * np.nan_to_num((1 / self.contact_coeff * -du)**self.contact_power)
+        return contact_force
+
+    def calculate_contact_deformation(self, F: np.ndarray) -> np.ndarray:
+        """
+        Calculate contact deformation
+
+        Args:
+            - F (np.ndarray): contact force
+
+        Returns:
+            - np.ndarray: contact deformation
+        """
+
+        return np.sign(F) * self.contact_coeff * np.abs(F)**(1 / self.contact_power)

uvec-1.1.0/UVEC/uvec_ten_dof_vehicle_2D/irregularities.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+
+def calculate_rail_irregularity(x: float,
+                                f_min: float = 2,
+                                f_max: float = 500,
+                                N: int = 2000,
+                                Av: float = 0.00002095,
+                                omega_c: float = 0.8242,
+                                seed: int = 14) -> float:
+    """
+     Creates rail unevenness following :cite: `zhang_2001`.
+
+    A summary of default values can be found in : cite: `Podworna_2015`.
+
+    Args:
+        - x (float) : position of the node [m]
+        - f_min (float): minimum spatial frequency for the PSD of the unevenness [1/m] (default 2 1/m)
+        - f_max: (float) maximum spatial frequency for the PSD of the unevenness [1/m] (default 500 1/m)
+        - N (int): number of frequency increments [-] (default 2000)
+        - Av (float): vertical track irregularity parameters [m2 rad/m]  (default 0.00002095 m2 rad/m)
+        - omega_c (float): critical wave number [rad/m] (default 0.8242 rad/m)
+        - seed: (int) seed for random generator [-] (default 14)
+
+    Returns:
+        - irregularity (float): irregularity at the node [m]
+    """
+
+    # random generator
+    random_generator = np.random.default_rng(seed)
+
+    # define omega range
+    omega_max = 2 * np.pi * f_max
+    omega_min = 2 * np.pi * f_min
+    delta_omega = (omega_max - omega_min) / N
+
+    # for each frequency increment
+    omega_n = omega_min + delta_omega * np.arange(N)
+    phi = random_generator.uniform(0, 2 * np.pi, N)
+    irregularity = np.sum(np.sqrt(4 * spectral(omega_n, Av, omega_c) * delta_omega) * np.cos(omega_n * x - phi))
+
+    return irregularity
+
+
+def spectral(omega: np.ndarray, Av: float, omega_c: float) -> np.ndarray:
+    """
+    Computes spectral unevenness
+
+    Args:
+        - omega (np.ndarray): wave number [rad/m]
+        - Av (float): vertical track irregularity parameters [m2 rad/m]
+        - omega_c (float): critical wave number [rad/m]
+
+    Returns:
+        - spectral_unevenness (np.ndarray): spectral unevenness [m3 / rad]
+    """
+
+    spectral_unevenness = 2 * np.pi * Av * omega_c**2 / ((omega**2 + omega_c**2) * omega**2)
+    return spectral_unevenness