Miscellaneous¶
The Miscellaneous package provides various functions and methods which are used in the examples and in some of the other implemented routines.
The package contains the following modules:
PyDynamic.misc.SecondOrderSystem
: tools for 2nd order systemsPyDynamic.misc.filterstuff
: tools for digital filtersPyDynamic.misc.testsignals
: test signalsPyDynamic.misc.noise
: noise related functionsPyDynamic.misc.tools
: miscellaneous useful helper functions
Tools for 2nd order systems¶
The PyDynamic.misc.SecondOrderSystem
module is a collection of methods that
are used throughout the whole package, specialized for second
order dynamic systems, such as the ones used for high-class accelerometers.
This module contains the following functions:
sos_FreqResp()
: Calculation of the system frequency responsesos_phys2filter()
: Calculation of continuous filter coefficients from physical parameterssos_absphase()
: Propagation of uncertainty from physical parameters to real and imaginary part of system’s transfer function using GUM S2 Monte Carlosos_realimag()
: Propagation of uncertainty from physical parameters to real and imaginary part of system’s transfer function using GUM S2 Monte Carlo
- PyDynamic.misc.SecondOrderSystem.sos_FreqResp(S, d, f0, freqs)[source]¶
Calculation of the system frequency response
The frequency response is calculated from the continuous physical model of a second order system given by
\(H(f) = \frac{4S\pi^2f_0^2}{(2\pi f_0)^2 + 2jd(2\pi f_0)f - f^2}\)
If the provided system parameters are vectors then \(H(f)\) is calculated for each set of parameters. This is helpful for Monte Carlo simulations by using draws from the model parameters
- Parameters
- Returns
H – complex frequency response values
- Return type
ndarray shape (N,) or ndarray shape (N,K)
- PyDynamic.misc.SecondOrderSystem.sos_absphase(S, d, f0, uS, ud, uf0, f, runs=10000)[source]¶
Propagation of uncertainty from physical parameters to real and imaginary part of system’s transfer function using GUM S2 Monte Carlo.
- Parameters
S (float) – static gain
d (float) – damping
f0 (float) – resonance frequency
uS (float) – uncertainty associated with static gain
ud (float) – uncertainty associated with damping
uf0 (float) – uncertainty associated with resonance frequency
f (ndarray, shape (N,)) – frequency values at which to calculate amplitue and phase
- Returns
Hmean (ndarray, shape (N,)) – best estimate of complex frequency response values
Hcov (ndarray, shape (2N,2N)) – covariance matrix [ [u(abs,abs), u(abs,phase)], [u(phase,abs), u(phase,phase)] ]
- PyDynamic.misc.SecondOrderSystem.sos_phys2filter(S, d, f0)[source]¶
Calculation of continuous filter coefficients from physical parameters.
If the provided system parameters are vectors then the filter coefficients are calculated for each set of parameters. This is helpful for Monte Carlo simulations by using draws from the model parameters
- PyDynamic.misc.SecondOrderSystem.sos_realimag(S, d, f0, uS, ud, uf0, f, runs=10000)[source]¶
Propagation of uncertainty from physical parameters to real and imaginary part of system’s transfer function using GUM S2 Monte Carlo.
- Parameters
S (float) – static gain
d (float) – damping
f0 (float) – resonance frequency
uS (float) – uncertainty associated with static gain
ud (float) – uncertainty associated with damping
uf0 (float) – uncertainty associated with resonance frequency
f (ndarray, shape (N,)) – frequency values at which to calculate real and imaginary part
- Returns
Hmean (ndarray, shape (N,)) – best estimate of complex frequency response values
Hcov (ndarray, shape (2N,2N)) – covariance matrix [ [u(real,real), u(real,imag)], [u(imag,real), u(imag,imag)] ]
Tools for digital filters¶
The PyDynamic.misc.filterstuff
module is a collection of methods which are
related to filter design.
This module contains the following functions:
db()
: Calculation of decibel values \(20\log_{10}(x)\) for a vector of valuesua()
: Shortcut for calculation of unwrapped angle of complex valuesgrpdelay()
: Calculation of the group delay of a digital filtermapinside()
: Maps the roots of polynomial with coefficients \(a\) to the unit circlekaiser_lowpass()
: Design of a FIR lowpass filter using the window technique with a Kaiser window.isstable()
: Determine whether a given IIR filter is stablesavitzky_golay()
: Smooth (and optionally differentiate) data with a Savitzky-Golay filter
- PyDynamic.misc.filterstuff.db(vals)[source]¶
Calculation of decibel values \(20\log_{10}(x)\) for a vector of values
- PyDynamic.misc.filterstuff.grpdelay(b, a, Fs, nfft=512)[source]¶
Calculation of the group delay of a digital filter
- Parameters
- Returns
group_delay (np.ndarray) – group delay values
frequencies (ndarray) – frequencies at which the group delay is calculated
References
Smith, online book [Smith]
- PyDynamic.misc.filterstuff.isstable(b, a, ftype='digital')[source]¶
Determine whether IIR filter (b,a) is stable
Determine whether IIR filter (b,a) is stable by checking roots of the polynomial ´a´.
- Parameters
b (ndarray) – filter numerator coefficients
a (ndarray) – filter denominator coefficients
ftype (string) – type of filter (digital or analog)
- Returns
stable – whether filter is stable or not
- Return type
- PyDynamic.misc.filterstuff.kaiser_lowpass(L, fcut, Fs, beta=8.0)[source]¶
Design of a FIR lowpass filter using the window technique with a Kaiser window.
This method uses a Kaiser window. Filters of that type are often used as FIR low-pass filters due to their linear phase.
- PyDynamic.misc.filterstuff.mapinside(a)[source]¶
Maps the roots of polynomial to the unit circle.
Maps the roots of polynomial with coefficients \(a\) to the unit circle.
- Parameters
a (ndarray) – polynomial coefficients
- Returns
a – polynomial coefficients with all roots inside or on the unit circle
- Return type
ndarray
- PyDynamic.misc.filterstuff.savitzky_golay(y, window_size, order, deriv=0, delta=1.0)[source]¶
Smooth (and optionally differentiate) data with a Savitzky-Golay filter
The Savitzky-Golay filter removes high frequency noise from data. It has the advantage of preserving the original shape and features of the signal better than other types of filtering approaches, such as moving averages techniques.
Source obtained from scipy cookbook (online), downloaded 2013-09-13
- Parameters
y (ndarray, shape (N,)) – the values of the time history of the signal
window_size (int) – the length of the window. Must be an odd integer number
order (int) – the order of the polynomial used in the filtering. Must be less then window_size - 1.
deriv (int, optional) – The order of the derivative to compute. This must be a nonnegative integer. The default is 0, which means to filter the data without differentiating.
delta (float, optional) – The spacing of the samples to which the filter will be applied. This is only used if deriv > 0. This includes a factor \(n! / h^n\), where \(n\) is represented by deriv and \(1/h\) by delta.
- Returns
ys – the smoothed signal (or it’s n-th derivative).
- Return type
ndarray, shape (N,)
Notes
The Savitzky-Golay is a type of low-pass filter, particularly suited for smoothing noisy data. The main idea behind this approach is to make for each point a least-square fit with a polynomial of high order over a odd-sized window centered at the point.
References
Savitzky et al. [Savitzky]
Numerical Recipes [NumRec]
Test signals¶
The PyDynamic.misc.testsignals
module is a collection of test signals
which can be used to simulate dynamic measurements and test methods.
This module contains the following functions:
shocklikeGaussian()
: signal that resembles a shock excitation as a Gaussian followed by a smaller Gaussian of opposite signGaussianPulse()
: Generates a Gaussian pulse at \(t_0\) with height \(m_0\) and std \(sigma\)rect()
: Rectangular signal of given height and width \(t_1 - t_0\)squarepulse()
: Generates a series of rect functions to represent a square pulse signalsine()
: Generate a sine signalmulti_sine()
: Generate a multi-sine signal as summation of single sine signals
- PyDynamic.misc.testsignals.GaussianPulse(time, t0, m0, sigma, noise=0.0)[source]¶
Generates a Gaussian pulse at t0 with height m0 and std sigma
- Parameters
- Returns
x – signal amplitudes at time instants
- Return type
np.ndarray of shape (N,)
- class PyDynamic.misc.testsignals.corr_noise(w, sigma, seed=None)[source]¶
Base class for generation of a correlated noise process.
- PyDynamic.misc.testsignals.multi_sine(time, amps, freqs, noise=0.0)[source]¶
Generate a multi-sine signal as summation of single sine signals
- Parameters
- Returns
x – signal amplitude at time instants
- Return type
np.ndarray of shape (N,)
- PyDynamic.misc.testsignals.rect(time, t0, t1, height=1, noise=0.0)[source]¶
Rectangular signal of given height and width t1-t0
- Parameters
time (np.ndarray of shape (N,)) – time instants (equidistant)
t0 (float) – time instant of rect lhs
t1 (float) – time instant of rect rhs
height (float) – signal maximum
noise (float or numpy.ndarray of shape (N,), optional) – float: standard deviation of additive white gaussian noise ndarray: user-defined additive noise
- Returns
x – signal amplitudes at time instants
- Return type
np.ndarray of shape (N,)
- PyDynamic.misc.testsignals.shocklikeGaussian(time, t0, m0, sigma, noise=0.0)[source]¶
Generates a signal that resembles a shock excitation as a Gaussian followed by a smaller Gaussian of opposite sign.
- Parameters
- Returns
x – signal amplitudes at time instants
- Return type
np.ndarray of shape (N,)
- PyDynamic.misc.testsignals.sine(time, amp=1.0, freq=6.283185307179586, noise=0.0)[source]¶
Generate a sine signal
- Parameters
- Returns
x – signal amplitude at time instants
- Return type
np.ndarray of shape (N,)
Noise related functions¶
Collection of noise-signals
This module contains the following functions:
get_alpha()
: normal distributed signal amplitudes with equal power spectral densitypower_law_noise()
: normal distributed signal amplitudes with power spectrum :math:f^lphapower_law_acf()
: (theoretical) autocorrelation function of power law noiseARMA()
: autoregressive moving average noise process
- PyDynamic.misc.noise.ARMA(length, phi=0.0, theta=0.0, std=1.0)[source]¶
Generate time-series of a predefined ARMA-process based on this equation: \(\sum_{j=1}^{\min(p,n-1)} \phi_j \epsilon[n-j] + \sum_{j=1}^{\min(q,n-1)} \theta_j w[n-j]\) where w is white gaussian noise. Equation and algorithm taken from [Eichst2012] .
- Parameters
length (int) – how long the drawn sample will be
phi (float, list or numpy.ndarray, shape (p, )) – AR-coefficients
theta (float, list or numpy.ndarray) – MA-coefficients
std (float) – std of the gaussian white noise that is feeded into the ARMA-model
- Returns
e – time-series of the predefined ARMA-process
- Return type
numpy.ndarray, shape (length, )
References
Eichstädt, Link, Harris and Elster [Eichst2012]
- PyDynamic.misc.noise.get_alpha(color_value=0)[source]¶
Translate a color (given as string) into an exponent alpha or directly hand through a given numeric value of alpha.
- PyDynamic.misc.noise.power_law_acf(N, color_value='white', std=1.0)[source]¶
Return the theoretic right-sided autocorrelation (Rww) of different colors of noise.
Colors of noise are defined to have a power spectral density (Sww) proportional to f^lpha. Sww and Rww form a Fourier-pair. Therefore Rww = ifft(Sww).
- PyDynamic.misc.noise.power_law_noise(N=None, w=None, color_value='white', mean=0.0, std=1.0)[source]¶
Generate colored noise by * generate white gaussian noise * multiplying its Fourier-transform with f^(alpha/2) * inverse Fourier-transform to yield the colored/correlated noise * further adjustments to fit to specified mean/std
based on [Zhivomirov2018](A Method for Colored Noise Generation)
- Parameters
N (int) – length of noise to be generated
w (numpy.ndarray) – user-defined white noise if provided, N is ignored!
color_value (str, int or float) – if string -> check against known colornames if numeric -> used as alpha to shape PSD
mean (float) – mean of the output signal
std (float) – standard deviation of the output signal
- Returns
w_filt
- Return type
filtered noise signal
Miscellaneous useful helper functions¶
The PyDynamic.misc.tools
module is a collection of miscellaneous helper
functions.
This module contains the following functions:
print_vec()
: Print vector (1D array) to the console or return as formatted stringprint_mat()
: Print matrix (2D array) to the console or return as formatted stringmake_semiposdef()
: Make quadratic matrix positive semi-definiteFreqResp2RealImag()
: Calculate real and imaginary parts from frequency responsemake_equidistant()
: Interpolate non-equidistant time series to equidistanttrimOrPad()
: trim or pad (with zeros) a vector to desired lengthprogress_bar()
: A simple and reusable progress-bar
- PyDynamic.misc.tools.FreqResp2RealImag(Abs: numpy.ndarray, Phase: numpy.ndarray, Unc: numpy.ndarray, MCruns: Optional[int] = 1000)[source]¶
Calculate real and imaginary parts from frequency response
Calculate real and imaginary parts from amplitude and phase with associated uncertainties.
- Parameters
Abs ((N,) array_like) – amplitude values
Phase ((N,) array_like) – phase values in rad
Unc ((2N, 2N) or (2N,) array_like) – uncertainties either as full covariance matrix or as its main diagonal
MCruns (int, optional) – number of iterations for Monte Carlo simulation, defaults to 1000
- Returns
Re, Im ((N,) array_like) – best estimate of real and imaginary parts
URI ((2N, 2N) array_like) – uncertainties assoc. with Re and Im
- PyDynamic.misc.tools.make_semiposdef(matrix: numpy.ndarray, maxiter: Optional[int] = 10, tol: Optional[float] = 1e-12, verbose: Optional[bool] = False) numpy.ndarray [source]¶
Make quadratic matrix positive semi-definite by increasing its eigenvalues
- Parameters
matrix (array_like of shape (N,N)) – the matrix to process
maxiter (int, optional) – the maximum number of iterations for increasing the eigenvalues, defaults to 10
tol (float, optional) – tolerance for deciding if pos. semi-def., defaults to 1e-12
verbose (bool, optional) – If True print smallest eigenvalue of the resulting matrix, if False (default) be quiet
- Returns
quadratic positive semi-definite matrix
- Return type
(N,N) array_like
- Raises
ValueError – If matrix is not square.
- PyDynamic.misc.tools.print_mat(matrix, prec=5, vertical=False, retS=False)[source]¶
Print matrix (2D array) to the console or return as formatted string
- PyDynamic.misc.tools.print_vec(vector, prec=5, retS=False, vertical=False)[source]¶
Print vector (1D array) to the console or return as formatted string
- PyDynamic.misc.tools.progress_bar(count, count_max, width=30, prefix='', done_indicator='#', todo_indicator='.', fout=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]¶
A simple and reusable progress-bar
- Parameters
count (int) – current status of iterations, assumed to be zero-based
count_max (int) – total number of iterations
width (int, optional) – width of the actual progressbar (actual printed line will be wider)
prefix (str, optional) – some text that will be printed in front of the bar (i.e. “Progress of ABC:”)
done_indicator (str, optional) – what character is used as “already-done”-indicator
todo_indicator (str, optional) – what character is used as “not-done-yet”-indicator
fout (file-object, optional) – where the progress-bar should be written/printed to
- PyDynamic.misc.tools.shift_uncertainty(x, ux, shift)[source]¶
- Shift the elements in the vector x (and associated uncertainty ux) by shift elements.
This method uses
numpy.roll
to shift the elements in x and ux. See documentation of np.roll for details.
- Parameters
- Returns
xs ((N,) array) – shifted vector of estimates
uxs (float, np.ndarray of shape (N,) or of shape (N,N)) – uncertainty associated with the shifted vector of estimates
- PyDynamic.misc.tools.trimOrPad(array, length, mode='constant')[source]¶
Trim or pad (with zeros) a vector to the desired length
- Parameters
- Returns
array_modified – An array that is either trimmed or zero-padded to achieve the required length. Both actions are applied to the right side of the array
- Return type
np.ndarray of shape (length,)