
Building an animation to visualise the output of our simulation is usually a worthwhile step because it helps communicate what our simulation is telling us, in a more digestible format. This is particularly the case if you need to communicate to a non-expert audience; and it also just looks good! This is very much an optional step.

We start by importing some animation functionality from matplotlib and changing the plotting mode for our notebook.

```python
from matplotlib.animation import FuncAnimation
import matplotlib.gridspec as gridspec
%matplotlib notebook
```

Next we can set up some animation parameters and set a scale factor for deflections so we can easily see them. You can set the duration of your animation to match the simulation length. But be warned, generating the animation make take quite a while depending on your hardware. It may be better to simulate a window of time within the simulation. Here, we'll animate the first 100 seconds. Frame rate, or the number of frames (images) generated per second also has a big impact on time taken. The lower this number, the choppier your animation but the faster it runs and vice-versa.

```python
#Animation parameters
animLength = 100 #(sec)
frameRate = 12 #(5,10,20) frames per second (too high and animation slows down)
plotInterval = 1/frameRate #(sec) time between frame plots
dataInterval = int(plotInterval/delT) #Plot moving elements every 'dataInterval-th' point
defScale = 500 #Scale factor on bridge deflection (for visibility)
```

Next, we define the axes and add some subplots. The top sub-plot will be used to visualise our pedestrians walking across the bridge, viewed from above - a plan view. The bottom subplot will be used to visualise the oscillating beam. We'll also define a sensible set of limits for the x and y axes of both plots.

```python
fig, (ax1,ax2) = plt.subplots(nrows=2,ncols=1, figsize=(10, 5)) #Define figure and subplots
gs = gridspec.GridSpec(2,1,height_ratios=[1,1]) #Control subplot layout
ax1 = plt.subplot(gs[0])
ax2 = plt.subplot(gs[1])

ax1.set_aspect('equal', adjustable='box') #Set equal scale for axes top subplot

#Set axis limits
ax1.set_xlim([0,L])
ax1.set_ylim([-3, 3])
yLim2 = defScale*max(Res_crowd)
ax2.set_xlim([0,L])
ax2.set_ylim([-yLim2, yLim2])

#Housekeeping
ax1.set_title('Bridge plan view')
ax1.set_xlabel('(m)')
ax1.set_ylabel('(m)')
ax1.grid()

ax2.set_title('Bridge oscillation')
ax2.set_xlabel('(m)')
ax2.set_ylabel(f'Scaled displacement x{defScale} (m)')
ax2.grid()

plt.show()
```

Now we can define the initial state of our plots. This simply requires us to draw everything at time zero. We can then return to these elements and update them inside the animation loop.

```python
#Define initial state of pedestrians in top plot
topPedList = [] #Initialise an empty list to hold markers representing pedestrians
for i in np.arange(N):
    yPos = np.random.uniform(low=-2.5, high=2.5, size=1) #Random positions across bridge deck width
    pedTop, = ax1.plot(0,yPos,'o', markeredgecolor='k', markersize=10)
    topPedList.append(pedTop)

#Define initial state of pedestrians in bottom plot
btmPedList = []
for i in np.arange(N):
    ped, = ax2.plot([0,0],[0,0.6*yLim2])
    btmPedList.append(ped)

#Define the initial state of the beam in the bottom plot
xVals = np.arange(0,L+1,1) #An array of x-values along the beam
phiVals = np.sin(math.pi*xVals/L) #Corresponding y-values
beamDisp = 0*phiVals #Initial array of displacements along the beam

axisLine, = ax2.plot(xVals,beamDisp,'k') #Add a horizontal beam axis to plot
defLine, = ax2.plot(xVals,beamDisp,'r') #Add initial deflected shape to plot
```

Next we define the animation function that will perform the updates for us. We'll be updating the pedestrian positions along the bridge in the top and bottom view. For the plan view we'll randomly assign positions along the width of the bridge deck. We'll be updating the deflected shape of the beam in the bottom plot.

To give a sense of the dynamic load imposed by each pedestrian we'll scale the height of the pedestrian in the bottom plot to represent the oscillating modal load applied by that pedestrian. As we'll be using the modal load, the height scaling will become most obvious around the mid-span of the beam - which seems fairly intuitive as this is where the pedestrians are having most dynamic influence.

```python
#Function to animate plot objects
def animate(i):
    frm = int(i*dataInterval) #Index of data for this frame
    simTime = time[frm] #Simulation time for this animation frame

    #Update the pedestrian positions (top plot) for the current frame
    for i in np.arange(N):
        if(simTime>tStart[i] and simTime<tStart[i] + L/Vp[i]):
            Pt = topPedList[i]
            pos = (simTime - tStart[i])*Vp[i]
            Pt.set_xdata([pos, pos])


    #Update the beam deflected shape for the current frame
    defLine.set_data(xVals, -defScale*phiVals*Res_crowd[frm])

    #Update the pedestrian positions (bottom plot) for the current frame
    for i in np.arange(N):
        if(simTime>tStart[i] and simTime<tStart[i] + L/Vp[i]):
            Pb = btmPedList[i]
            pos = (simTime - tStart[i])*Vp[i]
            h = 0.1 + 0.1*crowdForce[i,frm]/max(crowdForce[i,:])
            Pb.set_data([pos, pos],[0,h])

    return
```

Finally we can call the animation function and save the resulting animation to a GIF file. It will be easier to view rather than trying to watch the animation play back from the function call.

After the animation GIF has been generated, we can drag it back into the notebook.

```python
#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('Bridge_response.gif')
```

<Image
	src="/images/courses/simulating-crowd-induced-vibrations-using-the-duhamel-integral/animating-bridge-response-traffic-flow/img1.gif"
	alt="Animation. | EngineeringSkills.com"
	width="529"
	height="269"
/>

<Caption>
	Fig 1.Animation produced with $N=100$ (note that this animation uses different
	parameters to those discussed above)
</Caption>

## Simulation limitations, wrap up and what next?

That wraps up our development on this project. This is a good time to review the limitations of this simulation but also how what we've learned can be generalised to the dynamic analysis of other structures and other scenarios.

Let's review the limitations first. We've relied pretty heavily on superposition in this analysis. This allowed us to calculate the response generated by each person individually, ignoring interaction between pedestrians and between each pedestrian and the bridge. In many cases this will be acceptable, for example, only when large lateral oscillations occur do we expect to see significant feedback between walking pedestrians and the structures they're walking on, see London Millennium Footbridge [1].

So, vertical vibration assessment without interaction modelling is generally acceptable. We also ignored the mass effect of pedestrians on the basis that it was small compared to the bridge mass. If this assumption cannot be made, altering the modal mass to account for pedestrians is quite simple. In any event, the additional mass will just lead to a reduction in the modal frequency. This may or may not be a conservative simplification depending on the relationship between the modal frequency and pacing frequency.

So, unless you are attempting to generate exceptionally accurate simulation results, the type of crowd-induced vibration modelling demonstrated here is likely to suffice. At the very least, it should be sufficient to highlight the potential for serviceability problems in service. This is particularly the case when we consider all of the other additional sources of uncertainty that creep into numerical modelling.

The other big simplification we made in our analysis was our bridge model; it was a simple beam. This may at first appear like a significant drawback. However, in order to generalise everything we've done here to more complex structures, all we need to know are the modal properties; frequency and mode-shape. Once these are known for the structure in question, you can directly apply the modal analysis that we demonstrated on a simple beam model.

This is the power of modal analysis - it allows us to reduce the dynamic behaviour of complex structures down to the dynamics of a series of SDoF systems. This SDoF system response can then be mapped back onto the complex structure via the mode-shape. If this has given you an appetite to dive deeper into structural dynamics, checkout the other DegreeTutors dynamics courses referenced throughout this project.

> So that's it for this one. I hope you found it helpful. 👍

<Callout type='info' heading='References'>

- [1] P. Dallard, A.J. Fitzpatrick, A. Flint, S. Le Bourva, A. Low, R.M. Ridsdill Smith, and M. Willford. The london millennium footbridge. The Structural Engineer, 79: 17–33, 2001.

</Callout>


Please log in to continue