Skip to content
ladiskPublic

About

Fatigue Damage Spectrum (FDS) and Extreme Response Spectrum (ERS)

Resources

Contributing

Stars

10 stars

Watchers

5 watching

Forks

Repository files navigation

FatigueDS

FatigueDS

Calculating Extreme Response Spectrum (ERS) and Fatigue Damage Spectrum (FDS) of signals. Calculations are supported for sine, sine-sweep, and random signals (defined using PSD or time history). The underlying theory is based on [1].

See the documentation for more information.

Installation

Use pip to install it by:

$ pip install FatigueDS

Usage

Some short examples of how to use the package are given below for different types of signals.

Random signals (PSD)

Here is an example of determining the ERS and FDS of a random signal, defined in the frequency domain (PSD):

Generate sample signal PSD:

import numpy as np
import pyExSi as es

# generate random signal
fs = 5000  # sampling frequency [Hz]
time = 1  # time duration [s]
freq_flat = np.arange(0, fs / 2, 1 / time)  # frequency vector
freq_lower = 200  # PSD lower frequency limit  [Hz]
freq_upper = 1000  # PSD upper frequency limit [Hz]
PSD_flat = es.get_psd(freq_flat, freq_lower, freq_upper, variance=800)  # one-sided flat-shaped PSD

Use the package:

import FatigueDS

# instantiate the Spectrum class
# set the frequency range (start, stop, step) and damping ratio
load_spectrum = FatigueDS.Spectrum(freq_data=(100, 1100, 20), damp=0.05)

# set the random load
load_spectrum.set_random_load((PSD_flat, freq_flat), unit='ms2', T=3600)  # input is PSD array and frequency array

# calculate the ERS and FDS
load_spectrum.get_ers()
load_spectrum.get_fds(k=10, C=1e80, p=6.3 * 1e10)

# plot the results
load_spectrum.plot_ers()
load_spectrum.plot_fds()

# or access the results directly
ers = load_spectrum.ers
fds = load_spectrum.fds
f = load_spectrum.f0_range  # frequency vector

Random signals (time history)

Here is an example of determining the ERS and FDS of a random signal, defined in the time domain. For time domain, two methods are available:
  • Convolution (directly from time history, using rainflow counting)
  • PSD averaging (converting time history to PSD and then to ERS and FDS)

Import random time history data:

import numpy as np

_time_data = np.load('test_data/test_time_history.npy', allow_pickle=True)
time_history_data = _time_data[:,1]
t = _time_data[:,0]
dt = t[2] - t[1]

Use the package:

import FatigueDS

# instantiate the Spectrum classes
load_spectrum_1 = FatigueDS.Spectrum(freq_data=(20, 200, 5))  # convolution
load_spectrum_2 = FatigueDS.Spectrum(freq_data=(20, 200, 5))  # psd averaging

# set the random loads (input is time history array and time step)
load_spectrum_1.set_random_load((time_history_data, dt), unit='g', method='convolution')
load_spectrum_2.set_random_load((time_history_data, dt), unit='g', method='psd_averaging', bins=10)

# calculate the ERS and FDS
load_spectrum_1.get_ers()
load_spectrum_1.get_fds(k=10, C=1e80, p=6.3 * 1e10)

load_spectrum_2.get_ers()
load_spectrum_2.get_fds(k=10, C=1e80, p=6.3 * 1e10)

# plot the results

load_spectrum_1.plot_ers(label='Time history (convolution)')
load_spectrum_2.plot_ers(new_figure=False, label='Time history (PSD averaging)')

load_spectrum_1.plot_fds(label='Time history (convolution)')
load_spectrum_2.plot_fds(new_figure=False, label='Time history (PSD averaging)')

# or access the results directly

ers_1 = load_spectrum_1.ers
fds_1 = load_spectrum_1.fds
f_1 = load_spectrum_1.f0_range  # frequency vector

ers_2 = load_spectrum_2.ers
fds_2 = load_spectrum_2.fds
f_2 = load_spectrum_2.f0_range  # frequency vector

Sine and sine-sweep signals

Here is an example of determining the ERS and FDS of a sine and sine-sweep signal:

import numpy as np
import FatigueDS
import matplotlib.pyplot as plt

# instantiate classes
load_spectrum_sine = FatigueDS.Spectrum(freq_data=(0, 2000, 5), damp=0.1)  # sine
load_spectrum_sine_sweep = FatigueDS.Spectrum(freq_data=(0, 2000, 5), damp=0.1)  # sine sweep

# set the sine and sine-sweep loads
load_spectrum_sine.set_sine_load(sine_freq=500, amp=10, t_total=3600)  # t_total is is required only for FDS calculation.
load_spectrum_sine_sweep.set_sine_sweep_load(const_amp=[5, 10, 20], const_f_range=[20, 100, 500, 1000], exc_type='acc', sweep_type='log', sweep_rate=1)

# calculate the ERS and FDS
load_spectrum_sine.get_ers()
load_spectrum_sine_sweep.get_ers()

load_spectrum_sine.get_fds(k=10, C=1e80, p=6.3 * 1e10)
load_spectrum_sine_sweep.get_fds(k=10, C=1e80, p=6.3 * 1e10)

# plot the results
load_spectrum_sine.plot_ers(label='sine')
load_spectrum_sine.plot_fds(label='sine')

load_spectrum_sine_sweep.plot_ers(label='sine sweep')
load_spectrum_sine_sweep.plot_fds(label='sine sweep')

Mission synthesis

Mission synthesis gives one random vibration test PSD that has the same fatigue damage as all the events of a life cycle profile, in a shorter test duration [1]. Each event is a Spectrum with its ERS and FDS. The events must have the same freq_data, damping, material parameters and unit.

# truck and missile are Spectrum objects with get_ers() and get_fds() done
ms = FatigueDS.MissionSynthesis([truck, missile])
ms.invert(T_test=5 * 60)  # test PSD: ms.test_psd on ms.f0_range
ms.check_ers()            # compare the test ERS with the reference ERS

See the mission synthesis example (Example 11.2 of [1]: truck transport and missile flight).

References:
1. C. Lalanne, Mechanical Vibration and Shock: Specification development, London, England: ISTE Ltd and John Wiley & Sons, 2009

About

Fatigue Damage Spectrum (FDS) and Extreme Response Spectrum (ERS)

Resources

Contributing

Stars

10 stars

Watchers

5 watching

Forks

Releases

Packages

Used by

Contributors

Languages