def ramp_response(fwd_sys, fb_sys, test_type: str = 'open'):

    """
       fwd_sys:    passed in forward transfer function
       fb_sys:     feedback transfer function
       test_type:  False: passed in as closed loop
                   True:  passed in as open loop - need to apply feedback
    """

    test_sys = 0
    plt.style.use('dark_background')

    # Transfer function passed in with feedback applied
    if test_type == 'closed':
        test_sys = fwd_sys # ct.TransferFunction(fwd_sys)

    # need feedback applied (open loop passed in)
    elif test_type == 'open':
        plt.title('Closed Loop')

        test_sys = ct.tf(ct.feedback(fwd_sys, fb_sys))

    # 2. Define the time vector and ramp input signal
    T = np.linspace(0, 10, 1000) # Time from 0 to 1 seconds
    U = T                      # Ramp input: u(t) = t

    # 3. Compute the forced response
    time, y = ct.forced_response(test_sys, T, U, return_x=False)

    # 4. Compute steady state error
    final_diff = []

    # Find the difference from the last ten samples
    for sample in range(1, 11):
        final_diff.append((U[-sample] - y[-sample]) / U[-sample])

    sum = 0

    for val in final_diff:
        sum += val

    print(f'\ness = {100*sum / len(final_diff)  :0.2f} %')

    # Compute overshoot
    # tbd

    # Plot the results (optional)
    plt.plot(time, U, label='Input (Ramp)')
    plt.plot(time, y, label='Output Response')
    plt.title('Ramp Response of the System')
    plt.xlabel('Time (sec)')
    plt.ylabel('Amplitude')
    plt.legend()
    plt.grid()
    plt.show()

# Plant
Gp = ct.tf([1], [1, 10, 0])

# Compensator values
K = 150; z = 2; p = 0.065

# Phase-Lead Compensator (p > z)
Gc = ct.tf([K, K*z], [1, p])

# Closed loop L(s)
Ls = ct.series(Gp, Gc)

# Call ramp function
ramp_response(Ls, 1, 'open')