cbadc.digital_estimator.fir_estimator.FIRFilter
- class cbadc.digital_estimator.fir_estimator.FIRFilter(analog_system: ~cbadc.analog_system.analog_system.AnalogSystem, digital_control: ~cbadc.digital_control.digital_control.DigitalControl, eta2: float, K1: int, K2: int, stop_after_number_of_iterations: int = 9223372036854775808, Ts: float = None, mid_point: bool = False, downsample: int = 1, offset: ~numpy.ndarray = None, fixed_point: ~cbadc.utilities.FixedPoint = None, solver_type: ~cbadc.digital_estimator._filter_coefficients.FilterComputationBackend = FilterComputationBackend.mpmath, modulation_frequency: float = None, dtype=<class 'numpy.float64'>)[source]
Bases:
BatchEstimatorFIR filter implementation of the digital estimator.
Specifically, the FIR filter estimator estimates a filtered version \(\hat{\mathbf{u}}(t)\) (shaped by
signal_transfer_function()) of the input signal \(\mathbf{u}(t)\) from a sequence of control signals \(\mathbf{s}[k]\).Specifically, the estimate is of the form
\(\hat{\mathbf{u}}(k T) = \hat{\mathbf{u}}_0 + \sum_{\ell=-K_1}^{K_2} \mathbf{h}[\ell] \mathbf{s}[k + \ell]\)
where
\(\mathbf{h}[\ell]=\begin{cases}\mathbf{W}^{\mathsf{T}} \mathbf{A}_b^\ell \mathbf{B}_b & \mathrm{if} \, \ell \geq 0 \\ -\mathbf{W}^{\mathsf{T}} \mathbf{A}_f^{-\ell + 1} \mathbf{B}_f & \mathrm{else} \end{cases}\)
and \(\mathbf{W}^{\mathsf{T}}\), \(\mathbf{A}_b\), \(\mathbf{B}_b\), \(\mathbf{A}_f\), and \(\mathbf{B}_f\) are computed based on the analog system, the sample period \(T_s\), and the digital control’s DAC waveform as described in control-bounded converters.
- Parameters
analog_system (
cbadc.analog_system.AnalogSystem) – an analog system (necessary to compute the estimators filter coefficients).digital_control (
cbadc.digital_control.DigitalControl) – a digital control (necessary to determine the corresponding DAC waveform).eta2 (float) – the \(\eta^2\) parameter determines the bandwidth of the estimator.
K1 (int) – The lookback size
K2 (int, optional) – lookahead size, defaults to 0.
stop_after_number_of_iterations (int) – determine a max number of iterations by the iterator, defaults to \(2^{63}\).
Ts (float, optional) – the sampling time, defaults to the time period of the digital control.
mid_point (bool, optional) – set samples in between control updates, i.e., \(\hat{u}(kT + T/2)\), defaults to False.
downsample (int, optional) – specify down sampling rate in relation to the control period \(T\), defaults to 1, i.e., no down sampling.
offset (array_like, shape=(L), optional) – the estimate offset \(\hat{\mathbf{u}}_0\), defaults to a zero vector.
fixed_point (
cbadc.utilities.FixedPoint, optional) – fixed point arithmetic configuration, defaults to None.solver_type (
cbadc.digital_estimator._filter_coefficients.FilterComputationBackend) – determine which solver type to use when computing filter coefficients.
- analog_system
analog system as in
cbadc.analog_system.AnalogSystemor from derived class.- Type
cbadc.analog_system.AnalogSystem
- control_signal
a iterator suppling control signals as
cbadc.digital_control.DigitalControl.- Type
cbadc.digital_control.DigitalControl
- number_of_iterations
number of iterations until iterator raises
StopIteration.- Type
int
- K1
number of samples, prior to estimate, used in estimate
- Type
int
- K2
number of lookahead samples per computed batch.
- Type
int
- Ts
spacing between samples in seconds.
- Type
float
- mid_point
estimated samples shifted in between control updates, i.e., \(\hat{u}(kT + T/2)\).
- Type
bool
- downsample
down sampling rate in relation to the control period \(T\).
- Type
int, optional
- Af
The Af matrix
- Type
array_like, shape=(N, N)
- Ab
The Ab matrix
- Type
array_like, shape=(N, N)
- Bf
The Bf matrix
- Type
array_like, shape=(N, M)
- Bb
The Bb matrix
- Type
array_like, shape=(N, M)
- WT
The W matrix transposed
- Type
array_like, shape=(L, N)
- h
filter impulse response
- Type
array_like, shape=(L, K1 + K2, M)
- offset
the estimate offset \(\hat{\mathbf{u}}_0\).
- Type
array_like, shape=(L)
- fixed_point
using fixed point?
- Type
bool
- solver_type
The solver used for computing the filter coefficients.
- Type
cbadc.digital_estimator._filter_coefficients.FilterComputationBackend
- Yields
array_like, shape=(L,) – an input estimate sample \(\hat{\mathbf{u}}(t)\)
Methods
__init__(analog_system, digital_control, ...)Initializes filter coefficients
Compute the control signal transfer function at the angular frequencies of the omega array.
convolve(filter)Shape \(\mathbf{h}\) filter by convolving with filter
Demodulate the received signal.
Return the lag of the filter.
Compute the FFT of the system impulse response (FIR filter coefficients).
general_transfer_function(omega)Compute the general transfer functions from additive sources into each state varible
Return the filter's impulse response
lookback()Return lookback size \(K1\).
max_harmonic_estimate(BW, SFDR)max_transfer_function_peak(BW)noise_transfer_function(omega)Compute the noise transfer function (NTF) at the angular frequencies of the omega array.
Number of non-zero filter coefficients
save(filename)Pickle object for later use.
set_iterator(control_signal_sequence)Set iterator of control signals
signal_transfer_function(omega)Compute the signal transfer function (STF) at the angular frequencies of the omega array.
warm_up([samples])Warm up filter by population control signals.
white_noise_balance(BW[, max])See the magnitude difference between different noise contributions.
white_noise_sensitivities(BW, target_snr[, ...])Compute per node white noise sensitivity
write_C_header(filename)Write the FIR filter coefficients h into a C header file.
write_rust_module(filename)Write the FIR filter coefficients into a rust module
- control_signal_transfer_function(omega: ndarray)
Compute the control signal transfer function at the angular frequencies of the omega array.
Specifically, computes
\(\begin{pmatrix}\hat{u}_1(\omega) / s_1(\omega) & \dots & \hat{u}_1(\omega) / s_M(\omega) \\ \vdots & \ddots & \vdots \\ \hat{u}_L(\omega) / s_1(\omega) & \dots & \hat{u}_L(\omega) / s_M(\omega) \end{pmatrix}= \mathbf{G}( \omega)^\mathsf{H} \left( \mathbf{G}( \omega)\mathbf{G}( \omega)^\mathsf{H} + \eta^2 \mathbf{I}_N \right)^{-1} \bar{\mathbf{G}}( \omega)\)
for each angular frequency in omega where where \(\bar{\mathbf{G}}( \omega)= \mathbf{C}^\mathsf{T} \left(\mathbf{A} - i \omega \mathbf{I}_N\right)^{-1} \mathbf{\Gamma} \in\mathbb{R}^{N \times M}\) is the transfer function from the control signals to the output and \(\mathbf{I}_N\) represents a square identity matrix.
- Parameters
omega (array_like, shape=(K,)) – an array_like object containing the angular frequencies for evaluation.
- Returns
return STF evaluated at K different angular frequencies.
- Return type
array_like, shape=(L, M, K)
- convolve(filter: ndarray)[source]
Shape \(\mathbf{h}\) filter by convolving with filter
- Parameters
filter (array_like, shape=(K)) – filter to be applied for each digital control filter equivalently.
- demodulate() ndarray
Demodulate the received signal.
- Returns
Demodulated signal.
- Return type
np.ndarray
- fir_filter_transfer_function(Ts: float = 1.0)[source]
Compute the FFT of the system impulse response (FIR filter coefficients).
- Parameters
Ts (float) – the sample period of the corresponding impulse response.
- Returns
the FFT of the corresponding impulse responses.
- Return type
array_like, shape=(L, K3 // 2, M)
- general_transfer_function(omega: ndarray)
- Compute the general transfer functions from additive sources into each state varible
to the estimates.
- Parameters
omega (array_like, shape=(K,)) – an array_like object containing the angular frequencies for evaluation.
- Returns
return transfer function from each state N to each input estimate L for each frequency K.
- Return type
array_like, shape=(L, N, K)
- impulse_response() ndarray[source]
Return the filter’s impulse response
- Returns
the impulse response
- Return type
array_like, shape=(L, K3, M)
- noise_transfer_function(omega: ndarray)
Compute the noise transfer function (NTF) at the angular frequencies of the omega array.
Specifically, computes
\(\text{NTF}( \omega) = \mathbf{G}( \omega)^\mathsf{H} \left( \mathbf{G}( \omega)\mathbf{G}( \omega)^\mathsf{H} + \eta^2 \mathbf{I}_N \right)^{-1}\)
for each angular frequency in omega where where \(\mathbf{G}(\omega)\in\mathbb{R}^{N \times L}\) is the ATF matrix of the analog system and \(\mathbf{I}_N\) represents a square identity matrix.
- Parameters
omega (array_like, shape=(K,)) – an array_like object containing the angular frequencies for evaluation.
- Returns
return NTF evaluated at K different angular frequencies.
- Return type
array_like, shape=(L, N_tilde, K)
- number_of_filter_coefficients() int[source]
Number of non-zero filter coefficients
- Returns
total number of non-zero filter coefficients
- Return type
int
- save(filename: str)
Pickle object for later use.
Uses
cbadc.utilities.pickle_load()to save object for later use.- Parameters
filename (str) – filename to save object to.
- set_iterator(control_signal_sequence: Iterator[ndarray])
Set iterator of control signals
- Parameters
control_signal_sequence (iterator) – a iterator which outputs a sequence of control signals.
- signal_transfer_function(omega: ndarray)
Compute the signal transfer function (STF) at the angular frequencies of the omega array.
Specifically, computes
\(\text{STF}( \omega) = \mathbf{G}( \omega)^\mathsf{H} \left( \mathbf{G}( \omega)\mathbf{G}( \omega)^\mathsf{H} + \eta^2 \mathbf{I}_N \right)^{-1} \mathbf{G}( \omega)\)
for each angular frequency in omega where where \(\mathbf{G}(\omega)\in\mathbb{R}^{N \times L}\) is the ATF matrix of the analog system and \(\mathbf{I}_N\) represents a square identity matrix.
- Parameters
omega (array_like, shape=(K,)) – an array_like object containing the angular frequencies for evaluation.
- Returns
return STF evaluated at K different angular frequencies.
- Return type
array_like, shape=(L, K)
- warm_up(samples=0)
Warm up filter by population control signals.
Effectively removes the filter lag.
- Parameters
samples (int, optional) – number of warmup samples, defaults to filter_lag
- white_noise_balance(BW: ndarray, max=True)
See the magnitude difference between different noise contributions.
- Parameters
BW (array_like, shape=(2,)) – the upper and lower bandwidth ranges as (BW_low, BW_high).
max (bool, optional) – If to take the max value of the transferfunction or the squared integrated, defaults to True.
- Returns
white noise balance.
- Return type
array_like, shape=(L, N)
- white_noise_sensitivities(BW: ndarray, target_snr: float, input_power: float = 0.5, max=True, spectrum=False) ndarray
Compute per node white noise sensitivity
- Parameters
BW (array_like, shape=(2,)) – the upper and lower bandwidth ranges as (BW_low, BW_high).
target_snr (float) – the target SNR expressed in a linear scale.
input_power (float, optional) – the input power expressed in a linear scale, defaults to 1/2.
max (bool, optional) – If to take the max value of the transferfunction or the squared integrated, defaults to True.
spectrum (bool, optional) – express the returned noise variance as a power spectral density, i.e., V^2/Hz, for states representing voltages. Defaults to False.
- Returns
admissable noise power to align with SNR requirement.
- Return type
array_like, shape=(L, N)