grame/beam.py

import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import spsolve

def neb_beam_matrices(nx, dx, E, Ix, rho, S, cy):
    """
    Compute the FE matrices for Navier-Euler-Bernoulli beams
    """
    npt = nx + 1
    ndof = 2 * npt
    doflist = np.arange(0, 2*nx, 2)
    on1 = np.ones(nx)

    Ki = np.concatenate([
        doflist, doflist, doflist, doflist,
        doflist+1, doflist+1, doflist+1, doflist+1,
        doflist+2, doflist+2, doflist+2, doflist+2,
        doflist+3, doflist+3, doflist+3, doflist+3
    ])
    Kj = np.concatenate([
        doflist, doflist+1, doflist+2, doflist+3,
        doflist, doflist+1, doflist+2, doflist+3,
        doflist, doflist+1, doflist+2, doflist+3,
        doflist, doflist+1, doflist+2, doflist+3
    ])
    Kv = E*Ix/(dx**3) * np.concatenate([
        12*on1, 6*dx*on1, -12*on1, 6*dx*on1,
        6*dx*on1, 4*dx**2*on1, -6*dx*on1, 2*dx**2*on1,
        -12*on1, -6*dx*on1, 12*on1, -6*dx*on1,
        6*dx*on1, 2*dx**2*on1, -6*dx*on1, 4*dx**2*on1
    ])
    Kfull = csr_matrix((Kv, (Ki, Kj)), shape=(ndof, ndof))

    Mv1 = rho*S*dx/420 * np.concatenate([
        156*on1, 22*dx*on1, 54*on1, -13*dx*on1,
        22*dx*on1, 4*dx**2*on1, 13*dx*on1, -3*dx**2*on1,
        54*on1, 13*dx*on1, 156*on1, -22*dx*on1,
        -13*dx*on1, -3*dx**2*on1, -22*dx*on1, 4*dx**2*on1
    ])
    Mfull = csr_matrix((Mv1, (Ki, Kj)), shape=(ndof, ndof))

    Cv = cy*dx/420 * np.concatenate([
        156*on1, 22*dx*on1, 54*on1, -13*dx*on1,
        22*dx*on1, 4*dx**2*on1, 13*dx*on1, -3*dx**2*on1,
        54*on1, 13*dx*on1, 156*on1, -22*dx*on1,
        -13*dx*on1, -3*dx**2*on1, -22*dx*on1, 4*dx**2*on1
    ])
    Cfull = csr_matrix((Cv, (Ki, Kj)), shape=(ndof, ndof))

    return Kfull, Cfull, Mfull

def newmark1step_mrhs(M, C, K, f, u0, v0, a0, dt, beta, gamma):
    """
    Computes one step of the Newmark algorithm
    """
    fatK = K + 1/(beta*dt**2)*M + gamma/(beta*dt)*C
    b = f + C * (gamma/(beta*dt)*u0 + (gamma/beta - 1)*v0 + dt/2*(gamma/beta - 1)*a0) + M * (1/(beta*dt**2)*u0 + 1/(beta*dt)*v0 + (1/(2*beta) - 1)*a0)
    u = spsolve(fatK, b)
    a = 1/(beta*dt**2) * (u - u0 - dt*v0 - (dt**2/2)*(1-2*beta)*a0)
    v = v0 + dt * ((1 - gamma)*a0 + gamma*a)
    return u, v, a

def Newmark2N(M, C, K, f, u0, v0, dt, beta, gamma):
    """
    Solves the dynamic system with Newmark approach
    """
    ndof, ntime = f.shape
    u = np.zeros((ndof, ntime))
    v = np.zeros((ndof, ntime))
    a = np.zeros((ndof, ntime))
    
    up = u0
    vp = v0
    ap = spsolve(M, f[:, 0] - C @ vp - K @ up)
    
    fatK = K + 1/(beta*dt**2)*M + gamma/(beta*dt)*C
    fatK_inv = np.linalg.inv(fatK.toarray())  # Assuming small, or use sparse inv
    
    u[:, 0] = u0
    v[:, 0] = v0
    a[:, 0] = ap
    
    for i in range(1, ntime):
        b = f[:, i] + C @ (gamma/(beta*dt)*up + (gamma/beta - 1)*vp + dt/2*(gamma/beta - 2)*ap) + M @ (1/(beta*dt**2)*up + 1/(beta*dt)*vp + (1/(2*beta) - 1)*ap)
        u[:, i] = fatK_inv @ b
        a[:, i] = 1/(beta*dt**2) * (u[:, i] - up - dt*vp - (dt**2/2)*(1-2*beta)*ap)
        v[:, i] = vp + dt * ((1 - gamma)*ap + gamma*a[:, i])
        up, vp, ap = u[:, i], v[:, i], a[:, i]
    
    return u, v, a

def Bconstruct(M, C, K, nA, dt, beta, gamma):
    nx = M.shape[0]
    B = np.zeros((3*nx, nx))
    for j in range(nx):
        u0 = np.zeros(nx)
        v0 = np.zeros(nx)
        a0 = np.zeros(nx)
        eta = np.zeros(nx)
        eta[j] = 1
        u, v, a = newmark1step_mrhs(M, C, K, eta, u0, v0, a0, dt, beta, gamma)
        B[:, j] = np.concatenate([u, v, a])
    return B

def Fconstruct(M, C, K, dt, beta, gamma):
    nx = M.shape[0]
    M1 = np.eye(nx)
    M2 = np.zeros((nx, nx))
    u0 = np.block([M1, M2, M2])
    v0 = np.block([M2, M1, M2])
    a0 = np.block([M2, M2, M1])
    f = np.zeros(nx)
    u, v, a = newmark1step_mrhs(M, C, K, f, u0, v0, a0, dt, beta, gamma)
    F = np.concatenate([u, v, a])
    return F