Modal FRF — Control Systems/Vibration

Modal FRF

Control Systems / Vibration

The frequency-response function of a structure, estimated from the force that excites it (x) and the response it produces (y), over a sliding window – MATLAB's modalfrf(x, y, fs, window, noverlap). The block keeps the last W samples of each input, splits them into K segments, windows and transforms every one, and averages the spectra P_xx = Σ|X|², P_yy = Σ|Y|² and P_yx = ΣY·X*. From them it forms one of three estimates bin by bin:

• H1 = P_yx / P_xx – unbiased by noise on the response.
• H2 = P_yy / P_yx* – unbiased by noise on the excitation.
• Hv = (P_yx/|P_yx|)·√(P_yy / P_xx) – the phase of H1 with the geometric mean of the two magnitudes.

and converts it to dynamic flexibility (displacement per unit force) from the quantity the response sensor measured: an accelerance is multiplied by −1/(2πf)², a mobility divided by j·2πf, a displacement left alone – with f = m·f_s/L, and bin 0 taking bin 1's factor, as MATLAB does.

Ports

• x – the excitation (force), a scalar stream.
• y – the response, a scalar stream, in the unit the Sensor parameter names.
• Re – the real part of the FRF, a column of L/2 + 1 entries: one per frequency bin from DC to Nyquist. Entry m is the bin at m·f_s/L hertz.
• Im – the imaginary part, the same size and the same bins.

Parameters

• Segment Length – L, the transform length, an even whole number from 4 to 32. MATLAB's window length, which modalfrf also uses as the transform length.
• Segments – K, how many segments are averaged, from 1 to 8. One segment is a valid estimate (a single impact), and there all three estimators coincide at Y/X.
• Segment Overlap – how far the segments overlap.
  • None (0%) – the hop is L. modalfrf's default, and this block's.
  • Half (50%) – the hop is L/2.
  • Three quarters (75%) – the hop is L/4; needs L divisible by four.
  The window the block holds is W = L + (K−1)·hop samples long, which is exactly K segments – MATLAB's noverlap is L − hop.
• Window – the taper applied to each segment: Rectangular (what modalfrf uses when its window argument is a length, and this block's default), Hann or Hamming. Both tapers are the symmetric form that hann and hamming return.
• Estimator – which ratio the answer is.
  • H1 – modalfrf's default, and this block's.
  • H2
  • Hv
• Sensor – what the response y measures.
  • Acceleration – modalfrf's default, and this block's.
  • Velocity
  • Displacement
• Sample Rate (Hz) – f_s, positive; it sets the frequency of each bin, and so the acceleration and velocity factors. It is not read for a displacement sensor.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. Every transform is a fixed weighted sum of window taps and the weights and sensor factors are computed once at export time, so no emitted core contains a sine, a cosine or a loop over data; the two windows become shift registers. Nothing is exposed as a tunable parameter: every setting changes the coefficient table or the arithmetic, which is structural.

The three HDL targets are simulation-only: they carry the arithmetic in real and quantize only at the port boundary. The answer is a ratio of two run-time spectra spanning several decades, which does not belong in a Q16.16 datapath – and an accelerance converted to displacement is often far below the Q16.16 quantum of 1.5×10⁻⁵, so scale the output before it reaches a fixed-point port. VHDL carries each bin in an emitted function, because a clocked process here has no place to keep the running sums a bin needs.

Simulink bridge

No equivalent (Support::None), so nothing crosses in either direction, and no parity testbench is owed. modalfrf is a Signal Processing Toolbox function, that toolbox ships no Simulink library, and no library block estimates a frequency-response function from two streams. No configuration crosses either, including "Sampling Time (s)", which has no counterpart to be written to. Code export verification still covers the block across all ten languages.

Notes

• Stateful and inherently discrete: two shift registers of W samples, advanced once per sample. The block runs on the discrete path whatever the model's solver is (setDiscreteOnlyBlock(true)), and its period comes from its own "Sampling Time (s)" – or, when that is zero or less, from the model's global sampling time. The output depends on the current sample, so a loop through the block is an algebraic loop.
• Verified against R2026a: the arithmetic here reproduces modalfrf over 324 configurations – two segment lengths, three segment counts, two overlaps, three windows, all three estimators and all three sensors – to 5×10⁻¹³ relative in the worst bin. At any instant the output is modalfrf of the last W samples of each input.
• The first W−1 samples of a run are read against a zero-prefilled window, as every sliding-window block here is, so the estimate is complete only once the window has filled.
• A silent window answers zero, not a NaN: each denominator is floored at 10⁻³⁰, which only an exactly zero spectrum reaches (MATLAB answers NaN or Inf there).
• Welch's normalizing constants are not computed, because all three estimators cancel them; the answer matches MATLAB's, the intermediate spectra do not.
• Not offered: modalfrf's subspace estimator, which identifies a state-space model instead of dividing spectra, and its Measurement option, which only arranges multi-channel answers.
• Related blocks. Spectral Measurements / Magnitude-Squared Coherence takes the same segmentation parameters and gives the coherence modalfrf returns as its third output – wire both to the same two streams to judge where the FRF can be trusted.