
In this lecture we will introduce the basic idea of response spectra. Response spectra are a useful tool commonly deployed in seismic analysis and design so it's worth familiarising ourselves with them. For a given support excitation, a response spectrum (singular) plots the SDoF system frequency against the maximum response observed. This chart allows us to quickly identify how susceptible a structure might be to excitation as the system properties vary.

If we recall the dynamic analysis from the last lecture; to produce a response spectrum we would need to repeat this analysis many times, each time changing the system natural frequency (by changing the stiffness for example) and recording the largest magnitude displacement observed, Fig 1.

<Image
	src="/images/courses/multi-degree-of-freedom-dynamics-modal-analysis-and-seismic-response-simulation-in-python/introduction-to-response-spectra/img1.jpg"
	alt="Single analysis iteration required to produce one data point on a response spectrum. | EngineeringSkills.com"
	width="600"
	height="171"
	caption="Fig 1. Single analysis iteration required to produce one data point on a response spectrum."
/>

After sweeping through the frequency range of interest and accumulating the range of maximum absolute responses we could repeat the analysis with a different level of structural damping. The final graphical representation of all this data would be a displacement response spectrum, Fig 2. Note that we could just as easily produce a velocity or acceleration response spectrum by extracting the relevant response values on each iteration of our analysis.

<Image
	src="/images/courses/multi-degree-of-freedom-dynamics-modal-analysis-and-seismic-response-simulation-in-python/introduction-to-response-spectra/img2.jpg"
	alt="Sketch of a response spectrum. | EngineeringSkills.com"
	width="450"
	height="302"
	caption="Fig 2. Sketch of a response spectrum."
/>

Note that the same input ground motion is maintained for each iteration of the analysis. So if a response spectrum is being produced it would be prudent to repeat the analysis for multiple ground motions of interest to produce an averaged spectrum that could be used during seismic design. To get a more complete understanding, let's further expand the dynamic analysis from the last lecture and build a response spectrum for the SDoF structure with the El Centro ground motion as the input.

### Building a response spectrum

First we need to import the ground motion data in the usual way.

```python
#Import data
data = genfromtxt('El-Centro_NS.csv', delimiter=',')
time = data[:,0] #(s) Time
time[0] = 0 #Remove nan from initial time value
delta_t = time[1] - time[0] #(sec) The timestep
acc_g = data[:,1] #(g) Acceleration normalised by acceleration due to gravity, g
acc = acc_g*9.81 #(m/s^2)
```

Then we define our piecewise exact function (discussed previously).

```python
#Define a function that takes in a time and force vector
def calculateResponse(tVector, fVector):
    '''
    NOTE: All our system parameters are defined globally and not explicitly passed
    into our function as arguments.
    '''

    nPoints = len(tVector) #Number of data points
    delta_t = tVector[1]-tVector[0]

    #Constants (ref. Dynamics of Structures by Humar)
    A = math.e**(-xi*wn*delta_t)*((xi/(math.sqrt(1-(xi**2))))*
        np.sin(wd*delta_t)+np.cos(wd*delta_t))

    B = math.e**(-xi*wn*delta_t)*((1/wd*np.sin(wd*delta_t)))

    C = (1/k)*(((2*xi)/(wn*delta_t)) + math.e**(-xi*wn*delta_t)*
        ((((1-2*(xi**2))/(wd*delta_t))-(xi/(math.sqrt(1-(xi**2)))))*
        math.sin(wd*delta_t)-(1+((2*xi)/(wn*delta_t)))*np.cos(wd*delta_t)))

    D = (1/k)*(1-((2*xi)/(wn*delta_t))+math.e**(-xi*wn*delta_t)*
        (((2*(xi**2)-1)/(wd*delta_t))*np.sin(wd*delta_t)+
        ((2*xi)/(wn*delta_t))*np.cos(wd*delta_t)))

    A1 = -math.e**(-xi*wn*delta_t)*((wn/(math.sqrt(1-(xi**2))))*
         np.sin(wd*delta_t))

    B1 = math.e**(-xi*wn*delta_t)*(np.cos(wd*delta_t)-((xi)/
         (math.sqrt(1-(xi**2))))*np.sin(wd*delta_t))

    C1 =(1/k)*(-(1/delta_t)+math.e**(-xi*wn*delta_t)*
        ((((wn)/(math.sqrt(1-(xi**2))))+((xi)/(delta_t*
        math.sqrt(1-(xi**2)))))*np.sin(wd*delta_t)+(1/delta_t)*np.cos(wd*delta_t)))

    D1 =(1/k)*((1/delta_t)-(math.e**(-xi*wn*delta_t)/delta_t)*
               ((xi/(math.sqrt(1-(xi**2))))*np.sin(wd*delta_t)+np.cos(wd*delta_t)))

    #INITIAL CONDITIONS
    x0=0
    v0=0

    pos = [] #Initialise an array to hold calculated position
    vel = [] #Initialise an array to hold calculated velocity

    #MAIN LOOP (to 'step through' solution)
    for n, timestep in enumerate(tVector):
        #note that enumerate adds a counter to an iterable (n)
        timestep = round(timestep,3) #The current time

        #Update the force values
        if n<nPoints-1:
            Fn = fVector[n]
            Fnp1 = fVector[n+1]
        else:
            #Pickup when we're at the end of the force vector (no more +1 values)
            Fn = fVector[n]
            Fnp1 = 0

        #Calculate the position and velocity at the end of the timestep
        curPos = (A*x0) + (B*v0) + (C*Fn) + (D*Fnp1)
        curVel = (A1*x0) + (B1*v0)+ (C1*Fn) + (D1*Fnp1)

        #Append (save) the position and velocity into the vectors defined above
        pos.append(curPos)
        vel.append(curVel)

        #Update initial conditions for the next loop iteration
        x0 = curPos
        v0 = curVel

    return pos, vel #Return the calculated position and velocity out of the function
```

Now we can define the range of structural properties we're interested in.

```python
Xi = np.array([0.01, 0.02, 0.05, 0.1]) #Range of damping ratios
Fn = np.arange(0.01,10.01,0.01) #Range of natural frequencies
```

Now it's just a matter of calling our `calculateResponse()` function inside a nested loop and extracting the maximum structural displacement on every iteration.

```python
m = 1000 #(kg) Mass
Peff_EC = -m*acc #(N) Effective inertia force due to ground motion

R = np.zeros((len(Xi),len(Fn))) #Initialise a container to hold the response values

#Loop through all damping values
for i,xi in enumerate(Xi):

    #Loop through all natural frequencies
    for j, fn in enumerate(Fn):

        wn = 2*math.pi*fn #(rad/s) Angular natural frequency
        wd = wn*math.sqrt(1-xi**2) #Damped natural frequency
        k = m*wn**2 #(N/m) Stiffness

        pos_EC, vel_EC = calculateResponse(time, Peff_EC) #Call the function
        X = np.max(np.abs(pos_EC))
        R[i,j] = X

print('Done') #Print a statement to indicate the loop has been completed
```

Finally we can plot a line onto the response spectrum for each level of damping investigated.

```python
fig = plt.figure()
axes = fig.add_axes([0.1,0.1,2,1.5])
axes.set_xlabel('Natural frequency (Hz)')
axes.set_ylabel('Max displacement relative to base (m)')
axes.set_title('Displacement response spectrum')

nRows = np.shape(R)[0]
for i in np.arange(0,nRows):
    damping = Xi[i]*100 #percentage damping (for label)
    axes.plot(Fn,R[i,:], '-', label = "{A}% damping".format(A=damping))

axes.grid()
axes.legend(loc='upper right')
axes.set_xlim([np.min(Fn),np.max(Fn)])
axes.set_xlim([0,2])
plt.show()
```

<Image
	src="/images/courses/multi-degree-of-freedom-dynamics-modal-analysis-and-seismic-response-simulation-in-python/introduction-to-response-spectra/img3.jpg"
	alt="Response spectrum for the El Centro N-S ground motion for a range of system natural frequencies and damping ratios. | EngineeringSkills.com"
	width="1000"
	height="533"
	caption="Fig 3. Response spectrum for the El Centro N-S ground motion for a range of system natural frequencies and damping ratios."
/>

This plot allows us to identify at a glance the range of frequencies that will be excited most by the input ground motion. There is more we could say about response spectra, however, we'll move on at this point to consider MDoF system dynamics; our main focus in this course.


Please log in or enroll to continue

Please log in or enroll to continue