Beispiel #1
0
def _tausmooth(omega, rovert):

    ptL1 = 9
    ptR1 = 11

    ptL2 = 8.7*rovert - 1
    ptR2 = 8.7*rovert + 1

    if omega < ptL1:
        C_tau = np.sqrt(1.0 + 42.0/omega**3 - 42.0/10**3)

    elif omega >= ptL1 and omega <= ptR1:
        fL = np.sqrt(1.0 + 42.0/ptL1**3 - 42.0/10**3)
        fR = 1.0
        gL = -63.0/ptL1**4/fL
        gR = 0.0
        C_tau = cubic_spline_eval(ptL1, ptR1, fL, fR, gL, gR, omega)

    elif omega > ptR1 and omega < ptL2:
        C_tau = 1.0

    elif omega >= ptL2 and omega <= ptR2:
        fL = 1.0
        fR = 1.0/3.0*np.sqrt(ptR2/rovert) + 1 - np.sqrt(8.7)/3
        gL = 0.0
        gR = 1.0/6/np.sqrt(ptR2*rovert)
        C_tau = cubic_spline_eval(ptL2, ptR2, fL, fR, gL, gR, omega)

    else:
        C_tau = 1.0/3.0*np.sqrt(omega/rovert) + 1 - np.sqrt(8.7)/3

    return C_tau
Beispiel #2
0
def _cxsmooth(omega, rovert):

    Cxb = 6.0  # clamped-clamped
    constant = 1 + 1.83/1.7 - 2.07/1.7**2

    ptL1 = 1.7-0.25
    ptR1 = 1.7+0.25

    ptL2 = 0.5*rovert - 1.0
    ptR2 = 0.5*rovert + 1.0

    ptL3 = (0.5+Cxb)*rovert - 1.0
    ptR3 = (0.5+Cxb)*rovert + 1.0


    if omega < ptL1:
        Cx = constant - 1.83/omega + 2.07/omega**2

    elif omega >= ptL1 and omega <= ptR1:

        fL = constant - 1.83/ptL1 + 2.07/ptL1**2
        fR = 1.0
        gL = 1.83/ptL1**2 - 4.14/ptL1**3
        gR = 0.0
        Cx = cubic_spline_eval(ptL1, ptR1, fL, fR, gL, gR, omega)

    elif omega > ptR1 and omega < ptL2:
        Cx = 1.0

    elif omega >= ptL2 and omega <= ptR2:

        fL = 1.0
        fR = 1 + 0.2/Cxb*(1-2.0*ptR2/rovert)
        gL = 0.0
        gR = -0.4/Cxb/rovert
        Cx = cubic_spline_eval(ptL2, ptR2, fL, fR, gL, gR, omega)

    elif omega > ptR2 and omega < ptL3:
        Cx = 1 + 0.2/Cxb*(1-2.0*omega/rovert)

    elif omega >= ptL3 and omega <= ptR3:

        fL = 1 + 0.2/Cxb*(1-2.0*ptL3/rovert)
        fR = 0.6
        gL = -0.4/Cxb/rovert
        gR = 0.0
        Cx = cubic_spline_eval(ptL3, ptR3, fL, fR, gL, gR, omega)

    else:
        Cx = 0.6

    return Cx
Beispiel #3
0
def _sigmasmooth(omega, E, rovert):

    Ctheta = 1.5  # clamped-clamped

    ptL = 1.63*rovert*Ctheta - 1
    ptR = 1.63*rovert*Ctheta + 1

    if omega < 20.0*Ctheta:
        offset = (10.0/(20*Ctheta)**2 - 5/(20*Ctheta)**3)
        Cthetas = 1.5 + 10.0/omega**2 - 5/omega**3 - offset
        sigma = 0.92*E*Cthetas/omega/rovert

    elif omega >= 20.0*Ctheta and omega < ptL:

        sigma = 0.92*E*Ctheta/omega/rovert

    elif omega >= ptL and omega <= ptR:

        alpha1 = 0.92/1.63 - 2.03/1.63**4

        fL = 0.92*E*Ctheta/ptL/rovert
        fR = E*(1.0/rovert)**2*(alpha1 + 2.03*(Ctheta/ptR*rovert)**4)
        gL = -0.92*E*Ctheta/rovert/ptL**2
        gR = -E*(1.0/rovert)*2.03*4*(Ctheta/ptR*rovert)**3*Ctheta/ptR**2

        sigma = cubic_spline_eval(ptL, ptR, fL, fR, gL, gR, omega)

    else:

        alpha1 = 0.92/1.63 - 2.03/1.63**4
        sigma = E*(1.0/rovert)**2*(alpha1 + 2.03*(Ctheta/omega*rovert)**4)

    return sigma
Beispiel #4
0
def _buckling_reduction_factor(alpha, beta, eta, lambda_0, lambda_bar):
    """
    Computes a buckling reduction factor used in Eurocode shell buckling formula.
    """

    lambda_p = np.sqrt(alpha/(1.0-beta))

    ptL = 0.9*lambda_0
    ptR = 1.1*lambda_0

    if (lambda_bar < ptL):
        chi = 1.0

    elif lambda_bar >= ptL and lambda_bar <= ptR:  # cubic spline section

        fracR = (ptR-lambda_0)/(lambda_p-lambda_0)
        fL = 1.0
        fR = 1-beta*fracR**eta
        gL = 0.0
        gR = -beta*eta*fracR**(eta-1)/(lambda_p-lambda_0)

        chi = cubic_spline_eval(ptL, ptR, fL, fR, gL, gR, lambda_bar)

    elif lambda_bar > ptR and lambda_bar < lambda_p:
        chi = 1.0 - beta*((lambda_bar-lambda_0)/(lambda_p-lambda_0))**eta

    else:
        chi = alpha/lambda_bar**2



    # if (lambda_bar <= lambda_0):
    #     chi = 1.0
    # elif (lambda_bar >= lambda_p):
    #     chi = alpha/lambda_bar**2
    # else:
    #     chi = 1.0 - beta*((lambda_bar-lambda_0)/(lambda_p-lambda_0))**eta

    return chi