UVEC 1.1.0__py3-none-any.whl

UVEC/__init__.py

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

UVEC/__version__.py

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

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/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/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/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/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

UVEC/uvec_ten_dof_vehicle_2D/newmark_solver.py

@@ -0,0 +1,105 @@
+from typing import Tuple
+import numpy as np
+
+
+class StaticSolver():
+    """
+    Class for static solver
+    """
+
+    def __init__(self):
+        pass
+
+    def calculate(self, K: np.ndarray, F: np.ndarray) -> np.ndarray:
+        """
+        Calculate the displacement of a statically loaded structure
+
+        Args:
+            - K (np.ndarray): stiffness matrix
+            - F (np.ndarray): force vector
+
+        Returns:
+            - np.ndarray: displacement vector
+        """
+        return np.linalg.solve(K, F)
+
+
+class NewmarkExplicit():
+    """
+    Newmark integration scheme for explicit time integration
+
+    Attributes:
+        - beta (float): beta parameter
+        - gamma (float): gamma parameter
+    """
+
+    def __init__(self, beta: float = 0.25, gamma: float = 0.5):
+        """
+        Constructor of the NewmarkExplicit class
+
+        Args:
+            - beta (float): beta parameter
+            - gamma (float): gamma parameter
+        """
+        self.beta = beta
+        self.gamma = gamma
+
+    def calculate(self, M: np.ndarray, C: np.ndarray, K: np.ndarray, F: np.ndarray, dt: float, t_index: int,
+                  u_ini: np.ndarray, v_ini: np.ndarray, a_ini: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Newmark integration step.
+
+        Args:
+            - M (np.ndarray): mass matrix
+            - C (np.ndarray): damping matrix
+            - K (np.ndarray): stiffness matrix
+            - F (np.ndarray): force vector
+            - dt (float): time step
+            - t_index (int): time index
+            - u_ini (np.ndarray): initial displacement
+            - v_ini (np.ndarray): initial velocity
+            - a_ini (np.ndarray): initial acceleration
+
+        Returns:
+            - Tuple[np.ndarray, np.ndarray, np.ndarray]: tuple containing the new displacement, velocity and \
+                acceleration
+        """
+
+        # calculate time step size
+
+        # constants for the Newmark integration
+        beta = self.beta
+        gamma = self.gamma
+
+        # initial acceleration
+
+        if t_index == 0:
+            a_ini = np.linalg.solve(M, F - C.dot(v_ini) - K.dot(u_ini))
+
+        # calculate newmark constants
+        a0 = 1 / (beta * dt**2)
+        a1 = gamma / (beta * dt)
+        a2 = 1 / (beta * dt)
+        a3 = 1 / (2 * beta) - 1
+        a4 = gamma / beta - 1
+        a5 = dt / 2 * (gamma / beta - 2)
+        # a5 = gamma/beta - 2*dt/2
+        a6 = dt * (1 - gamma)
+        a7 = gamma * dt
+
+        # calculate effective stiffness matrix
+        K_eff = K + a0 * M + a1 * C
+
+        # calculate effective force vector
+        m_part = M @ (a0 * u_ini + a2 * v_ini + a3 * a_ini)
+        c_part = C @ (a1 * u_ini + a4 * v_ini + a5 * a_ini)
+        force_eff = F + m_part + c_part
+
+        # solve for displacement
+        u = np.linalg.solve(K_eff, force_eff)
+
+        # solve for acceleration and velocity
+        a = a0 * (u - u_ini) - a2 * v_ini - a3 * a_ini
+        v = v_ini + a6 * a_ini + a7 * a
+
+        return u, v, a

UVEC/uvec_ten_dof_vehicle_2D/uvec.py

@@ -0,0 +1,286 @@
+import json
+import numpy as np
+from typing import Tuple, List
+
+from UVEC.uvec_ten_dof_vehicle_2D.base_model import TrainModel
+from UVEC.uvec_ten_dof_vehicle_2D.hertzian_contact import HertzianContact
+from UVEC.uvec_ten_dof_vehicle_2D.newmark_solver import NewmarkExplicit
+from UVEC.uvec_ten_dof_vehicle_2D.irregularities import calculate_rail_irregularity
+
+
+def uvec(json_string: str) -> str:
+    """
+    Args:
+        - json_string (str): json string containing the uvec data
+
+    Returns:
+        - str: json string containing the load data
+    """
+
+    # Get the uvec data
+    uvec_data = json.loads(json_string)
+
+    # Check if analysis is static
+    static = uvec_data["parameters"]["static_initialisation"]
+
+    if static:
+        uvec_data = compute_static_solution(uvec_data)
+    else:
+        uvec_data = compute_dynamic_solution(uvec_data)
+
+    return json.dumps(uvec_data)
+
+
+def compute_static_solution(uvec_data: dict) -> dict:
+    """
+    Compute the static solution for the UVEC
+
+    Args:
+        - uvec_data (dict): dictionary containing the UVEC data
+
+    Returns:
+        - dict: dictionary containing the UVEC data
+    """
+
+    u = uvec_data["u"]
+    # theta = uvec_data["theta"]
+    time_index = uvec_data["time_index"]
+    time_step = uvec_data["dt"]
+    state = uvec_data["state"]
+
+    # Get the uvec parameters
+    parameters = uvec_data["parameters"]
+
+    # initialise the train system
+    (_, _, K, F_train), train = initialise(time_index, parameters, state)
+
+    # calculate norm of u vector, gravity is downwards
+    gravity_axis = parameters["gravity_axis"]
+
+    u_vertical = [u[uw][gravity_axis] for uw in u.keys()]
+
+    if time_index <= 0:
+        state["previous_time"] = 0
+        state["previous_time_index"] = time_index
+
+        if "wheel_configuration" in parameters.keys():
+            state["current_position"] = [position for position in parameters["wheel_configuration"]]
+
+    if time_index > state["previous_time_index"]:
+        state["previous_time"] += time_step
+
+        if "wheel_configuration" in parameters.keys():
+            for i in range(len(parameters["wheel_configuration"])):
+                state["current_position"][i] = state["current_position"][i] + parameters["velocity"] * time_step
+
+    # check if vertical track irregularity parameter is present and add irregularities if required
+    if "irr_parameters" in parameters.keys():
+        irregularity_parameters = parameters["irr_parameters"]
+
+        for i in range(len(u_vertical)):
+            u_vertical[i] = (calculate_rail_irregularity(state["current_position"][i], **irregularity_parameters) +
+                             u_vertical[i])
+
+    # calculate static displacement
+    u_static = train.calculate_initial_displacement(K, F_train, u_vertical)
+
+    state["u"] = u_static.tolist()
+    state["v"] = np.zeros_like(u_static).tolist()
+    state["a"] = np.zeros_like(u_static).tolist()
+
+    # # calculate contact forces
+    F_contact = -train.calculate_static_contact_force()
+
+    # calculate unit vector
+    aux = {}
+    for i, val in enumerate(F_contact):
+        aux[i + 1] = [0., (-val).tolist(), 0.]
+    uvec_data["loads"] = aux
+
+    state["previous_time_index"] = time_index
+
+    return uvec_data
+
+
+def compute_dynamic_solution(uvec_data: dict) -> dict:
+    """
+    Compute the dynamic solution for the UVEC
+
+    Args:
+        - uvec_data (dict): dictionary containing the UVEC data
+
+    Returns:
+        - dict: dictionary containing the UVEC data
+    """
+
+    u = uvec_data["u"]
+    # theta = uvec_data["theta"]
+    time_index = uvec_data["time_index"]
+    time_step = uvec_data["dt"]
+    state = uvec_data["state"]
+
+    # Get the uvec parameters
+    parameters = uvec_data["parameters"]
+
+    # initialise the train system
+    (M, C, K, F_train), train = initialise(time_index, parameters, state)
+
+    # calculate norm of u vector, gravity is downwards
+    gravity_axis = parameters["gravity_axis"]
+
+    u_vertical = [u[uw][gravity_axis] for uw in u.keys()]
+
+    if time_index <= 0:
+        # calculate static displacement
+        u_static = train.calculate_initial_displacement(K, F_train, u_vertical)
+        state["u"] = u_static
+        state["v"] = np.zeros_like(u_static)
+        state["a"] = np.zeros_like(u_static)
+        state["previous_time"] = 0
+        state["previous_time_index"] = time_index
+
+        if "wheel_configuration" in parameters.keys():
+            state["current_position"] = [position for position in parameters["wheel_configuration"]]
+
+    state["u"] = np.array(state["u"])
+    state["v"] = np.array(state["v"])
+    state["a"] = np.array(state["a"])
+
+    if time_index > state["previous_time_index"]:
+        state["previous_time"] += time_step
+
+        if "wheel_configuration" in parameters.keys():
+            for i in range(len(parameters["wheel_configuration"])):
+                state["current_position"][i] = state["current_position"][i] + parameters["velocity"] * time_step
+
+    # check if vertical track irregularity parameter is present and add irregularities if required
+    if "irr_parameters" in parameters.keys():
+        irregularity_parameters = parameters["irr_parameters"]
+
+        for i in range(len(u_vertical)):
+            u_vertical[i] = (calculate_rail_irregularity(state["current_position"][i], **irregularity_parameters) +
+                             u_vertical[i])
+
+    # calculate contact forces
+    F_contact = calculate_contact_forces(u_vertical, train.calculate_static_contact_force(), state, parameters, train,
+                                         time_index)
+
+    # calculate force vector
+    F = F_train
+    F[train.contact_dofs] = F[train.contact_dofs] + F_contact
+
+    # scale the force vector based on the amount of initialisation steps
+    if "initialisation_steps" in parameters:
+        if time_index + 1 < parameters["initialisation_steps"]:
+            F = F * (time_index + 1) / parameters["initialisation_steps"]
+
+    # calculate new state
+    u_train, v_train, a_train = calculate(state, (M, C, K, F), time_step, time_index)
+
+    state["u"] = u_train.tolist()
+    state["v"] = v_train.tolist()
+    state["a"] = a_train.tolist()
+
+    # calculate unit vector
+    aux = {}
+    for i, val in enumerate(F_contact):
+        aux[i + 1] = [0., (-val).tolist(), 0.]
+    uvec_data["loads"] = aux
+
+    state["previous_time_index"] = time_index
+
+    return uvec_data
+
+
+def initialise(time_index: int, parameters: dict,
+               state: dict) -> Tuple[Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray], TrainModel]:
+    """
+    Initialise the train system
+
+    Args:
+        - time_index (int): time index
+        - parameters (dict): dictionary containing the parameters
+        - state (dict): dictionary containing the state
+
+    Returns:
+        - Tuple[Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray], TrainModel]: tuple containing the global \
+            matrices (M, C, K, F) and the train model
+    """
+
+    train = TrainModel()
+
+    train.n_carts = parameters["n_carts"]
+    train.cart_inertia = parameters["cart_inertia"]
+    train.cart_mass = parameters["cart_mass"]
+    train.cart_stiffness = parameters["cart_stiffness"]
+    train.cart_damping = parameters["cart_damping"]
+
+    train.bogie_distances = parameters["bogie_distances"]
+
+    train.bogie_inertia = parameters["bogie_inertia"]
+    train.bogie_mass = parameters["bogie_mass"]
+    train.wheel_distances = parameters["wheel_distances"]
+
+    train.wheel_mass = parameters["wheel_mass"]
+    train.wheel_stiffness = parameters["wheel_stiffness"]
+    train.wheel_damping = parameters["wheel_damping"]
+
+    train.initialise()
+
+    # set global matrices
+    K, C, M, F = train.generate_global_matrices()
+
+    return (M, C, K, F), train
+
+
+def calculate_contact_forces(u: List, F_static: np.ndarray, state: dict, parameters: dict, train: TrainModel,
+                             time_index: int) -> np.ndarray:
+    """
+    Calculate the contact forces
+
+    Args:
+        - u (List): vertical displacement of the wheels
+        - F_static (np.ndarray): static contact force
+        - state (dict): dictionary containing the state
+        - parameters (dict): dictionary containing the parameters
+        - train (TrainModel): train model
+        - time_index (int): time index
+
+    Returns:
+        - np.ndarray: array containing the contact forces
+    """
+
+    contact_method = HertzianContact()
+    contact_method.contact_coeff = parameters["contact_coefficient"]
+    contact_method.contact_power = parameters["contact_power"]
+
+    u_wheel = np.array(state["u"])[train.contact_dofs]
+
+    static_contact_u = contact_method.calculate_contact_deformation(F_static)
+
+    du = u_wheel + static_contact_u - u
+
+    return contact_method.calculate_contact_force(du)
+
+
+def calculate(state: dict, matrices: Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray], time_step,
+              t) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Calculate the new state dynamic
+
+    Args:
+        - state (dict): dictionary containing the state
+        - matrices (Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]): tuple containing the global matrices \
+            [M, C, K, F]
+        - time_step (float): time step
+        - t (int): time index
+
+    Returns:
+        - tuple: tuple containing the new state
+    """
+
+    (M, C, K, F) = matrices
+    (u, v, a) = state["u"], state["v"], state["a"]
+
+    solver = NewmarkExplicit()
+    return solver.calculate(M, C, K, F, time_step, t, u, v, a)

UVEC/uvec_two_dof_vehicle_2D/__init__.py

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

UVEC/uvec_two_dof_vehicle_2D/uvec.py

@@ -0,0 +1,133 @@
+import json
+import numpy as np
+
+
+def uvec(json_string: str) -> str:
+    """
+    Args:
+        - json_string (str): json string containing the uvec data
+
+    Returns:
+        - str: json string containing the load data
+    """
+
+    gravity_axis = 1
+
+    # Get the uvec data
+    uvec_data = json.loads(json_string)
+
+    # load the data
+    u = uvec_data["u"]
+    # theta = uvec_data["theta"]
+    time_index = uvec_data["time_index"]
+    time_step = uvec_data["dt"]
+    state = uvec_data["state"]
+
+    # Get the uvec parameters
+    # mass_1 = uvec_data["parameters"]["m1"]  # mass of the top
+    mass_2 = uvec_data["parameters"]["m2"]  # mass of the bottom
+    stiffness = uvec_data["parameters"]["k"]
+    damping = uvec_data["parameters"]["c"]
+
+    u_beam = [u[uw][gravity_axis] for uw in u.keys()]
+
+    # if first two time step initialise the variables. need to be two because we need the acceleration and velocity
+    if time_index <= 1:
+        # two dof system
+        state["u"] = 0
+        state["v"] = 0
+        state["a"] = 0
+        state["u_g_previous"] = 0
+        state["v_g_previous"] = 0
+        state["a_g_previous"] = 0
+        state["u_beam"] = 0
+
+    # compute the dof for the system given the u_beam
+    state["u_beam"] = u_beam[0]
+    state = compute_dofs(uvec_data["parameters"], state, time_step, time_index)
+
+    force = mass_2 * state["a_g_previous"] + damping * state["v_g_previous"] + stiffness * (state["u_beam"] -
+                                                                                            state["u"]) - mass_2 * 9.81
+
+    # Set the load data
+    uvec_data['loads'] = {1: [0, -force, 0]}
+    uvec_data["state"] = state
+
+    return json.dumps(uvec_data)
+
+
+def compute_dofs(parameters: dict, state: dict, delta_t: float, time_index: int) -> dict:
+    """
+    Compute the solution of a two dof system using the Newmark method
+
+    Args:
+        - parameters (dict): dictionary containing the parameters of the system
+        - state (dict): dictionary containing the state of the system
+        - delta_t (float): time step
+        - time_index (int): time index
+
+    Returns:
+        - dict: dictionary containing the state of the system
+    """
+
+    m1 = parameters["m1"]
+    # m2 = parameters["m2"]
+    k1 = parameters["k"]
+    c1 = parameters["c"]
+    external_displacement = state["u_beam"]
+    u = np.array(state["u"])
+    v = np.array(state["v"])
+    a = np.array(state["a"])
+
+    if time_index < 1:
+        return state
+
+    beta = 0.25
+    gamma = 0.5
+
+    M = m1
+    K = k1
+    C = c1
+
+    # external force
+    f_ext = k1 * external_displacement + M * 9.81
+
+    a1 = 1 / (beta * delta_t**2)
+    a2 = 1 / (beta * delta_t)
+    a3 = 1 / (2 * beta) - 1
+    a4 = gamma / (beta * delta_t)
+    a5 = (gamma / beta) - 1
+    a6 = (gamma / beta - 2) * delta_t / 2
+
+    # newmark method
+    K_till = K + C * a4 + M * a1
+
+    m_part = u * a1 + v * a2 + a * a3
+    c_part = u * a4 + v * a5 + a * a6
+    m_part = M * m_part
+    c_part = C * c_part
+
+    # external force
+    force_ext = f_ext + m_part + c_part
+
+    # solve
+    uu = force_ext / K_till
+
+    # velocity calculated through Newmark relation
+    vv = (uu - u) * a4 - v * a5 - a * a6
+    # acceleration calculated through Newmark relation
+    aa = (uu - u) * a1 - v * a2 - a * a3
+
+    state["u"] = uu
+    state["v"] = vv
+    state["a"] = aa
+    state["u_beam"] = external_displacement
+
+    new_d = external_displacement
+    new_v = (external_displacement - state["u_g_previous"]) / delta_t
+    new_a = (new_v - state["v_g_previous"]) / delta_t
+    state["u_g_previous"] = new_d
+    state["v_g_previous"] = new_v
+    state["a_g_previous"] = new_a
+
+    return state

UVEC-1.1.0.dist-info/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,16 @@
+UVEC/__init__.py,sha256=oEmWzkIpsyBXZUkuoz7yniRZXlEoP-mRdaDF5chynA8,48
+UVEC/__version__.py,sha256=oap2Ds8LnjHFaffZOUJ6emcPummRLtwK15YwAMnsNxA,66
+UVEC/get_path_uvec.py,sha256=H5uRrq8oH-k5ls87MKjIRMkQVjDyEjHdqzJtNwWOmhw,2252
+UVEC/uvec_ten_dof_vehicle_2D/__init__.py,sha256=5MFS0Gwk9JEJEHFseiYhX39RTxdXWvHDHpiawNoG0YM,84
+UVEC/uvec_ten_dof_vehicle_2D/base_model.py,sha256=NlUm6kM70eL-HmOq2Wm7Ouy6S6T1qwJUvxRD454uVc8,10702
+UVEC/uvec_ten_dof_vehicle_2D/hertzian_contact.py,sha256=buHl_MIsfKEr1hYZXXfTOvQa8IXic2zHJ5KDxMrke4s,1143
+UVEC/uvec_ten_dof_vehicle_2D/irregularities.py,sha256=eHvXh4VuI_t8E3bL92_Dhq1fFLuVHDilaxfCAKDsYCc,2212
+UVEC/uvec_ten_dof_vehicle_2D/newmark_solver.py,sha256=9CaGsNwKWnC4uNahdhGHkvpJl1rNk3q9QLEoEgkt5Bk,3014
+UVEC/uvec_ten_dof_vehicle_2D/uvec.py,sha256=FNKqzHwb6TfzKjuHOr9VTIgThkOEzRFzVARWXpAGAI4,9463
+UVEC/uvec_two_dof_vehicle_2D/__init__.py,sha256=VU9o7SmvfV6K75adFufzyJHn3JDliqk0SUGL8_L1U2c,84
+UVEC/uvec_two_dof_vehicle_2D/uvec.py,sha256=GCF4q6pKmV5wu4ICEMipssjxntlTuQM4n5OrvtlH7YU,3791
+UVEC-1.1.0.dist-info/LICENSE,sha256=WbcTzZtVX4H8BLF_mD2BtvCL8oh43TQtyugBiPKVDwo,1506
+UVEC-1.1.0.dist-info/METADATA,sha256=3efh23pwnFBzVZ0_5h4hQ1oTKH2UQRlLh3wyfNtfhZ8,1921
+UVEC-1.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+UVEC-1.1.0.dist-info/top_level.txt,sha256=dtSJchm8Httkhr-o294HMrAFCkQamKLbPtakH0TmsvE,5
+UVEC-1.1.0.dist-info/RECORD,,

UVEC-1.1.0.dist-info/WHEEL

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

UVEC-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+UVEC