
Numerical solution techniques offer us fantastic flexibility when it comes to solving real world engineering problems. However, if precautions are not taken, the results obtained can become inaccurate.

The primary source of error with the piecewise-exact step-by-step method is the difference between the actual force experienced by the structure and the piecewise representation of that force used in the simulation. In this lecture we'll explore the influence force segmentation has on the numerically calculated response.

We'll start by establishing a 'benchmark' forcing function generated from a sine wave, just as we did in the previous lecture.

```python
# BENCHMARK FORCE VECTOR
tmax = 30 #(sec) The max time
delta_t = 0.005 #(sec) The time step
nPoints = tmax/delta_t #Number of equally spaced data points
t = np.linspace(0,tmax, int(nPoints)) # Time vector
F_sine = P*np.sin(omega*t) #Force vector
```

Note that the time-step used to generate this force-time history is $0.005$ seconds. We can plot one second of the forcing function to visualise the individual data points.

```python
#Plotting
fig, axes = plt.subplots(figsize=(12,10))
axes.plot(t,F_sine,'-*', label='Sine (100 linear segments)')
axes.set_xlabel('Time (sec)')
axes.set_ylabel('Force (N)')
axes.set_title('(a) Force-time history ($\delta_t = 0.005$ s)')
axes.legend(loc='lower left')
axes.set_xlim([0,1])
axes.grid()
```

<Image
	src="/images/courses/fundamentals-of-structural-dynamics-with-python/force-segmentation/img2.jpg"
	alt="Fig 1. Force-time history with delta = 0.005 seconds. | EngineeringSkills.com"
	width="1000"
	height="819"
/>
<Caption type="">
	Fig 1. Force-time history with $\delta = 0.005$ seconds.
</Caption>

Now imagine that we can only sample this force signal at say, $4$, $8$, $20$ and $40 \:Hz$. Consider the first of these cases, $4$ samples per second:

<Image
	src="/images/courses/fundamentals-of-structural-dynamics-with-python/force-segmentation/img1.jpg"
	alt="Fig 2. Sketch of force sampled at 4 Hz. | EngineeringSkills.com"
	width="500"
	height="298"
/>
<Caption type="abcdeftxxxcccdddd">
	Fig 2. Sketch of force sampled at $4 \:Hz$.
</Caption>

Note that in each case, the time-step remains the same, i.e. $0.005$ seconds. So, to obtain values of force between the sampled points we simply linearly interpolate between sample points. We now need to build a function to sample the forcing function and generate the force values between sample points.

The function below takes as input arguments, the maximum time/duration of the force record, the magnitude of the sinusoidal force and the number of segments that a single cycle must be divided into. The function then returns the sample times, values of the force at each sample time and the complete (including interpolated points) force-time history and time vector.

```python
def generateForce(nSegs, tmax, P):
"""
nSegs: the number of linear segments in a single cycle
tmax: the length of the force record to be sampled
P: the magnitude of the sine wave being sampled
"""
nSegments = nSegs*tmax  #[4, 8, 20, 40]Number of segments forcing function is divided into
sp = np.linspace(0, tmax, nSegments+1,endpoint=True) #Sampling times
f_sp = P*np.sin(omega*sp) #Sample points (force values at sample times)

#Generate the time and force vectors (sampling points and infil data points between)
F = np.array([])
T = np.array([])
for n in np.arange(nSegments):

    if n==nSegments-1:
        forceVector = np.linspace(f_sp[n],f_sp[n+1],int(nPoints/nSegments),endpoint=True)
        timeVector = np.linspace(sp[n],sp[n+1],int(nPoints/nSegments),endpoint=True)
    else:
        forceVector = np.linspace(f_sp[n],f_sp[n+1],int(nPoints/nSegments),endpoint=False)
        timeVector = np.linspace(sp[n],sp[n+1],int(nPoints/nSegments),endpoint=False)

    F = np.append(F, forceVector, axis=0)
    T = np.append(T, timeVector, axis=0)

return [T, F, sp, f_sp]
```

Now we can call this function four times to generate 4 versions of the force record with different levels of segmentation.

```python
T4,F4, sp4, f_sp4 = generateForce(4, tmax, P) #Time and force vectors when sampling at 4Hz
T8,F8, sp8, f_sp8 = generateForce(8, tmax, P) #Time and force vectors when sampling at 8Hz
T20,F20, sp20, f_sp20 = generateForce(20, tmax, P) #Time and force vectors when sampling at 20Hz
T40,F40, sp40, f_sp40 = generateForce(40, tmax, P) #Time and force vectors when sampling at 40Hz
```

Next we can plot a single force cycle showing the 4 different levels of segmentation.

```python
#Plotting
fig, axes = plt.subplots(figsize=(12,10),nrows=2,ncols=2)
axes[0][0].plot(t,F_sine,label='Original signal')
axes[0][0].plot(T4,F4,'-*', label='4 linear segments')
axes[0][0].plot(sp4,f_sp4,'gd', label='Force sampling points')
axes[0][0].set_xlabel('Time (sec)')
axes[0][0].set_ylabel('Force (N)')
axes[0][0].set_title('(a) Force-time history ($\delta_t = 0.005$ s)')
axes[0][0].legend(loc='lower left')
axes[0][0].set_xlim([0,1])
axes[0][0].grid()

axes[0][1].plot(t,F_sine,'-', label='Original signal')
axes[0][1].plot(T8,F8,'-*', label='8 linear segments')
axes[0][1].plot(sp8,f_sp8,'gd', label='Force sampling points')
axes[0][1].set_xlabel('Time (sec)')
axes[0][1].set_ylabel('Force (N)')
axes[0][1].set_title('(b) Force-time history ($\delta_t = 0.005$ s)')
axes[0][1].legend(loc='lower left')
axes[0][1].set_xlim([0,1])
axes[0][1].grid()

axes[1][0].plot(t,F_sine,'-', label='Original signal')
axes[1][0].plot(T20,F20,'-*', label='20 linear segments')
axes[1][0].plot(sp20,f_sp20,'gd', label='Force sampling points')
axes[1][0].set_xlabel('Time (sec)')
axes[1][0].set_ylabel('Force (N)')
axes[1][0].set_title('(c) Force-time history ($\delta_t = 0.005$ s)')
axes[1][0].legend(loc='lower left')
axes[1][0].set_xlim([0,1])
axes[1][0].grid()

axes[1][1].plot(t,F_sine,'-', label='Original signal')
axes[1][1].plot(T40,F40,'-*', label='40 linear segments')
axes[1][1].plot(sp40,f_sp40,'gd', label='Force sampling points')
axes[1][1].set_xlabel('Time (sec)')
axes[1][1].set_ylabel('Force (N)')
axes[1][1].set_title('(d) Force-time history ($\delta_t = 0.005$ s)')
axes[1][1].legend(loc='lower left')
axes[1][1].set_xlim([0,1])
axes[1][1].grid()

plt.tight_layout()
```

<Image
	src="/images/courses/fundamentals-of-structural-dynamics-with-python/force-segmentation/img3.jpg"
	alt="Force-time history with 4 levels of linear segmentation. | EngineeringSkills.com"
	width="1000"
	height="819"
	caption="Fig 3. Force-time history with 4 levels of linear segmentation."
/>

The question that we're trying to answer now is how does the different degrees of force segmentation influence the response obtained using the piecewise-exact method? We can answer this by calculating the response of our SDoF system to each force and comparing the response.

It's important to recognise that we're not investigating time discretisation here (next lecture), the time-step of the dynamic simulation remains constant. All we're focusing on here is the degree of force segmentation.

We can calculate the response by calling the `calculateResponse()` function we developed in the previous lecture.

```python
Pos = calculateResponse(t,F_sine)
Pos4 = calculateResponse(T4,F4)
Pos8 = calculateResponse(T8,F8)
Pos20 = calculateResponse(T20,F20)
Pos40 = calculateResponse(T40,F40)
```

Next we plot the responses for comparison; first plotting the forces applied (top) and then the resulting structural response(bottom).

```python
# Plotting Force
fig, axes = plt.subplots(figsize=(15,15),nrows=2,ncols=1)
axes[0].plot(t,F_sine,'-', label='Original force signal')
axes[0].plot(T4,F4,'-', label='4 segments/cycle')
axes[0].plot(T8,F8,'-', label='8 segments/cycle')
axes[0].plot(T20,F20,'--', label='20 segments/cycle')
axes[0].plot(T40,F40,'--', label='40 segments/cycle')
axes[0].set_xlim([0,3])
axes[0].set_xlabel('Time (sec)')
axes[0].set_ylabel('Force (N)')
axes[0].set_title('Force-time history')
axes[0].grid()
axes[0].legend(loc='lower right')

#Plotting Displacement
axes[1].plot(t,Pos, label='Response to Original signal')
axes[1].plot(T4,Pos4, label='4 segments/cycle')
axes[1].plot(T8,Pos8, label='8 segments/cycle')
axes[1].plot(T20,Pos20, '--',label='20 segments/cycle')
axes[1].plot(T40,Pos40, '--',label='40 segments/cycle')
axes[1].set_xlim([0,3])
axes[1].set_xlabel('Time (sec)')
axes[1].set_ylabel('Displacement (m)')
axes[1].set_title('Displacement-time history')
axes[1].grid()
axes[1].legend(loc='lower right')
plt.tight_layout()
```

<Image
	src="/images/courses/fundamentals-of-structural-dynamics-with-python/force-segmentation/img4.jpg"
	alt="Four different force-time records (top) and their corresponding displacement-time records (bottom). | EngineeringSkills.com"
	width="1000"
	height="963"
	caption="Fig 4. Four different force-time records (top) and their corresponding displacement-time records (bottom)."
/>

At this point we can make some observations:

- We can see, as expected that the more frequently we sample the force signal, in other words the more linear segments we use to represent or 'reconstruct' it, the more accurate is the resulting dynamic behaviour.

- However, we also see that doubling the number of samples (linear segments) from $20$ to $40$ produces a negligible increase in response accuracy. At a particular level of segmentation we reach a point of diminishing returns.

- It will be for you the engineer, to determine, based on a sensitivity analysis what level of segmentation you need to employ. This can be done as demonstrated above by seeking convergence in the system's dynamic behaviour.

- Of course, with the negligible cost of computation, you may also consider not segmenting your force signal at all beyond its source sampling rate. In this example, that would mean generating $1/0.005 = 200$ samples or segments per cycle. Of course we have in fact done this, to generate the 'benchmark' response.

So, although we've seen that an insufficient force sampling rate has an appreciable impact on the system's dynamic behaviour, force segmentation is likely to be something you can completely avoid in practice if your source force is sampled as a sufficiently high rate. In the next lecture we'll consider the other important quantity for discretisation, time.


Please log in or enroll to continue

Please log in or enroll to continue