weac.core.eigensystem module¶

This module provides the Eigensystem class, which is used to solve the eigenvalue problem for a layered beam on an elastic foundation.

class weac.core.eigensystem.Eigensystem(weak_layer, slab)[source]¶

Bases: object

Calculates system properties and solves the eigenvalue problem for a layered beam on an elastic foundation (Winkler model).

Parameters:

weak_layer (WeakLayer)
slab (Slab)

weak_layer¶

Type:: WeakLayer

slab¶

Type:: Slab

System properties

-----------------

A11¶

Type:: float # extensional stiffness

B11¶

Type:: float # coupling stiffness

D11¶

Type:: float # bending stiffness

kA55¶

Type:: float # shear stiffness

K0¶

Type:: float # foundation stiffness

Eigenvalues and Eigenvectors

----------------------------

ewC¶

Type:: NDArray[np.complex128] # shape (k): Complex Eigenvalues

ewR¶

Type:: NDArray[np.float64] # shape (k): Real Eigenvalues

evC¶

Type:: NDArray[np.complex128] # shape (6, k): Complex Eigenvectors

evR¶

Type:: NDArray[np.float64] # shape (6, k): Real Eigenvectors

sR¶

# (for numerical robustness)

Type:: NDArray[np.float64] # shape (k): Real positive eigenvalue shifts

sC¶

# (for numerical robustness)

Type:: NDArray[np.float64] # shape (k): Complex positive eigenvalue shifts

A11: float¶

B11: float¶

D11: float¶

kA55: float¶

K0: float¶

K: ndarray[tuple[Any, ...], dtype[_ScalarT]]¶

ewC: ndarray[tuple[Any, ...], dtype[complex128]]¶

ewR: ndarray[tuple[Any, ...], dtype[float64]]¶

evC: ndarray[tuple[Any, ...], dtype[complex128]]¶

evR: ndarray[tuple[Any, ...], dtype[float64]]¶

sR: ndarray[tuple[Any, ...], dtype[float64]]¶

sC: ndarray[tuple[Any, ...], dtype[float64]]¶

__init__(weak_layer, slab)[source]¶

Parameters:

weak_layer (WeakLayer)
slab (Slab)

slab: Slab¶

weak_layer: WeakLayer¶

calc_eigensystem()[source]¶: Calculate the fundamental system of the problem.

assemble_system_matrix(kn, kt)[source]¶

Assemble first-order ODE system matrix K.

Using the solution vector z = [u, u’, w, w’, psi, psi’] the ODE system is written in the form Az’ + Bz = d and rearranged to z’ = -(A^-1)Bz + (A^-1)d = Kz + q

Returns:

System matrix K (6x6).

Return type:

NDArray[np.float64]

Parameters:

kn (float | None)
kt (float | None)

calc_eigenvalues_and_eigenvectors(system_matrix)[source]¶

Calculate eigenvalues and eigenvectors of the system matrix.

Parameters:¶

system_matrix: NDArray # system_matrix size (6x6) of the eigenvalue problem

Return:¶

ewC: NDArray[np.complex128] # shape (k): Complex Eigenvalues ewR: NDArray[np.float64] # shape (g): Real Eigenvalues evC: NDArray[np.complex128] # shape (6, k): Complex Eigenvectors evR: NDArray[np.float64] # shape (6, g): Real Eigenvectors sR: NDArray[np.float64] # shape (k): Real positive eigenvalue shifts

# (for numerical robustness)

sC: NDArray[np.float64] # shape (g): Complex positive eigenvalue shifts: # (for numerical robustness)

Parameters:: system_matrix (ndarray[tuple[Any, ...], dtype[float64]])
Return type:: tuple[ndarray[tuple[Any, …], dtype[complex128]], ndarray[tuple[Any, …], dtype[float64]], ndarray[tuple[Any, …], dtype[complex128]], ndarray[tuple[Any, …], dtype[float64]], ndarray[tuple[Any, …], dtype[float64]], ndarray[tuple[Any, …], dtype[float64]]]

zh(x, length=0, has_foundation=True)[source]¶

Compute bedded or free complementary solution at position x.

Parameters:

x (float) – Horizontal coordinate (mm).
length (float, optional) – Segment length (mm). Default is 0.
has_foundation (bool) – Indicates whether segment has foundation or not. Default is True.

Returns:

zh – Complementary solution matrix (6x6) at position x.

Return type:

ndarray

zp(x, phi=0, has_foundation=True, qs=0)[source]¶

Compute bedded or free particular integrals at position x.

Parameters:

x (float) – Horizontal coordinate (mm).
phi (float) – Inclination (degrees).
has_foundation (bool) – Indicates whether segment has foundation (True) or not (False). Default is True.
qs (float) – additional surface load weight

Returns:

zp – Particular integral vector (6x1) at position x.

Return type:

ndarray

get_load_vector(phi, qs=0)[source]¶

Compute system load vector q.

Using the solution vector z = [u, u’, w, w’, psi, psi’] the ODE system is written in the form Az’ + Bz = d and rearranged to z’ = -(A ^ -1)Bz + (A ^ -1)d = Kz + q

Parameters:

phi (float) – Inclination [deg]. Counterclockwise positive.
qs (float) – Surface Load [N/mm]

Returns:

System load vector q (6x1).

Return type:

ndarray