
We've seen how animations can bring the dynamic behaviour of your structure to life. So, although not strictly necessary, in this lecture we'll generalise our animation code to allow easy visualisation of an NDoF structure.

### Calculate ground displacement

First we'll bring back the function we wrote way back in lecture 10 for integrating the ground acceleration record. We'll need to calculate the ground displacement if we want to visualise it in an animation.

```python
#Get ground displacement
def calcVelDisp(A, Time, vel_0, disp_0):
    delT = Time[1]-Time[0] #Define the timestep

    #Re-assign input arguments to variables used inside the function
    vel_im1 = vel_0 #Initial velocity
    disp_im1 = disp_0 #Initial displacement

    #Initialise containers to hold Velocity and Displacement
    Velocity = np.zeros(len(Time))
    Velocity[0] = vel_im1
    Displacement = np.zeros(len(Time))
    Displacement[0] = disp_im1

    #Loop through data and integrate (Trapezoidal rule)
    for i, m in enumerate(A):
        if i>0:
            A_im1 = A[i-1]
            A_i = A[i]

            #Integrate acceleration values to get velocities
            vel_i = vel_im1 + 0.5*delT*(A_i + A_im1)
            #Integrate velocity values to get displacements
            disp_i = disp_im1 + 0.5*delT*(vel_i+vel_im1)

            #Store data
            Velocity[i] = vel_i
            Displacement[i] = disp_i

            #Update values for next loop iteration
            vel_im1 = vel_i
            disp_im1 = disp_i

    return Velocity, Displacement
```

Call the function to determine the ground velocity and displacement. We'll only be using the displacement.

```python
groundVel, groundDisp = calcVelDisp(acc, time, 0, 0)
```

### Generate animation

Now it's time to generate the animation. We start with the usual imports.

```python
from matplotlib.animation import FuncAnimation
import matplotlib.patches as patch #For plotting polygons
import matplotlib.gridspec as gridspec
%matplotlib notebook
```

We define a scale factor for the structure and ground displacement to exaggerate them and make them more visible. Multiplying the ground acceleration by a further scale factor of zero or one allows us to easily include or remove it from our animation.

```python
#Scale displacements to make them visible
scale = 5
Us = scale*U
Ug = 1*scale*groundDisp
```

The animation parameters remain unchanged from our earlier work.

```python
#Animation parameters
animLength = max(time) #(sec)
frameRate = 10 #(5,10,20) frames per second (too high and animation slows down)
plotInterval = 1/frameRate #(sec) time between frame plots
dataInterval = plotInterval/delta_t #Plot moving elements every 'dataInterval-th' point
```

The code to build the animation follows the same structure we're familiar with. We start by plotting the initial state of the structure. Then update those variables that need updating inside our animation function. The one additional element here is that we need to use `for` loops to define our floor level green patches and the individual trace lines in our time-history plot. This actually helps clean up our code and makes for a more readable code block.

```python
th = 0.5 #Floor thickness
wth = buildingWidth #Floor width

#-----------------------------------SET UP PLOTS--------------------------------
fig, (ax1,ax2) = plt.subplots(nrows=2,ncols=1, figsize=(10, 14))
gs = gridspec.GridSpec(2,1,height_ratios=[4,1]) #Control subplot layout
ax1 = plt.subplot(gs[0])
ax2 = plt.subplot(gs[1])

#Top plot
ax1.set_aspect('equal', adjustable='box')
ax1.set_xlabel(f'Disp (m) x {scale}')
ax1.set_ylabel('Height (m)')
ax1.set_title(f'Earthquake-induced motion x{scale}')
ax1.set_xlim([-10,10])
ax1.grid()

#Bottom plot
ax2.set_xlim([0,max(time)])
ax2.set_xlabel('Time (sec)')
ax2.set_ylabel('Displacement (m)')
ax2.set_title(f'Earthquake-induced motion x{scale} (relative to ground)')
ax2.grid()

#-----------------------------------PLOT INITIAL STATE--------------------------------

#Top plot
colL, = ax1.plot(-wth/2*np.ones([N+1]),floorHeights,'k',lw=2)
colR, = ax1.plot(wth/2*np.ones([N+1]),floorHeights,'k',lw=2)

patchList = [] #Initialise an empty list to hold patches
for i in np.arange(N):
    #Floor plate m1
    h = floorHeights[i+1]
    pt1 = np.array([-wth/2,h-th/2]) #Bottom left
    pt2 = np.array([-wth/2, h+th/2]) #Top left
    pt3 = np.array([wth/2, h+th/2]) #Top right
    pt4 = np.array([wth/2, h-th/2]) #Bottom right
    xm = np.array([pt1[0],pt2[0],pt3[0],pt4[0]]) #x-coords
    ym = np.array([pt1[1],pt2[1],pt3[1],pt4[1]]) #y-coords

    #Draw the patch representing floor mass 1
    patchM = patch.Polygon(xy=list(zip(xm,ym)),alpha=1, facecolor='#33cc99', edgecolor='black')
    ax1.add_patch(patchM)
    patchList.append(patchM) #Save patch to list to update later

#Bottom plot
vline, = ax2.plot([time[0],time[0]],[np.min(Us),np.max(Us)],'r--')
traceList = [] #Initialise an empty list to hold traces
for i in np.arange(N):
    ax2.plot(time, np.ravel(Us[i,:]),'gray',lw=0.5) #Add background grey traces
    trace, = ax2.plot([0],[0]) #Add color traces to update later
    traceList.append(trace) #Save colour traces to update later

#-----------------------------------ANIMATE PLOTS--------------------------------

#Function to animate plot objects
def animate(i):
    frm = int(i*dataInterval)

    disp = np.append(0,np.ravel(Us[:,frm])) + Ug[frm]
    colL.set_data(-wth/2*np.ones([N+1])+disp, floorHeights)
    colR.set_data(+wth/2*np.ones([N+1])+disp, floorHeights)

    for i in np.arange(N):
        h = floorHeights[i+1]
        xm = Ug[frm] + Us[i,frm] + np.array([pt1[0], pt2[0], pt3[0], pt4[0]])
        ym = np.array([h-th/2, h+th/2, h+th/2, h-th/2])

        patchM = patchList[i]
        patchM.set_xy(list(zip(xm,ym)))

    vline.set_data([time[frm],time[frm]],[np.min(Us),np.max(Us)])

    for i in np.arange(N):
        trace = traceList[i]
        trace.set_data(time[0:frm], np.ravel(Us[i,0:frm]))

    return

#Function to generate the animation
myAnimation = FuncAnimation(fig,
                            animate,
                            frames=int(1 + (animLength/plotInterval) ),
                            interval=plotInterval*1000,  #milliseconds
                            blit=True,
                            repeat=True)

plt.show()
myAnimation.save('N-storey response.gif')
```

<Image
	src="/images/courses/multi-degree-of-freedom-dynamics-modal-analysis-and-seismic-response-simulation-in-python/visualising-the-structural-response-for-ndof/img1.gif"
	alt="Animation of structural and ground motion (top), time-history animation of relative ground motion (bottom). | EngineeringSkills.com"
	width="863"
	height="1177"
	caption="Fig 1. Animation of structural and ground motion (top), time-history animation of relative ground motion (bottom)."
/>


Please log in or enroll to continue

Please log in or enroll to continue