
We can start by establishing some system parameters. For the purposes of demonstration I'll just use simple round numbers for the floor masses and storey-stiffnesses. I'll also specify a damping ratio for each mode.

```python
#(kg) Lumped masses
mArray = np.array([30000, #Floor 1
                   30000, #Floor 2
                   30000, #Floor 3
                   30000, #Floor 4
                   25000, #Floor 5
                   25000, #Floor 6
                   ])

#(N/m) Stiffnesses
kArray = np.array([2500000,
                   2500000,
                   2500000,
                   2100000,
                   2100000,
                   2100000,
                   ])
xiArray = np.array([5,5,4,1,1,1,]) #(%) Modal damping
```

For our visualisations, I'll specify a $6\:m$ storey-height and a building width of $8\:m$. I'll also specify a maximum simulation duration. This will be useful if we want to continue simulating the free vibration of our structure, after the end of our ground acceleration record. We'll do that in this case.

```python
N = len(mArray) #Number of degrees of freedom
floorHeights = np.arange(0,6*N+6,6) #Generate array floor heights
buildingWidth = 8 #Width between columns
maxTime = 50 #Total simulation time
```

Next we can import the ground acceleration 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)
```

Because we want to simulate the free vibration of our structure after the end of the ground acceleration record, we need to extend the time record that we imported and pad the end of the acceleration record with zeros. But we first need to check if the imported time record is shorter that the max simulation time specified above.

```python
if(max(time)<maxTime):
    time = np.arange(0,maxTime,delta_t)
    Acc = np.ravel(np.zeros([1,len(time)]))
    Acc[0:len(acc)] = acc
    acc = Acc
```

### Mass and Stiffness matrices

Up to this point, we've been defining the mass and stiffness matrices manually. Clearly this is not a good strategy when the number of degrees of freedom increases. So we need a way to do this algorithmically - we start with the mass matrix.

```python
#Mass matrix
M = np.matrix(np.zeros([N,N]))
for i, m in enumerate(mArray):
    M[i,i] = mArray[i]
```

To build the stiffness matrix we start by establishing an $N\times N$ matrix of zeros. Then we construct the mini-stiffness matrix or sub-stiffness matrix for each floor level and assign it into the correct location in the overall $N\times N$ stiffness matrix.

```python
#Stiffness matrix
K = np.matrix(np.zeros([N,N]))
K[0,0] = kArray[0]
for i, k in enumerate(kArray):
    if(i>0):
        ki = np.array([[k, -k],[-k, k]])
        K[i-1:i+1,i-1:i+1] = K[i-1:i+1,i-1:i+1] + ki
```

Now that we've established our structure's mass and stiffness matrix, we can perform a modal analysis in the next lecture. It's worth pausing here to reflect on the fact that what follows in the remaining lectures is the same regardless of the complexity of the structure. We simply need to establish the mass and stiffness matrix to facilitate a modal analysis. The dynamic analysis that follows is the same whether we're analysing a complex finite element model with thousands of degrees of freedom or a simple shear building model with a dozen degrees of freedom. The trick is in determining a mass and stiffness matrices that encode the key information about the structure in question.


Please log in or enroll to continue

Please log in or enroll to continue