pax_global_header 0000666 0000000 0000000 00000000064 14131365315 0014514 g ustar 00root root 0000000 0000000 52 comment=d95e90dc36f7e33e384f0e89edcc506993131513
CZT-0.0.7/ 0000775 0000000 0000000 00000000000 14131365315 0012160 5 ustar 00root root 0000000 0000000 CZT-0.0.7/.gitignore 0000664 0000000 0000000 00000000337 14131365315 0014153 0 ustar 00root root 0000000 0000000 .cache
.DS_Store
.idea
.ipynb_checkpoints
.pytest_cache
.ropeproject
.coverage
.vscode
*.py.bak
*.pyc
TASKS.md
new-version.md
misc/
my-projects/
old/
references/
build/
dist/
htmlcov/
CZT.egg-info/
__pycache__/
.eggs/
CZT-0.0.7/CHANGES.md 0000664 0000000 0000000 00000006064 14131365315 0013560 0 ustar 00root root 0000000 0000000 v0.0.7 (Oct 12, 2021)
=====================
- Bugs:
- Remove `import czt` from `setup.py`. This was causing a circular dependency.
- Testing:
- Compare this package against a stripped down version of the CZT algorithm.
- Improve testing coverage.
- Examples:
- Plot residuals in examples.
v0.0.6 (Mar 22, 2021)
=====================
- `czt`:
- `freq2time` and `time2freq`:
- Fix phase correction.
- Remove scaling factor (hack).
- Remove `t_orig` and `f_orig` arguments. Not needed anymore.
- Don't return original frequency/time in `time2freq` and `freq2time`. Instead make a copy of the Numpy array.
- Always default to FFT settings if output frequency/time array is not specified.
- Fix `M!=N` error in `czt.czt`. Use proper `k`-range.
- Optimize `pd` and `skew_circulant_multiply`. `pd` is now a similar speed as `scipy`.
- Profiling:
- Add benchmarking scripts using `perfplot`.
- Add simple timing scripts.
v0.0.5 (Mar 2, 2021)
====================
- CZT:
- Optimize code to run faster (approx. x4)
- Change default `t_method` to `'ce'` (fastest, see benchmark scripts)
- Benchmark:
- Use perfplots to iterate over a range of input sizes
v0.0.4 (Feb 27, 2021)
=====================
- CZT:
- Change default ``t_method`` to ``'scipy'`` (fastest).
- czt.iczt: add option to use algorithm 2 from Sukhoy & Stoytchev 2019.
- Fix error in fft and ifft algorithms. Remove warnings now that they work.
- Rename ``f_method``: ``"std"`` -> ``"numpy"``, ``"fast"`` -> ``"recursive"``
- Benchmark:
- Add benchmarks for czt.czt and czt.iczt.
- Misc:
- Remove windowing functions (unnecessary).
v0.0.3 (Feb 26, 2021)
=====================
- CZT:
- Added new ``t_method`` to ``czt``. This method uses the new ``matmul_toeplitz`` function from Scipy. Requires ``scipy>=1.6.0``.
- Fixed argument order in ``scipy.linalg.toeplitz``.
- Use ``np.complex128`` for A and W. Fixes a potential error if A or W is passed as an integer.
- Setup:
- Add dependencies for examples.
- Add ``requriements.txt``.
- Testing:
- Added new ``t_method`` to testing.
- Misc:
- More comments.
v0.0.2 (Dec 21, 2020)
=====================
- CZT:
- Add function for inverse CZT (iczt) using complex conjugate.
- ``czt``:
- Fixed default phase of W so that CZT provides FFT by default.
- Wrapped ``czt_simple`` into ``czt`` (can still accessed via ``simple=True`` argument).
- ``time2freq``:
- Changed default frequency range to match FFT
- Add normalization for arbitrary freq/time sweeps
- Add functions to generate windows.
- Testing:
- Add test to compare CZT to analytic expression
- Added test to compare CZT to FFT
- Added test for ICZT
- Added test for time-domain -> frequency-domain -> time-domain conversion
- Remove redundant tests
- Examples:
- Add example calculating the time-domain response of a lossy waveguide
- Automatic package reloading after each cell
- ``setup.py``:
- Use ``py_modules`` instead of ``packages``
v0.0.1 (Dec 2, 2020)
====================
Initial release.
CZT-0.0.7/LICENSE 0000664 0000000 0000000 00000002054 14131365315 0013166 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2020 John Garrett
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. CZT-0.0.7/README.md 0000664 0000000 0000000 00000006151 14131365315 0013442 0 ustar 00root root 0000000 0000000 Chirp Z-Transform (CZT)
=======================
[](https://badge.fury.io/py/czt)
From [Wikipedia](https://en.wikipedia.org/wiki/Chirp_Z-transform):
> The chirp Z-transform (CZT) is a generalization of the discrete Fourier transform (DFT). While the DFT samples the Z plane at uniformly-spaced points along the unit circle, the chirp Z-transform samples along spiral arcs in the Z-plane, corresponding to straight lines in the S plane. The DFT, real DFT, and zoom DFT can be calculated as special cases of the CZT.
Getting Started
---------------
You can install the CZT package using ``pip``:
```bash
# to install the latest release (from PyPI)
pip install czt
# to install the latest version (from GitHub)
git clone https://github.com/garrettj403/CZT.git
cd CZT
pip install -e .
# to install dependencies for examples
pip install -e .[examples]
```
Example
-------
Consider the following time-domain signal:
This is an exponentially decaying sine wave with some distortion from higher-order frequencies. We can convert this signal to the frequency-domain to investigate the frequency content using the Chirp Z-Transform (CZT):
Note that the CZT also allows us to calculate the frequency response over an arbitrary frequency range:
We can see that the signal has frequency components at 1 kHz, 2.5 kHz and 3.5 kHz. To remove the distortion and isolate the 1 kHz signal, we can apply a simple window in the frequency-domain:
Finally, we can use the Inverse Chirp Z-Transform (ICZT) to transform back to the time domain:
As we can see, we were able to remove the higher-order frequencies that were distorting our 1 kHz signal.
You can find this example and others in the [``examples/``](https://github.com/garrettj403/CZT/blob/main/examples/) directory.
References
----------
- [Rabiner, L., Schafer, R., Rader, C. The Chirp z-Transform Algorithm. IEEE Trans. Audio Electroacoustics, Au-17, 2, Jun. 1969.](https://web.ece.ucsb.edu/Faculty/Rabiner/ece259/Reprints/015_czt.pdf)
- [Sukhoy, V., Stoytchev, A. Generalizing the inverse FFT off the unit circle. Sci Rep 9, 14443 (2019).](https://doi.org/10.1038/s41598-019-50234-9)
- [Chirp Z-Transform (Wikipedia)](https://en.wikipedia.org/wiki/Chirp_Z-transform)
- [Discrete Fourier Transform (Wikipedia)](https://en.wikipedia.org/wiki/Discrete_Fourier_transform)
CZT-0.0.7/czt.py 0000664 0000000 0000000 00000033155 14131365315 0013341 0 ustar 00root root 0000000 0000000 """Calculate the Chirp Z-transform (CZT).
CZT reference:
Lawrence R. Rabiner, Ronald W. Schafer, and Charles M. Rader, "The chirp
z-transform algorithm and its application," Bell Syst. Tech. J. 48,
1249-1292 (1969).
CZT computation reference:
Sukhoy, V., Stoytchev, A. "Generalizing the inverse FFT off the unit
circle," Sci Rep 9, 14443 (2019).
"""
import numpy as np
from scipy.linalg import toeplitz, matmul_toeplitz
# CZT ------------------------------------------------------------------------
def czt(x, M=None, W=None, A=1.0, simple=False, t_method="ce", f_method="numpy"):
"""Calculate the Chirp Z-transform (CZT).
Solves in O(n log n) time.
See algorithm 1 in Sukhoy & Stoytchev 2019.
Args:
x (np.ndarray): input array
M (int): length of output array
W (complex): complex ratio between points
A (complex): complex starting point
simple (bool): use simple algorithm? (very slow)
t_method (str): Toeplitz matrix multiplication method. 'ce' for
circulant embedding, 'pd' for Pustylnikov's decomposition, 'mm'
for simple matrix multiplication, 'scipy' for matmul_toeplitz
from scipy.linalg.
f_method (str): FFT method. 'numpy' for FFT from NumPy,
'recursive' for recursive method.
Returns:
np.ndarray: Chirp Z-transform
"""
# Unpack arguments
N = len(x)
if M is None:
M = N
if W is None:
W = np.exp(-2j * np.pi / M)
A = np.complex128(A)
W = np.complex128(W)
# Simple algorithm (very slow)
if simple:
k = np.arange(M)
X = np.zeros(M, dtype=complex)
z = A * W ** -k
for n in range(N):
X += x[n] * z ** -n
return X
# Algorithm 1 from Sukhoy & Stoytchev 2019
k = np.arange(max(M, N))
Wk22 = W ** (-(k ** 2) / 2)
r = Wk22[:N]
c = Wk22[:M]
X = A ** -k[:N] * x / r
try:
toeplitz_mult = _available_t_methods[t_method] # now this raises an key error
except KeyError:
raise ValueError(f"t_method {t_method} not recognized. Must be one of {list(_available_t_methods.keys())}")
X = toeplitz_mult(r, c, X, f_method)
return X / c
def iczt(X, N=None, W=None, A=1.0, simple=True, t_method="scipy", f_method="numpy"):
"""Calculate inverse Chirp Z-transform (ICZT).
Uses an efficient algorithm. Solves in O(n log n) time.
See algorithm 2 in Sukhoy & Stoytchev 2019.
Args:
X (np.ndarray): input array
N (int): length of output array
W (complex): complex ratio between points
A (complex): complex starting point
simple (bool): calculate ICZT using simple method (using CZT and
conjugate)
t_method (str): Toeplitz matrix multiplication method. 'ce' for
circulant embedding, 'pd' for Pustylnikov's decomposition, 'mm'
for simple matrix multiplication, 'scipy' for matmul_toeplitz
from scipy.linalg. Ignored if you are not using the simple ICZT
method.
f_method (str): FFT method. 'numpy' for FFT from NumPy,
'recursive' for recursive method.
Returns:
np.ndarray: Inverse Chirp Z-transform
"""
# Unpack arguments
M = len(X)
if N is None:
N = M
if W is None:
W = np.exp(-2j * np.pi / M)
A = np.complex128(A)
W = np.complex128(W)
# Simple algorithm
if simple:
return np.conj(czt(np.conj(X), M=N, W=W, A=A, t_method=t_method, f_method=f_method)) / M
# Algorithm 2 from Sukhoy & Stoytchev 2019
if M != N:
raise ValueError("M must be equal to N")
n = N
k = np.arange(n)
Wk22 = W ** (-(k ** 2) / 2)
x = Wk22 * X
p = np.r_[1, (W ** k[1:] - 1).cumprod()]
u = (-1) ** k * W ** (k * (k - n + 0.5) + (n / 2 - 0.5) * n) / p
# equivalent to:
# u = (-1) ** k * W ** ((2 * k ** 2 - (2 * n - 1) * k + n * (n - 1)) / 2) / p
u /= p[::-1]
z = np.zeros(n, dtype=complex)
uhat = np.r_[0, u[-1:0:-1]]
util = np.r_[u[0], np.zeros(n - 1)]
try:
toeplitz_mult = _available_t_methods[t_method] # now this raises an key error
except KeyError:
raise ValueError(f"t_method {t_method} not recognized. Must be one of {list(_available_t_methods.keys())}")
# Note: there is difference in accuracy here depending on the method. Have to check.
x1 = toeplitz_mult(uhat, z, x, f_method)
x1 = toeplitz_mult(z, uhat, x1, f_method)
x2 = toeplitz_mult(u, util, x, f_method)
x2 = toeplitz_mult(util, u, x2, f_method)
x = (x2 - x1) / u[0]
x = A ** k * Wk22 * x
return x
# OTHER TRANSFORMS -----------------------------------------------------------
def dft(t, x, f=None):
"""Transform signal from time- to frequency-domain using a Discrete
Fourier Transform (DFT).
Used for testing CZT algorithm.
Args:
t (np.ndarray): time
x (np.ndarray): time-domain signal
f (np.ndarray): frequency for output signal
Returns:
np.ndarray: frequency-domain signal
"""
if f is None:
# Default to FFT frequency sweep
nt = len(t)
tspan = t[-1] - t[0]
dt = tspan / (nt - 1) # more accurate than t[1] - t[0]
f = np.fft.fftshift(np.fft.fftfreq(nt, dt))
X = np.empty(len(f), dtype=complex)
for k in range(len(f)):
X[k] = np.sum(x * np.exp(-2j * np.pi * f[k] * t))
return f, X
def idft(f, X, t=None):
"""Transform signal from time- to frequency-domain using an Inverse
Discrete Fourier Transform (IDFT).
Used for testing the ICZT algorithm.
Args:
f (np.ndarray): frequency
X (np.ndarray): frequency-domain signal
t (np.ndarray): time for output signal
Returns:
np.ndarray: time-domain signal
"""
if t is None:
# Default to FFT time sweep
nf = len(f)
fspan = f[-1] - f[0]
df = fspan / (nf - 1) # more accurate than f[1] - f[0]
t = np.fft.fftshift(np.fft.fftfreq(nf, df))
x = np.empty(len(t), dtype=complex)
for n in range(len(t)):
x[n] = np.sum(X * np.exp(2j * np.pi * f * t[n]))
x /= len(t)
return t, x
# FREQ <--> TIME-DOMAIN CONVERSION -------------------------------------------
def time2freq(t, x, f=None):
"""Transform a time-domain signal to the frequency-domain.
Args:
t (np.ndarray): time
x (np.ndarray): time-domain signal
f (np.ndarray): frequency for output signal, optional, defaults to
standard FFT frequency sweep
Returns:
frequency-domain signal
"""
# Input time array
nt = len(t)
tspan = t[-1] - t[0]
dt = tspan / (nt - 1) # more accurate than t[1] - t[0]
# Output frequency array
if f is None:
# Default to FFT frequency sweep
f = np.fft.fftshift(np.fft.fftfreq(nt, dt))
else:
f = np.copy(f)
nf = len(f)
fspan = f[-1] - f[0]
df = fspan / (nf - 1) # more accurate than f[1] - f[0]
# Starting point
A = np.exp(2j * np.pi * f[0] * dt)
# Step
W = np.exp(-2j * np.pi * df * dt)
# Phase correction
phase = np.exp(-2j * np.pi * t[0] * f)
# Frequency-domain transform
freq_data = czt(x, nf, W, A) * phase
return f, freq_data
def freq2time(f, X, t=None):
"""Transform a frequency-domain signal to the time-domain.
Args:
f (np.ndarray): frequency
X (np.ndarray): frequency-domain signal
t (np.ndarray): time for output signal, optional, defaults to standard
FFT time sweep
Returns:
time-domain signal
"""
# Input frequency array
nf = len(f)
fspan = f[-1] - f[0]
df = fspan / (nf - 1) # more accurate than f[1] - f[0]
# Output time array
if t is None:
# Default to FFT time sweep
t = np.fft.fftshift(np.fft.fftfreq(nf, df))
else:
t = np.copy(t)
nt = len(t)
tspan = t[-1] - t[0]
dt = tspan / (nt - 1) # more accurate than t[1] - t[0]
# Starting point
A = np.exp(-2j * np.pi * t[0] * df)
# Step
W = np.exp(2j * np.pi * df * dt)
# Phase correction
phase = np.exp(2j * np.pi * f[0] * t)
# Time-domain transform
time_data = czt(X, nt, W=W, A=A) * phase / nf
return t, time_data
# HELPER FUNCTIONS -----------------------------------------------------------
def _toeplitz_mult_ce(r, c, x, f_method="numpy"):
"""Multiply Toeplitz matrix by vector using circulant embedding.
See algorithm S1 in Sukhoy & Stoytchev 2019:
Compute the product y = Tx of a Toeplitz matrix T and a vector x, where
T is specified by its first row r = (r[0], r[1], r[2],...,r[N-1]) and
its first column c = (c[0], c[1], c[2],...,c[M-1]), where r[0] = c[0].
Args:
r (np.ndarray): first row of Toeplitz matrix
c (np.ndarray): first column of Toeplitz matrix
x (np.ndarray): vector to multiply the Toeplitz matrix
f_method (str): FFT method. 'numpy' for FFT from NumPy, 'recursive'
for recursive method.
Returns:
np.ndarray: product of Toeplitz matrix and vector x
"""
N = len(r)
M = len(c)
assert r[0] == c[0]
assert len(x) == N
n = int(2 ** np.ceil(np.log2(M + N - 1)))
assert n >= M
assert n >= N
chat = np.r_[c, np.zeros(n - (M + N - 1)), r[-(N - 1):][::-1]]
xhat = _zero_pad(x, n)
yhat = _circulant_multiply(chat, xhat, f_method)
y = yhat[:M]
return y
def _toeplitz_mult_pd(r, c, x, f_method="numpy"):
"""Multiply Toeplitz matrix by vector using Pustylnikov's decomposition.
See algorithm S3 in Sukhoy & Stoytchev 2019:
Compute the product y = Tx of a Toeplitz matrix T and a vector x, where
T is specified by its first row r = (r[0], r[1], r[2],...,r[N-1]) and
its first column c = (c[0], c[1], c[2],...,c[M-1]), where r[0] = c[0].
Args:
r (np.ndarray): first row of Toeplitz matrix
c (np.ndarray): first column of Toeplitz matrix
x (np.ndarray): vector to multiply the Toeplitz matrix
f_method (str): FFT method. 'numpy' for FFT from NumPy, 'recursive'
for recursive method.
Returns:
np.ndarray: product of Toeplitz matrix and vector x
"""
N = len(r)
M = len(c)
assert r[0] == c[0]
assert len(x) == N
n = int(2 ** np.ceil(np.log2(M + N - 1)))
if N != n:
r = _zero_pad(r, n)
x = _zero_pad(x, n)
if M != n:
c = _zero_pad(c, n)
c1 = np.r_[c[0], c[1:]+r[-1:0:-1]]
c2 = np.r_[c[0], c[1:]-r[-1:0:-1]]
y1 = _circulant_multiply(c1 / 2, x, f_method)
y2 = _skew_circulant_multiply(c2 / 2, x, f_method)
y = y1[:M] + y2[:M]
return y
def _zero_pad(x, n):
"""Zero pad an array x to length n by appending zeros.
Args:
x (np.ndarray): array x
n (int): length of output array
Returns:
np.ndarray: array x with padding
"""
m = len(x)
assert m <= n
xhat = np.zeros(n, dtype=complex)
xhat[:m] = x
return xhat
def _circulant_multiply(c, x, f_method="numpy"):
"""Multiply a circulant matrix by a vector.
Runs in O(n log n) time.
See algorithm S4 in Sukhoy & Stoytchev 2019:
Compute the product y = Gx of a circulant matrix G and a vector x,
where G is generated by its first column c=(c[0], c[1],...,c[n-1]).
Args:
c (np.ndarray): first column of circulant matrix G
x (np.ndarray): vector x
f_method (str): FFT method. 'numpy' for FFT from NumPy,
'recursive' for recursive method.
Returns:
np.ndarray: product Gx
"""
n = len(c)
assert len(x) == n
if f_method == "numpy":
C = np.fft.fft(c)
X = np.fft.fft(x)
Y = C * X
return np.fft.ifft(Y)
elif f_method.lower() == "recursive":
C = _fft(c)
X = _fft(x)
Y = C * X
return _ifft(Y)
else:
raise ValueError("f_method not recognized.")
def _skew_circulant_multiply(c, x, f_method="numpy"):
"""Multiply a skew-circulant matrix by a vector.
Runs in O(n log n) time.
See algorithm S7 in Sukhoy & Stoytchev 2019.
Args:
c (np.ndarray): first column of skew-circulant matrix G
x (np.ndarray): vector x
f_method (str): FFT method. 'numpy' for FFT from NumPy, 'recursive'
for recursive method.
Returns:
np.ndarray: product Gx
"""
n = len(c)
assert len(x) == n
k = np.arange(n, dtype=float)
prefac = np.exp(-1j * k * np.pi / n)
chat = c * prefac
xhat = x * prefac
y = _circulant_multiply(chat, xhat, f_method)
y *= prefac.conjugate()
return y
def _fft(x):
"""Recursive FFT algorithm. Runs in O(n log n) time.
Args:
x (np.ndarray): input
Returns:
np.ndarray: FFT of x
"""
n = len(x)
if n == 1:
return x
xe = x[0::2]
xo = x[1::2]
y1 = _fft(xe)
y2 = _fft(xo)
k = np.arange(n // 2)
w = np.exp(-2j * np.pi * k / n)
y = np.empty(n, dtype=complex)
y[: n // 2] = y1 + w * y2
y[n // 2:] = y1 - w * y2
return y
def _ifft(y):
"""Recursive IFFT algorithm. Runs in O(n log n) time.
Args:
y (np.ndarray): input
Returns:
np.ndarray: IFFT of y
"""
n = len(y)
if n == 1:
return y
ye = y[0::2]
yo = y[1::2]
x1 = _ifft(ye)
x2 = _ifft(yo)
k = np.arange(n // 2)
w = np.exp(2j * np.pi * k / n)
x = np.empty(n, dtype=complex)
x[: n // 2] = (x1 + w * x2) / 2
x[n // 2:] = (x1 - w * x2) / 2
return x
_available_t_methods = {
"ce": _toeplitz_mult_ce,
"pd": _toeplitz_mult_pd,
"mm": lambda r, c, x, _: np.matmul(toeplitz(c, r), x),
"scipy": lambda r, c, x, _: matmul_toeplitz((c, r), x),
}
CZT-0.0.7/examples/ 0000775 0000000 0000000 00000000000 14131365315 0013776 5 ustar 00root root 0000000 0000000 CZT-0.0.7/examples/compare-czt-fft.ipynb 0000664 0000000 0000000 00000360420 14131365315 0020047 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Example: Compare CZT to FFT"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"%load_ext autoreload\n",
"%autoreload 2"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np \n",
"import matplotlib.pyplot as plt\n",
"\n",
"# CZT package\n",
"import czt\n",
"\n",
"# https://github.com/garrettj403/SciencePlots\n",
"plt.style.use(['science', 'notebook'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Generate Time-Domain Signal"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sampling period: 0.10 ms\n",
"Sampling frequency: 10.00 kHz\n",
"Nyquist frequency: 5.00 kHz\n",
"Number of points: 200\n"
]
}
],
"source": [
"# Time data\n",
"t = np.arange(0, 20, 0.1) * 1e-3\n",
"dt = t[1] - t[0]\n",
"Fs = 1 / dt\n",
"N = len(t)\n",
"\n",
"print(\"Sampling period: {:5.2f} ms\".format(dt * 1e3))\n",
"print(\"Sampling frequency: {:5.2f} kHz\".format(Fs / 1e3))\n",
"print(\"Nyquist frequency: {:5.2f} kHz\".format(Fs / 2 / 1e3))\n",
"print(\"Number of points: {:5d}\".format(N))"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# Signal data\n",
"def model1(t):\n",
" \"\"\"Exponentially decaying sine wave with higher-order distortion.\"\"\"\n",
" output = (1.0 * np.sin(2 * np.pi * 1e3 * t) + \n",
" 0.3 * np.sin(2 * np.pi * 2.5e3 * t) + \n",
" 0.1 * np.sin(2 * np.pi * 3.5e3 * t)) * np.exp(-1e3 * t)\n",
" return output\n",
"\n",
"def model2(t):\n",
" \"\"\"Exponentially decaying sine wave without higher-order distortion.\"\"\"\n",
" output = (1.0 * np.sin(2 * np.pi * 1e3 * t)) * np.exp(-1e3 * t)\n",
" return output\n",
"\n",
"sig = model1(t)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Plot time-domain data\n",
"plt.figure()\n",
"t_tmp = np.linspace(0, 6, 601) / 1e3\n",
"plt.plot(t_tmp*1e3, model1(t_tmp), 'k', lw=0.5, label='Data')\n",
"plt.plot(t*1e3, sig, 'ro--', label='Samples')\n",
"plt.xlabel(\"Time (ms)\")\n",
"plt.ylabel(\"Signal\")\n",
"plt.xlim([0, 6])\n",
"plt.legend()\n",
"plt.title(\"Time-domain signal\");"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Frequency-domain"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"sig_fft = np.fft.fftshift(np.fft.fft(sig))\n",
"f_fft = np.fft.fftshift(np.fft.fftfreq(N, d=dt))\n",
"\n",
"freq, sig_f = czt.time2freq(t, sig)\n",
"\n",
"# Plot results\n",
"fig1 = plt.figure(1)\n",
"frame1a = fig1.add_axes((.1,.3,.8,.6))\n",
"plt.plot(f_fft / 1e3, np.abs(sig_fft), 'k', label='FFT')\n",
"plt.plot(freq / 1e3, np.abs(sig_f), 'ro--', label='CZT')\n",
"plt.ylabel(\"Signal magnitude\")\n",
"plt.xlim([f_fft.min()/1e3, f_fft.max()/1e3])\n",
"plt.legend()\n",
"plt.title(\"Frequency-domain\")\n",
"frame1b = fig1.add_axes((.1,.1,.8,.2))\n",
"plt.plot(f_fft / 1e3, (np.abs(sig_fft) - np.abs(sig_f)) * 1e13, 'r-', label=\"Data\") \n",
"plt.xlabel(\"Frequency (kHz)\")\n",
"plt.ylabel(\"Residual\\n\" + r\"($\\times10^{-13}$)\")\n",
"plt.xlim([f_fft.min()/1e3, f_fft.max()/1e3])\n",
"plt.savefig(\"results/freq-domain.png\", dpi=600)\n",
"\n",
"# Plot results\n",
"fig2 = plt.figure(2)\n",
"frame2a = fig2.add_axes((.1,.3,.8,.6))\n",
"plt.plot(f_fft / 1e3, np.angle(sig_fft), 'k', label='FFT')\n",
"plt.plot(freq / 1e3, np.angle(sig_f), 'ro--', label='CZT')\n",
"plt.ylabel(\"Signal phase\")\n",
"plt.xlim([f_fft.min()/1e3, f_fft.max()/1e3])\n",
"plt.legend()\n",
"plt.title(\"Frequency-domain\")\n",
"frame2b = fig2.add_axes((.1,.1,.8,.2))\n",
"plt.plot(f_fft / 1e3, (np.angle(sig_fft) - np.angle(sig_f)) * 1e13, 'r-', label=\"Data\") \n",
"plt.xlabel(\"Frequency (kHz)\")\n",
"plt.ylabel(\"Residual\\n\" + r\"($\\times10^{-13}$)\")\n",
"plt.xlim([f_fft.min()/1e3, f_fft.max()/1e3]);"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
CZT-0.0.7/examples/lossy-waveguide.ipynb 0000664 0000000 0000000 00000266415 14131365315 0020206 0 ustar 00root root 0000000 0000000 {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Time-Domain Response of a Lossy Waveguide"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"%load_ext autoreload\n",
"%autoreload 2"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np \n",
"import matplotlib.pyplot as plt\n",
"import scipy.constants as sc\n",
"from scipy.signal import tukey\n",
"\n",
"# CZT package\n",
"import czt\n",
"\n",
"# https://scikit-rf.readthedocs.io/\n",
"from skrf import Frequency, RectangularWaveguide\n",
"\n",
"# https://github.com/garrettj403/SciencePlots\n",
"plt.style.use(['science', 'notebook'])"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def db20(value):\n",
" \"\"\"Convert linear voltage-like value to dB.\"\"\"\n",
" return 20 * np.log10(np.abs(value))"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Frequency sweep: 250.0-400.0 GHz, 15001 pts\n",
"Frequency step: 10.0 MHz\n"
]
}
],
"source": [
"# Define frequency sweep\n",
"freq = Frequency(250, 400, 15001, 'ghz')\n",
"print(\"Frequency sweep: \", freq)\n",
"print(\"Frequency step: {:.1f} MHz\".format((freq.f[1] - freq.f[0]) / sc.mega))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Create gold-plated WR-2.8 waveguide\n",
"wr2p8 = RectangularWaveguide(freq.copy(), a=28*sc.mil, b=14*sc.mil, rho='Al')\n",
"\n",
"# Create 2 inch long waveguide\n",
"waveguide = wr2p8.line(2, unit='in')\n",
"waveguide.name = '2\" long WR-2.8 waveguide'\n",
"\n",
"# Unpack \n",
"f = waveguide.f.copy()\n",
"s21f = waveguide.s[:,1,0].copy()\n",
"\n",
"# Plot S-parameters\n",
"plt.figure()\n",
"plt.plot(f/sc.giga, db20(s21f), label=r\"$S_{21}$\")\n",
"plt.autoscale(enable=True, axis='x', tight=True)\n",
"plt.xlabel(\"Frequency (GHz)\")\n",
"plt.ylabel(\"Magnitude (dB)\")\n",
"plt.legend();"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAgwAAAFyCAYAAACZRoIjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABhwElEQVR4nO3dd3gc1dX48e/Zoi5LsmW5dxtXwICpptlAgEBMSegJgSS88L5AILyEhEBAQCAkJsUhkBB+qZSXAIEY4lACLoDBNGMb2+Auyzau6l1b7u+PmZVX0qruame1ez7PM89IM3dmzliWdHTnzrlijEEppZRSqjMupwNQSimlVOLThEEppZRSXfI4HYBTRESfxSillEopxhjp7bEpmzAA9GT8hoj0qH0iH5OocfXmmESNqzfHJGpcvTkmUePqzTGJGldvjknUuHpzTKLG1Ztj4hlXNPSRhFJKKaW6pAlDN919991JdUw8rhGPY+Jx7729TjzuJVHvP1H/v/RGIt9LKt9/ov7f780xifq1b0tS9bVKETEpfO897spKJnr/ev+pev+pfO+g92/ff6+fS2gPg1JKKaW6lNIJg4ggIhQXFzsdSlw50ZWVSPT+9f5TVSrfO6Tm/RcXF7f8rouWPpJQSimlUoA+klBKKaVUn9OEQSmllFJd0oRBKaWUUl3ShEEppZRSXdKEQSmllFJd0oRBKaWUUl1K6YQhVeswKNWRTYuWsuKEL3Ngw1anQ1FKxYDWYYgBrcOgVHvvnnAOJ7z3b5bffA+zf3WX0+EopWJI6zAopWImZ89OAIK1tQ5HopRKNB6nA1BKJY6BZXusD+rqnQ1E9YmVK1cyf/58Nm3ahN/vp6GhgcGDB3Pqqady8803U1hY6HSIKoFpD4NSCoCAz8eQmjLrk4YGZ4NRMffqq68yZ84cLrzwQj788ENWrVrF2rVrmTlzJvfffz/BYNDpEFWC04RBKQXA/s+34TUBAKRRE4Zkc8stt3DRRRdx0UUXtQyA83q93HDDDYwcOZKioiKHI1SJThMGpRQAB9ZubPlYGhsdjETF2u7du/nss88YNGhQu32TJk3iww8/dCAq1d9owqCUAqB2w5aWjzVhSC4ZGRl4vV4effRRFixYQGVlZcs+t9vN0KFDnQtO9RspPegx1C139913ay0GlfKat25r+djdpAlDuNwrn3Y6BABq/nZ5r44rKCjggQce4Pbbb+fmm2/mtttu47TTTuPqq6/mggsuwONJ6V8FSa24uJh77rknJufSOgxKKQCWz7mQ2UtfBOCjaccza927DkeUOPp7whBSWlrKk08+yQsvvMDHH38MwCmnnMJ//vMfampq+P73v09WVhYul4uSkhIeeughJk2a1HK8z+djwYIF3H333bz//vvMmDEjqnhUfEVbh0HTSqUUAJm7d7V87NEehlai/UWdKEaPHs2PfvQjfvSjH7FmzRquvPJKli1bxtKlSxk8eDAZGRk8/PDDAPz2t7/lO9/5DsuWLWs5/g9/+AOzZ8+mvl5fu01FOoZBKQVAfqgGA+Bt1oQhWfh8Pp5+un0PyWGHHcatt94KWOMYZs6cySOPPNKyf9y4cezevbvVMddffz3HH3983wasEpYmDEopTDDIkMq9LZ97m5scjEbF0qeffsrtt98ecd+aNWsoLCzkpJNOarfv5Zdf5rrrruvr8FQ/ogmDUoqK0j1k+w8mCV6fJgzJYuXKlZSWlrbqZQgEAjzxxBM88sgjPProo3i93lbHLFq0iKqqKm6++eY4R6sSmY5hUEpxYO0GBgI13kxyfQ2k+5qdDknFyIknnsitt97K/Pnzue+++8jIyMAYw5QpU3jzzTc57rjjWrVftGgRCxcu5IknnsDl0r8p1UGaMCilqLJrMOwaPJIpX2wiza89DMliypQpzJ8/v1ttn3vuOZYvX85jjz2GiHDTTTexYMGCPo5Q9RcpnT6G5gjXGgwq1TVt3gpAxcjxAGT4tYch1axZs4bLLruMZ555hmHDhjF06FD+8Ic/tGrz1ltvccMNNwDwwAMP8Pe//92JUFUPFBcXt/yui5bWYVBK8fbZV3DSq0/z9hU3ctJTD+MXF55gwOmwlFIxFG0dhpTuYVBKWdJ37wTAO3kSPnHjMUF8DfpYQil1UFwSBhEZJSLPi0iViFSLyAsiMrobx40RkYUisl1EGkTkgIgsFZGzI7QtERETYTm/T25KqSQyYJ/1vn3O5Ak0etIAaKiqcTIkpVSC6fOEQUSygMXAFOCbwDeAScASEcnu4vAc4ABwJ/Bl4NtALfBvEbkwQvvXgOPbLMsitFNKhSm0azAUTp9Mk50wNGnCoJQKE4+3JK4BxgOTjTGbAURkDbAJuBb4ZUcHGmPWYSUJLURkEbANuBp4oc0hB4wxK2IXulLJr76imsKGappdboomj2W3Nw0aoKmmzunQlFIJJB6PJOYBK0LJAoAxZhuwHDivpyczxviBKsAXswiVSmF7P91orXMH4/K4afakA9CsCYNSKkw8EobpwNoI29cB07pzAhFxiYhHRIaKyI+BQ4BHIjT9iojUi0iTiKzQ8QtKda1y/SYAygcNBaA5TRMGpVR78UgYBgIVEbaXAwXdPMfPsXoUdgO3AZcaY95s0+Zl4EbgTOAKoBF4UUS+3puglUoV9ZusGgx1Q4YD4EvLsNa1mjAopQ6K12uVkQoe9ORd0F8DRwNfAV4BnhaRc1tdwJgbjTF/M8a8bYx5HjgN+Aj4aUcnDRWzCF+0iJNKNcGSEgD8o6wXl3x2D4NfEwal+qXwYk3hS7TikTBUYPUytFVA5J6HdowxO40xHxlj/mWMuRhYATzUxTEB4DlgpIgM66BNu0UTBpVqPDt3WOuxYwAIpFs9DP66esdiUkr1XnFxccTfb9GKR8KwDmscQ1vTgPW9POdHwMRutAulVFrSUakO5Oz9AoCsQyYAELAfSQS1h0EpFSYeCcNLwHEiMj60QUTGArPtfT0iIi7gRGBLF+08wEVAqTFmT0+vo1SqGFhhfXsUTLNy8ECGlTAEtIdBKRUmHgnD40AJsFBEzhORecBCYAfwWKiRXdXRLyJ3hW0rFpHfiMglInKKiFwCvAocA9wd1u4yEXlGRK4UkTkicimwBDgK+EEc7lGpfsnf1MyQmjIAhsyYDICxE4ZgvSYMyWblypVcdtllzJo1i5kzZzJ58mROPPFE7rzzTg4cOOB0eJ0KPZePlVNPPZVTTz01ZufrS4kSa58nDMaYOmAusBF4AngKq/DSXGNMbVhTAdxtYloJzAAeBl7HeluiETjJGPNMWLttQBEw3273GNAEnNWmnVIqzL7PtuIxQfZl5ZORmwVA0B7DYBoanAxNxdirr77KnDlzuPDCC/nwww9ZtWoVa9euZebMmdx///0Eg0GnQ+zUd77zHd577z2nw0hp8aj0iDGmFPhqF21KaPPmhDHmJbrx2MKu7jg3ihCVSkll6zYyHDhQMJSi0MbMTGtdrwlDMrnlllu46KKLuOiii1q2eb1ebrjhBhYuXEhRUVEnRztv5MiRjBw50ukwUprOVqlUCqvbaA0FqikafnBjKGHQHoaksXv3bj777DMGDRrUbt+kSZP48MMP4xbLRx99hIjwzjvvtGx7+OGHERHuvPPOlm2bNm1CRPj3v/8NtH8kEfp806ZNnHPOOeTk5DBmzBjuvffedr0lzzzzDFOmTCE9PZ3p06fz4osvRozt1Vdf5fjjjyczM5O8vDzOP/98NmzYEHXsAKtXr2bevHkUFBSQmZnJ7Nmzefvtt9vF0N1YnZDSCYPWXlCprnlrCQBNI8L+csuyHk1owpA8MjIy8Hq9PProoyxYsIDKysqWfW63m6FDh0Z9jZKSkm79PD3yyCPJz89n8eLFLdsWL15MZmZmu21ut5uTTjqp0/NdcMEFzJ07l3/+85+cf/753H333fz1r39t2f/GG29w+eWXM2nSJF544QW+//3vc9NNN7VKBMBKFkKJx9///nd+97vfsXbtWk488UR27doVVewrV67khBNOoLy8nMcff5x//OMfDBo0iNNPP52PP/64x7H2RHhNhqhFelczFRbr1pVKbe+ccr4xYN6+4ccHt3232Bgw78y50MHIEgwkxhKF+fPnG4/HYwCTlpZmzj77bPPss88an88Xk3+ikpIS43a7zT333NNl23nz5plTTz3VGGNMIBAwBQUF5pZbbjEej8fU1NQYY4y55JJLzLHHHttyzN13323Cf26HPv/Tn/7U6twzZswwZ5xxRsvnJ5xwgpk6daoJBAIt21asWGEAc8opp7RsO+qoo8zEiRNb/Xts3brVeDwe873vfS+q2OfOnWumTJlimpqaWrb5/X4zZcoUc9555/U41t6y//16/XszpXsYlEp1mbutv5wyJoxr2SbZ1iMJl/YwJJVbb72VLVu2cP/993PooYfyyiuvcPHFF3P66afj8/koLy/n29/+NjfeeCM33XQT5513Hps2bWp1Dp/Px0MPPUR2djZr17aeImjMmDH4/X7uuusuujJnzhzee+89GhsbWbVqFZWVldx2222kp6e3dNMvXbqUuXO7Hpp2zjnntPp8xowZlJaWAhAIBPjwww/52te+hst18Nfdsccey9ixY1s+r6urY+XKlVxyySV4PAeH9o0bN47Zs2ezbNmyXsfe0NDAsmXLuOiii3C5XPj9fvx+P8YYTj/9dN56660exeokTRiUSmF55Xut9ZSDddDc9iMJV1OjIzElJOf7FqwlSqNHj+ZHP/oRH330EatXr+bwww9n2bJlLF26lNLSUjIyMnj44YdZsGABZ5xxBt/5zndaHf+HP/yB2bNnUx/lK7dz586lqamJd999lyVLlnD44YczZMgQTjzxRJYsWcK6devYu3cvc+bM6fJcAwe2LiScnp5OY6P1f/fAgQP4fD6GDBnS7rjwbRUVFRhjGDasfVHgoUOHUl5e3uvYy8vLCQQC3HfffXi93lbLb3/7WyoqKggGg92O1UlxeUtCKZWYMpusXoTMooOD4VzZVsLg1oQhKfh8Pp577jkuv/zyVtsPO+wwbr31Vr7xjW/gdruZOXMmjzxycBLgcePGsXv37lbHXH/99TGJ6dBDD6WwsJDFixfzySeftPw1PnfuXJ599llGjRpFWloas2fPjuo6hYWFeL1e9u7d227f3r17GTPGKodeUFCAiLBnT/saf3v27Gk1WLSnsefn5+Nyubj++uu58sorI8bpcrm6HauTtIdBqRSW4bOSgoz83JZtHjth8GjCkBQ+/fRTbr/99oj71qxZQ2FhYcSBhS+//DLXXXddn8QkIpxyyin85z//4e233271S/eTTz7hxRdf5NhjjyUrNAC3l9xuN0cffTTPP/98qzcn3n//fUrsSdcAsrOzOeqoo3juuecIBAIt27dv3867777LKaec0uvYs7OzOemkk1i9ejVHHnkks2bNarf0JFYnacKgVArL8DUBkJk/oGWbJyfbWjc3ORKTiq2VK1dSWlrK008/3bItEAjwxBNP8Mgjj/Doo4/i9XpbHbNo0SKqqqq4+eabu32d7du34/F4uPfee7vVfu7cuXzwwQfU19e3JCxHHnkkAwYMYMmSJd16HNEd99xzD59//jnnn38+ixYt4i9/+QsXX3xxuzdD7rvvPjZt2sS5557Lyy+/zP/93/9xxhlnkJeXx//+7/9GFfsvf/lLPv74Y84880yeeeYZli1bxj/+8Q/uuOMOfvjDH/Y4VqdowqBUigr6A2QFmgHIHJDTst1rJwxenyYMyeDEE0/k1ltvZf78+UydOpUjjjiCo446ikWLFvHmm2+2KuQEVrKwcOFCnnjiiVaD77pijCEQCHS7YmTol+qsWbMYMMBKWF0uFyeffHKr/dE6/fTTeeqpp9iwYQMXXngh8+fP59e//jWTJ09u1e6ss85i0aJFVFZWcvHFF3PdddcxdepU3nnnHYYPH96qbU9jP/LII/nwww8ZNGgQ3/3ud/nSl77ETTfdxKefftpyTE9idYqYGAyk6Y9EpOXG7777bq3FoFJOfUU1WQPzaHB7yfQ3t2zfuvQDxs85lm0DRzKubIeDEap4e+6551i+fDm/+tWvEBFuuukmFixY0K6diPDpp58yY8YMB6JUPVFcXMw999zT8rkxptcFGVI6YUjVe1cKoKxkJ4PGjaI8I5eBDdUt23d+vI6Rs2awa8BgRlTtczBCFU9r1qzhyCOPpLCwsGVbVVUVDWGv17711ls8++yzPPLII1x22WWcd955XHLJJU6Eq3pBRDRh6A1NGFSq++KTzxh+5DS+yClkeM3+lu37N5Uw+JBxHMgcQGF9lYMRKqViKdqEQccwKJWiGqtqAGhKS2+1PX2A9cZERthjCqWU0oRBqRTVXG3NLt+cltFqe2gApCYMSqlwmjAolaJ8NVbC4GuTMHgz0/GLC48J4mvQNyWUUhZNGJRKUT67h8GXntFuX6MnDYAGu41SSmnCoFSK8tfWWeuMzHb7QglDU3VNXGNSSiWulE4YQnOEaw0GlYoC9iOJQISEocljDYRsqq6La0xKqdgqLi5u+V0XrZSefEpfq1SpLFhnJQOREoZmr5UwNNdowqBUf1ZcXNzyR3G0SUNK9zAolcqC9iMJkxkhYbBftQwNjFRKKU0YlEpRpr7eWme2nxHQpz0MSqk2NGFQKkVJKGHIzm63z2/3MIQGRiqllCYMSqUoqbeSAclq38Pgt1+19NfVxzUmpVTi0oRBqRQl9qRCrpz2PQwBO2EIasKglLJpwqBUinKFEobs9j0MoYQhUK8Jg1LKktIJg9ZhUKnM3WglDO4IYxiC9quWpq6h3T6lVP+hdRhiROswqFTmaWoEwJ3bPmEwGfYjCe1hUKpf0zoMSqmoee0eBq89nXUrodoMDdrDoJSyaMKgVIryNls9DF57OutWQgmD9jAopWxxSRhEZJSIPC8iVSJSLSIviMjobhw3RkQWish2EWkQkQMislREzo7Q1iUit4tIiYg0ishqEflq39yRUv1fmp0wpOVGSBiytIdBKdVanycMIpIFLAamAN8EvgFMApaISPuHp63lAAeAO4EvA98GaoF/i8iFbdreBxQDvwXOBlYAz4nIl2NzJ0oll3SflTCk57V/JCF2D4PLHueglFLxGPR4DTAemGyM2QwgImuATcC1wC87OtAYsw4rSWghIouAbcDVwAv2tiLgVuBBY8xDdtMlIjIReBD4dyxvSKlkkO5rstZ57XsYXHYxJ2nUhEEpZYnHI4l5wIpQsgBgjNkGLAfO6+nJjDF+oArwhW0+E0gDnmzT/EngUBEZ19PrKJXsMu2EISM/r92+UG0GtyYMSilbPBKG6cDaCNvXAdO6cwJ7fIJHRIaKyI+BQ4BH2lyjCdjc5tB19rpb11EqVZhgkEx/MwBZ+e17GEK1GdzNmjAopSzxSBgGAhURtpcDBd08x8+xehR2A7cBlxpj3mxzjUrTvrBCedj+dkLFLMIXLeKkUkFjTR0uDI1uL26vt91+T47Vw+DRMQxK9TvhxZrCl2jF67XKSBWSehL9r4Gjga8ArwBPi8i5bc7V42sYY9otmjCoVNBQUQNAoyct4n6PPb+Ep7kpbjEppWKjuLg44u+3aMVj0GMFkf/CLyByz0M7xpidwE7703+JyFLgIeBf9rZyoEBEpE0vQ0HYfqWUrak6lDCkR9zvtROGNH0koZSyxaOHYR3WGIO2pgHre3nOj4CJba6RDkyIcA2iuI5SSamxqhaAprSMiPvT7HLRXu1hUErZ4pEwvAQcJyLjQxtEZCww297XIyLiAk4EtoRtfhVoBq5o0/zrwFr7rQyllM1XVQ10nTCk+TVhUEpZ4vFI4nHgBmChiNyJNdbgPmAH8FiokYiMwUoC7jXG3GtvK8Z6nLEc2AMMxarLcAxweehYY8w+EfkVcLuI1AArgUuAufTi1U2lkl1TtdXD0NxBwpBuJwzpvua4xaSUSmx9njAYY+pEZC7wK+AJrIGIbwI3G2Nqw5oK4KZ1r8dK4GbgUiAPK2lYDZxkjFne5lJ3YFWBvAkrsdgAXGyMeTnW96RUf+evsb71/Okd9DDY80uk+zVhUEpZ4jK9tTGmFOh0XgdjTAlt3mowxrxENx9bGGMCwE/sRSnVCX9tHQC+9MyI+zPzrXLRGZowKKVsKT1bpdZeUKkqUGMlDIGMyD0M3ox0/OLCawL4mzRpUKq/Cq/JEK2UThi09oJKVYE6O2HIzIq4X0RaajQ0VNVGbKOUSnzhNRmildIJg1KpytRaSYDpIGGAg0WdQjUblFKpTRMGpVJQsK4eAJMZeQwDQLNd1KlRexiUUmjCoFRKknorYSCr4x6GJq/Vw9Bsj3dQSqU2TRiUSkXdSBh8XquHwVerCYNSShMGpVKSq7EBALHnjIjEl2YnDNrDoJRCEwalUpLL7mFwZXeWMFivXPpr61ttr9lbRnNdfaRDlFJJLKUTBq3DoFKV2+5hcOfmdNgmVAXSX3ewh6GhqoamcePZOO2Yvg1QKRUTsazDEJdKj4kqFu+lKtUfeZqshMHTySOJgJ0wBMJ6E774YA0TGqrJ2L2lo8OUUgmkuLi45Y/iaJOGlO5hUCpVeZoarXU3EoZgWA9D1YatAOT4Ggn4fH0YoVIq0WjCoFQK8toJg3dAx48kTEYoYWho2dawbXvLx7V7y/soOqVUItKEQakUlN5sJQzpebkdtmlJGOoPPpIIbi9t+bh2vyYMSqUSTRiUSkFpdsKQNqCzhMGuAtlwsIfB/cWulo/r95X1TXBKqYSkCYNSKSjD12St8zp+JEFm+4Qhe9/ulo8byyr6JDalVGLShEGpFJThtxKG9PwBHbYxoSqQYQlDfvnelo+bNWFQKqWkdMKgdRhUKjLBIJl2wpDZyRgGV5bVwyCNjS3HFVXvb9nvK6/suyCVUjERyzoMKZ0whOYI14RBpZLm+kbcxtDk8uDNSOuwncvuYXDZb1RUlO4mM3DwVcpAZWWfxqmUil5xcXHL77popXTCoFQqqi+vAqDBnr66I65sK2EIVYU8sG5zq/1BTRiUSimaMCiVYhqragFo8naeMLjtHga33cNQvalNdceq6tgHp5RKWJowKJVimqpqrHUXCYMnx0oYQlUhG7daRZuCWM9CpVoTBqVSiSYMSqWY5mq7h8GejbIjobLRnmZrgKQp3QHAzvwhALhra/oqRKVUAtKEQakU01xj/aJvTuu8h8Frj2Hw2gmDd7dVtGnvyAkAeDRhUCqlaMKgVIrx2Y8kfOmZnbYLzTPhtYs8ZdlFmxonTQEgvV4TBqVSSUonDFqHQaUif401+6Q/o/OEId1OGNLshGFgxT4APIcfZu1vqIt8oFIqYcSyDoMnBvH0W7F4L1Wp/iZQa/2iD01f3ZH0XGsMQ7q/maA/QFHNAQAKjz0CgCxNGJRKeMXFxS1/FEebNKR0D4NSqShQZycMXfQwpNk9DBm+Jsq3lpIWDFCekUv+hFEAZDXVd3a4UirJaMKgVIoxdsIQzMzqtF2mPTFVhr+ZA+utok0HBhSSO2QwALnNdZhgsA8jVUolkrgkDCIySkSeF5EqEakWkRdEZHQ3jpslIn8Qkc9FpF5ESkXkKREZF6FtiYiYCMv5fXJTSvVTxn4kEczqPGHwZqQTEMFrAlSv3wRAdeFQ0nOzaHJ5SAsGaKpt6PQcSqnk0edjGEQkC1gMNAHfBAzwE2CJiBxmjOnsQeilwHTgN8A6YATwY+AjEZlpjNnRpv1rQHGbbRuivgmlkkm99ShBukgYxOWi0Z1Gtr+JpvWfA9A4ZDgiQm1aFumN1dTs3U/GgOw+D1kp5bx4DHq8BhgPTDbGbAYQkTXAJuBa4JedHPszY8z+8A0ishzYZp/3rjbtDxhjVsQqcKWSUoM99qCLhAGg0ZNOtr8J91arLHRw5EgA6jKyGNRYTf2+cpg0tq8iVUolkHg8kpgHrAglCwDGmG3AcuC8zg5smyzY27YD+7F6G5RSPST11mMEye66ZyBUPjpv5zYAvGPHANCQYR3bsL+8L0JUSiWgeCQM04G1EbavA6b19GQiMhUoAj6LsPsr9liHJhFZoeMXlGrPZc8+GZqNsjNNXmv662H7dwKQPXEsAI2Z1oDIxrKKPohQKZWI4pEwDAQi/VQpBwp6ciIR8QC/x+ph+GOb3S8DNwJnAlcAjcCLIvL1Ts7XbtEiTirZhaardud03cPgs3sYBjZaVR3zp1hloZuzrYShubyyDyJUSkUjvFhT+BKteBVuilQhqTfR/xY4ATjHGNMqCTHG3Njq5CIvAiuAnwJPRgxKCzepFOSxxzC4c3O7bOtrM9/EkGkTAfBnW8f6K7SHQalEE16sKVx/KNxUgdXL0FYBkXseIhKRnwL/BXzLGPN6V+2NMQHgOWCkiAzr7nWUSnah6aq9uV33MPjDZrQ8kJlHuj3ldSB3AADByqo+iFAplYi61cMgIocBJwODgMeMMXtEZCKw1xjT1Qw067DGMbQ1DVjfzevfAfwQ+K4x5onuHBM61F5rV4JStrRmK2Hw5OZ02dYf1sNwIL+IQvtjY/dOGE0YlEoZnfYwiEi6iDwHfIJVC+EuYLi9++fAHd24xkvAcSIyPuy8Y4HZ9r5Oich3seo23GGMebgb1wsd5wEuAkqNMXu6e5xSyc5rJwyh0s+dCZ9voqZwyMEdeXnWuro6prEppRJXV48k7gdOB74BDKH1uINXsAYYduVxoARYKCLnicg8YCGwA3gs1EhExoiIX0TuCtt2KfBr4FVgsYgcF7ZMC2t3mYg8IyJXisgc+7glwFHAD7oRo1IpI73Zmn0yLa9nCUPT0INvMrvyrYTBVaMJg1KpoqtHEpcBdxpjnhYRd5t924CxXV3AGFMnInOBXwFPYCUdbwI3G2Nqw5oK4KZ1EnOWvf0sewm3DDg1LJYiYD7WeIl64EPgLGPMa13FqFQqyfBZPQwZeV0PegxkHpygKlS0CcCdnw+Ap6arJ5JKqWTRVcIwiMj1DsD6xZ7ewb5WjDGlwFe7aFNCmzcnjDFXAVd14/wrgLndiUWpVJfhs3oYMvIHdKPxwR6GNLtoE4BnYD4A3vratkcopZJUV48ktgHHd7DvGPr5PA1ae0GlGhMMkum3EoasbiQMJmwK7FDRJoD0QVYJlfR67WFQKpGF12SIVlcJw9+AH4rIFUCavc2IyBzge8Cfoo7AQcYYjDGaMKiU4WtswmOC+MSNN7MbHYRhjyQGTp14cPNg603pjIbO5o5TSjmtuLi45XddtLpKGH4OLMIaexAqGv8O8Abwak/eWlBKOa+hwuoRaPCkddHSZicMQYSiKeMPbi60EoasRk0YlEoVnY5hsIsfXSoij2C9EVEElGElC8viEJ9SKoYaK6vJAxq96XRjBEPLFNj7swsYEtYjkVM0yFo31fdBlEqpRNStwk3GmLeBt/s4FqVUH2ussnoYGsMqOHbGlWX1MJTlFxFWhYGcImsMQ66vgaA/gMvT9iUqpVSyiUdpaKVUgmiutt5qaPZ2L2HwFA0GoGrYqFbb3V4vtfY5anSKa6VSQrseBhEJ0oNSysYY/dNCqX6iudrqYWjuZg/D4ddextubtzLmqovb7atNyyLH10j9/nLyhg2OaZxKqcQT6ZHEvRxMGAT4FpCJNX30XmAocC7QQPspppVSCcxXYw1S9KV3L2FIz8nipN/dH3FffUY21JVTv68sZvEppRJXu0cSxphiY8w9xph7AD+wHRhjjPmWMeZ2Y8zVWBUeS+39/ZbWYVCpxl9jPZLwdzNh6ExDpjXbZcMBfSShVKKKZx2Ga4H5xphWQ6GNMXXAQ8B1UUfgIK3DoFJNS8KQkRX1uZozrbkomssqoz6XUqpvxLMOQyEHCza1lYZVOlop1U8Ea61HEuFzRPRWc441F4WvvCLqcymlEl9XCcNHwD0iMiJ8o/15MdYET0qpfiJYZyUMwYzoEwa/nTD4K6uiPpdSKvF1VYfhu8BiYIuIrMAa9DgEOA5rRsjL+zY8pVQsmTrr6aKJQQ9D0E4YghWVra8RCFC7v4LcoYVRX0MplTg67WEwxnwCTAR+AQSAQ+31Q8AkY8yqvg5QKRVD9fZwpKzoxzCQl2etq6tbbX73pnvIHTaY1X96LvprKKUSRpeVHo0xZcAdcYhFKdXX7EcSJjs7+nMNsIpLS5uEIX3JGwDUPvkMfOui6K+jlEoIWulRqRQiDQ0AuLKj72FwF+Rb65rWCUPh7lIAitZ9EvU1lFKJo9OEQUQWd7G8Ga9A+4LWYVCpxtUYShii72HwDMy31nU1Ldt8DU2MqNwDwIR9JVTvORD1dZRSvRfPOgwurGqP4UshMBs4xP6839I6DCrVuEM9DDnRJwxpBdYEVGl1tS3bvvhkPV4TsK6BYetL/4n6Okqp3otlHYauprc+NdJ2EZkA/BN4IOoIlFJx426yEgZ3DBKG9MFWwpDeUNey7cDHnzImrE3NG8vgvy6L+lpKKef1agyDMWYL8CAwP7bhKKX6ktd+JOHNyYn6XBmDBgKQ1XCwh6F+7XoA9mZb+3I/0VItSiWLaAY97sd6LKGU6ie8TY3WOi/6hCGnyE4Ymg5Wjndt2gTAxtPmATBx+3oCPl/U11JKOa9XCYOIDARuAbbENhylVF9Ka7YShrQBuVGfK3uIVZgpp/lgwpBTus3a96XT2Jk3hBxfI1vfeC/qaymlnNfVWxLbRGRrm2UnVsXH04A74xKlUiom0nyhhCH6HobMAdn4xE1GwEdTrZU0FO21XqksnHUoOybPBGDvK/36ZSqllK2rwk3LgLZDKxuxprx+zh7LoJTqJ9J9TdY6Bj0M4nJRk57FwMYaavaV4W/2May2jGaXm+Ezp7LjuOPhg9fwrNAeBqWSQVdvSVwVpziUUnGQYScMGfnRJwwA9XbCULevjIqNJUwCduUPY1x6GkVfPg1+U8zIDatjci2llLO6eiTxJxEZ18G+MSLyp74JKz60cJNKNVl2wpBZMCAm56vPsF7PbDxQQfknawE4MMx6sXL83GOp8WYysnofe9drZ6RSTohn4aargMEd7CsEvhl1BA7Swk0qlfgamvCaAH5xkZaZHpNzNmbaCcP+cprXfWZ9PHY8AG6vl81jpwGw/aXXY3I9pVTPxLJwU3fekujoKkOBhqgjUErFRX2lNedDgycdccVmGpnmbOvRRnN5Je4tmwFwTZ7csr/myGOs/cvejsn1lFLOafdTQ0QuEJG/icjf7E33hD4PW54D/gh83J2LiMgoEXleRKpEpFpEXhCR0d04bpaI/EFEPheRehEpFZGnIj0mERGXiNwuIiUi0igiq0Xkq92JT6lU0FhhJQyN3tj0LgD47ITBX1FB3k7rlcrcw6e17M+dezIAgz5dGbNrKqWcEWnQ42jgJPtjA8wEmtq0aQLeBW7v6gIikgUsto/5pn3OnwBLROQwY0xdJ4dfCkwHfgOsA0YAPwY+EpGZxpgdYW3vA27Fmor7Y/vY50TkXGPMv7uKU6lkV3+g3FqnRz9TZUggx0oYAhWVDN+/E4Chxxzesn/CeWcQuE6Y+MVmGqpqyMyLzWBLpVT8tUsYjDELgAVg1WEAzjfGRDPM+RpgPDDZGLPZPu8aYBNwLfDLTo79mTFmf/gGEVkObLPPe5e9rQgrWXjQGPOQ3XSJiEzEKmGtCYNKeY0HKgBoyIx+HokQM8AaPGm2bqOgqZZabwaDDxnbsn/AkEFsHDyWQ/Zt4/OXF3Po18+L2bWVUvHV6YNMY8y4KJMFgHnAilCyYJ93G7Ac6PSnR9tkwd62Hass9YiwzWcCacCTbZo/CRza0ZseSqWSRruHoSkz+qJNLeyEIf+zNQDsGjSy3fiIfTOOAqDyP0tjd12lVNy162EQkZOBlcaYWvvjThlj3uqiyXRgYYTt64CLuhVl6/imAkXAZ22u0QRsbtN8nb2ehtUroVTK8lVUAtCcFbseBld+PgATdllzSFSMGNO+zfHHweLnSV+zKmbXVUrFX6QehqVYv2BDHy/pYAnt68pAoCLC9nKgoCfBiogH+D1WD8Mf21yj0rR/b6Q8bH+k87Vb9BVLlaz8FVUA+HJiU4MBwFWQB0CW3xrm5Bs/sV2b3KmTAMgu2xuz6yqlOhZeeyF8iVakQY9zgPVhH8dCpFczexP9b4ETgHOMMeFJiPTmGrF4L1Wp/iJg9zAEc2I38NBb0Drn906d3K5N3kSr1yG/6kDMrquU6lhxcXHEP36jTRoiDXpcFunjKFQQ+S/8AiL3PEQkIj8F/gv4pjGmbRWYcqBARKRNL0NB2H6lUlu19VplcEDsehjSC1snDHlHzGjXpvAQawhRYW0FJhiMWQ0IpVR8xeM7dx3WGIO2pnGwJ6NTInIH8EPgJmPMEx1cIx2YEOEadPc6SiW1KuuRhMQwYcgY1DphGH704e3aZBUMoDItm/Sgn4rSPTG7tlIqvrpMGETkmyLyqoisjzDVdXcKxL8EHCci48POORaYbe/r6vrfxarbcIcx5uEOmr0KNANXtNn+dWCt/VaGUinNVVtjrfPyYnbOzMEHOw8PZOaRN6IoYrvyXKtd+Sb9VlSqv+p0tkoR+TFwD7AWWEX7Ak7d8ThwA7BQRO7EGmtwH7ADeCzsWmOALcC9xph77W2XAr/GSggWi8hxYeetNsasBzDG7BORXwG3i0gNsBK4BJhLF69uKpUqPLW1ALgH5sfsnNlFg1o+3l00isIO2lXnF0LZDqo3b4czZsfs+kqp+Ok0YQC+DSwwxnyvtxcwxtSJyFzgV8ATWAMR3wRuNsbUhjUVwE3rXo+z7O1n2Uu4ZcCpYZ/fAdQCN2HNc7EBuNgY83JvY1cqmXjrrB4Gb0Hsehhyiw72MNSMHNthu4bCIbAFGrfv6LCNUiqxdZUwDAKi/oVrjCkFOp3XwRhTQpu3GowxV2HNmNmdawSwHl38pDcxKpXs0hus/DxtYI/eZu6UJz2NOk862f4mAhMnddjOP2QoAIGdu2J2baVUfHU1hmEZ0H4UU5LQ2gsqlWQ2WNO2hI87iIVae26K9OlTO240fDgAskcHPSoVT+E1GaLVVcJwM3C1iFwpIoX2jJCtlqgjcFBojnBNGFQqyGy0E4bC2CYMFQOskQtDZs/qsE3a6JHWer8mDErFU3Fxccvvumh19Uhio73+cwf7TTfOoZRKANlN9dY6bKBiLHj+9lc+WL2eY044ouNrjx0FQE5Zu+lhlFL9RFe/7O8lcgVFpVQ/EvQHyPE1ApBbFLsxDAATTz8eTj++0zb5k8Zaa632qFS/JalaHrl9UUilklf13jIGDC20BijaiUM8NVbXkZGXg0/cuJubcHnccY9BqVQnIhhjej2YoV+PQVBKdU/dPqs6em167Gaq7ImMAdlUpOfgNQHKt+ubEkr1R10Vbrqrk91BoAprKuzlMY1KKRVT9fusRwH19hsNTigbMIiC/bVUbNpO4YTRjsWhlOqdrsYwFGONYYjUhRHabkTkPawZJKtiG55SKhYay6x53hoznelhAKjJHwz7t1OzZTtwkmNxKKV6p6tHElOBzcD/AmOADHv9fXv7CcCldrsH+i7MvqF1GFSqaA4lDFk5jsXQUGjNM9Gg1R6ViptY1mHoqofhEeD/GWN+FbZtB/ALEXED9xtjThORccCNwPVRRxRHOuhRpYrm8koAfA4mDAG72mNQqz0qFTfFxcUtfxRHmzR01cNwPNZETpGsBEKTQX0ERJ6mTinlOH+l9bTQl5PrWAwywqr26Nqz27EYlFK911XCUAWc1sG+0+39YD2qqI5VUEqp2ApWVgJgcp1LGNJGW8Wb0vbvcywGpVTvdfVI4k9YU0bnAs8D+7B6Ei4CrgN+arc7FmsKbKVUIqqy8nmTO8CxELLH2dUeyzVhUKo/6iphCL1WeRPwP/bHAtRhJQuh/YuAv8c8OqVUTEiN3QGYF7uprXsqf9I4AAq02qNS/VKnCYMxJgjcKSIPAYcCw4DdwKfGmMqwdh/0ZZBKqei4qq2EwZXvXMJQOGmMta6vJODz4fZ6HYtFKdVz3Zo4yk4O3u7bUJRSfcVTV2utHUwY0rMzKcsYwKDGavZv3cngyeMci0Up1XPdKg0tIgUicoyInNx26esA+5LWYVCpIq2uBgDvwNhOPNVT5QOsmTIrNpU4GodSqSJudRhEJANr4OPFRK72CNBvZ5HROgwqVaQ31FnrQfmOxlFTMBj2baNmmxZvUioe4lmH4cfAqcA3sRKGG4DvAO8AW4Bzo7q6UiouMuyEIaNwoKNxNNrVHhtLNGFQqr/pKmH4KnAv8Iz9+fvGmD8bY04BVgNn9WVwSqnYyGqyEoaswYMcjcM/dBgAwV09q/ZogkF2vL8aX0NTX4SllOqGrhKG0cA6Y0wA8AHhM9f8CbikrwJTSsVOTlM9ANlFzvYwuIZbCUN3qz2aYJCPf/1nNoyayqjjZvLB2Zf2ZXhKqU50lTCUAaHi8zuAw8P2FQKZfRGUUip2Aj4f2f4mggg5Do9hSB9jFW/K2L+303ZBf4APHniUzcMmctT3vsWULzYCMOvtf1Gm4x+UckRXCcMK4Aj7438A94nI7SLyfWA+1lgGpVQCq9lbDkCtNwOXx9kxyjnjRgOQXdF58abl19zGMXdcz6R929iTPZC3rr2dTyYdRXrQz/r7FsQjVKVUG10lDD8DPrc//gmwGGtMw8+ArcB/911oSqlYqNtvJQx16VkORxJW7bG684Rh1EKrcOyyb9xE/u4dnPz7BwhcfwMAY158iqA/0LeBKqXakZ6+Wigi6UC6MaZfTzYlIkZfq1SpYNNr7zDprJPYUjiaCfu3OxqLr6EJd1YmRsA0NOJJT2vXZttbHzHulKOpSM8ht6qspU3A52PPoBGMqNnPJ797miOuuyze4SvVr4kIxphev1vZrodBROZ2tgCzgVlhn/dbWrhJpYLGsgprnZndRcu+581MpywzD7cxlG2JPBZh55+fBuCzI05slVC4vV62nGclCf5HH+37YJVKAn1duOkNIPSnd0dXMPY+gxZuUiqhNZdbCUNTlnNTW4erGDCQwQ2VVGzcxpBpE9rtH/jmqwB4Lji/3b6pP/4evqce4ci1y9nz6SaGHjqpr8NVql+LZeGmjio91mANcvwH1syUSql+yldWaa2zcjpvGCc1BYNh71ZqS0rb7TuwcRtTd3xOo9vLtG9d3G7/4EPG8v7MUzj2k8Vsuu8XDH329/EIWSlF5EGPc7ASha9iFWz6FuA2xiyLtHTnIiIySkSeF5EqEakWkRdEZHQ3j31ARF4XkTIRMSJyVQftSuz9bZfzu3MdpZJVoLIKAH9OYiQMjYOHANC0vX3xpg1/eBoXhnWHHEVOYeR5LzK+ez0Ah/z7WfyNWshJqXhplzDYicC3gaHAdUAR8JqIlIrIT0Vkak8uICJZWG9XTMEqMf0NYBKwRES681D1Rqx6D//qRtvXgOPbLN1KapRKVsEqK2EIDhjgcCSWYCfVHjP+bX2bN3z5Kx0ef9iV57N10CiG1FXwyW/+2jdBKqXa6fC1SmNMozHmaWPM2VgVHxcAXwbWishve3CNa4DxwPnGmH8aYxYC84AxwLXdOD7PGHMScF832h4wxqxos1T0IFalko+dMJCbGAmDa8QIa92m2mPtgQqmb/yYIMLk/7q8w+PF5WLXRd8AwPv4Y30XqFKqlW5Nb41V8bHEXgzQkzly5wErjDGbQxuMMduA5cB5XR1sjAn24FpKqTakxpramgTpYUgbMxJoX+1x/R+fJSPg47ORUxh8yNhOz3HonTfhEzcztqyiem9ZX4WqlArTacIgIrNF5PfAbuCvQC1wDtZjhe6aDqyNsH0dMK0H5+mOr4hIvYg0icgKHb+gFLhqrJIp7oJ8ZwOx5Y61ykPnVuxvtT3w4j8BKD+t6znt8kcUsXHEIXhMkE3PLop5jEqp9iLVYZgoIveIyBbgLWAycCsw1BhzhTHmtR7+1T8QiPRYoJye9VR05WWs8Q5nAlcAjcCLIvL1jg4IvZsavmhNBpVsvHVWD4OnIM/hSCyDZkwiiDBh3zbeufDbNNc34G9sYuqqtwEY8a2OH0eEKzv6BADqX3ujz2JVqj8Kr70QvkQr0muVG4Fq4AXgO0CoNFyRiBS1bWyM2dqN60QqeBB99K3juLHVyUVexJoL46fAkx0cE8sQlEpIafXWm9FpA52dqTJk8MQxvHXFjcx++mFOfPFPbBy/lP0Xf53ZTXVsGziC8SfP6tZ5cs8+A178I0Ufv9fHESvVv4TXXggXbdLQ0SOJAcBVWEWcNnWxdKUCq5ehrQIi9zzEhD0l93PASBEZ1lfXUSrRpdfXWmuHZ6oMd/KTC1j31EvsyBvCIXu3MvvhewHYOfv0bp9j8tfOptnlZtKeLVTt7Hz2S6VU9CL1MFwd42uswxrH0NY0YH2Mr9VWKJ3SrgSVsjIbrR6GjA7qGjjlsMvOpea09bxz0bc48a2FAAz8xqXdPj6rYACfjprKodvXsunZfzHrlm/3VahKKSIkDMaYWL/Y/BLwkIiMDz2+EJGxWHNS/DDG12ohIh7gIqDUGLOnr66jVKLLthOG7KJBDkfSXm7RQE5c9k9W/eUFGnd+wXEXdT3gMVzFMbNh+1oaX38TNGFQqk91VBo6lh4HbgAWisidWH/t3wfsAFpeohaRMcAW4F5jzL1h208BBmMVkgJr4qtaAGPM83aby7Be0fy3fd4hwPXAUYBOaadSWnZzvbVOwIQhZOZVF/bquLwvfwmee4whn6yIcURKqbZ6PL11ry5ilYH+FXAG1mOCN4GbjTElYW3GAtuAe4wxxWHblwKnRDpvaJpOETkOeADr0cdAoB74EJhvjHmtg5h0emuV9JrrG0jLzsIvLtx+H+LqbumV/qGxug4GFpAR8FG+bScDx45wOiSlEla001vHJWFIRJowqFRQVrKTQeNGUZmeTX5jrdPh9InVE47g8K2r+ODB33PMD7pTPFap1BRtwpBcf270kNZeUMmufp/1IlJdepbDkfSdqmNnA+D7z5sOR6JU4gmvyRCtlE4YjDEYYzRhUEmr4YCVMNRnJMZMlX2h4JwvATB09fsOR6JU4ikuLm75XRetlE4YlEp2jQeseRYaM7szMWz/dMh5p1PvTmPCgVIObCl1OhylkpYmDEolsebySmudxAlDek4WG8fNAGDLMy87HI1SyUsTBqWSmL+iEgBfTq6zgfSx6uNOBMD/5mKHI1EqeWnCoFQSCyUMgSRPGAZ95UwAhus4BqX6jCYMSiUxU2VNbR1M8oThkK+cRp0nnXHlu9j3eXfmw1NK9ZQmDEols6oqa52XGFNb9xVvZjobxh8GQMkLrzocjVLJKaUTBq3DoJKd1NRY67wBDkfS92pnHQtA89K3HI5EqcShdRhiROswqGTnrrUSBndBvrOBxEH+l+YAUPTpRw5HolTi0DoMSqlu8dZZCYMnBRKGifNOxyduJuzdSvXeMqfDUSrpaMKgVBJLq7fmj0hLgYQhq2AAm4ZPwm0MW/75utPhKJV0NGFQKoll2AlDeuFAhyOJj7KZswCofWOps4EolYQ0YVAqiWU21lvrwgKHI4mPjDmnAJD3sdZjUCrWNGFQKollNVkJQ9bg1EgYxl1gFXCaWPoZvvpGh6NRKrlowqBUkjLBILnNdQDkDhnscDTxUTh+FNsGjiQr0MzmV5Y5HY5SSSWlEwatw6CSWVNtA2nBAM0uN+k5mU6HEzdfTD8SgLJX33Q4EqWcp3UYYkTrMKhkVrvferWwJi0bcaXOt7qcaE1Elf7+ew5HopTztA6DUqpLdXYtgvr0LIcjia+R530JgPGb1mCCQYejUSp5aMKgVJJqOFBhrTNSK2EYdfSh7MvKZ1BjNSXLP3E6HKWShiYMSiWppgPlADRm5TgcSXyJy0XJITMB2P3Sa84Go1QS0YRBqSTVXFFprVMsYQBoPu54AGT5cocjUSp5aMKgVJJq3rPPWg/IdzYQBxSefToAIz5b6XAkSiUPTRiUSlLB7aUABIYNdziS+Jt45onUejMYXbmH/Z9vdTocpZKCJgxKJSn3rp0AuEaPdjiS+POkp7Fp7HQAtr6o4xiUioWUThi0cJNKZln7dgOQMWGMw5E4o2bWcQD43lzicCRKOSeWhZskFsUc+iMRMal67yo1bBs0knHlu9j8+jtMPGO20+HE3ZqnX+awK+axtXA04/dvdzocpRwnIhhjep05aMKgVBIywSAN6Vlk+Zuo2rmXvBFFTocUd831DfjyCsj2N3Fgw1YKDxnndEhKOSrahCEujyREZJSIPC8iVSJSLSIviEi3HqyKyAMi8rqIlImIEZGrOmjnEpHbRaRERBpFZLWIfDWmN6JUP1G5cy9Z/iZqvRkMGFbodDiOSMvKZOO4GQBs+fu/HI5Gqf6vzxMGEckCFgNTgG8C3wAmAUtEJLsbp7gRyAS6+o6/DygGfgucDawAnhORL/cucqX6r7L1mwHYN2BwSs0j0VbN8ScB4H9zscORKNX/xeMnyTXAeOB8Y8w/jTELgXnAGODabhyfZ4w5CSshiEhEioBbgQeNMQ8ZY5YYY64FlgAPRn0HSvUzVZu2WeuBQxyOxFmDvnIWACPXfOBwJEr1f/FIGOYBK4wxm0MbjDHbgOXAeV0dbIzpzuwxZwJpwJNttj8JHCoi+vBSpZTGrSUA1A8Z5mwgDpv8lTnUeDMZU/EFez7d5HQ4SvVr8UgYpgNrI2xfB0yL4TWagM1ttq+z17G6jlL9QqhoU3DESIcjcZYnPY2NEw4DoOTZlx2ORqn+LR4Jw0CgIsL2cqAghteojPDaQ3nY/nZC76aGL1qTQSUDzxe7AHCNHuVwJM6rm30yAMElOo5BpYbw2gvhS7TiNRoq0vuL0Uff+lw9voYxpt2iCYNKBqGiTVkTxjobSAIoOu9sAEZ/+qHDkSgVH8XFxRF/v0UrHglDBZH/wi8gcs9Db5QDBdI+hSoI269Uyiio2AtA3uQJDkfivElnnUhlWjYjq/ex8+N1XR+glIooHgnDOqwxBm1NA9bH8BrpQNufjqGxC7G6jlIJzwSDFNWUAVA0Y5LD0TjP7fWycfIRAJQ+p/UYlOqteCQMLwHHicj40AYRGQvMtvfFwqtAM3BFm+1fB9bab2UolRLKtu0kI+CjMi2bnMJYDRPq35rscQyupTqvhFK9FY+E4XGgBFgoIueJyDxgIbADeCzUSETGiIhfRO4KP1hEThGRrwFn2ZtmicjX7G0AGGP2Ab8CbheRW0TkVBH5HTAX+FFf3pxSiSZUtOlA3mCHI0kcwy606reNXfcRJtidN7WVUm15+voCxpg6EZmL9Qv9CayBiG8CNxtjasOaCuCmfRJzD3BK2OfX20vomJA7gFrgJmAosAG42Bij71KplFK90S7aNCi1izaFGz/nOMoyBjC0toztK1Yz5oQjnA5JqX6nzxMGAGNMKdDpvA7GmBIivNVgjDm1m9cIAD+xF6VSVtO2EgAahw53NpAE4vK42TzlKAatWsLOfyzShEGpXkjdIvOgtRdUUjKlOwAt2tSW72RrHINX6zGoFBJekyFaKZ0waO0FlYy8u62iTZ6x3ZoQNmWMvuJCACavex9fQ5PD0SgVH+E1GaKV0gmDUskoe/8eALLGj3U2kAQz+pjD2DJoFHnN9Xz2f/p6pVI9pQmDUklmoF20KX+KFm1qa9fs0wCofu4fDkeiVP+jCYNSSSTg81FUYxU2LZo+0eFoEk/BpdbY69ErlujrlUr1kCYMSiWRss2leE2AsowBZOblOh1Owpn2tTMpz8hldOUeSt752OlwlOpXNGFQKomUfbYFgAP5WrQpErfXy4bDZwOw8y9/dzgapfoXTRiUSiI1m7YCUD1oqMORJC7XefMAyF/8usORKNW/pHTCoHUYVLJp2rrdWmvRpg5Nufoiml1uppWupWL7F06Ho1Sf0joMMaJ1GFTS2WEVbTIjtWhTR/KGFrJu/OG4jWHDn/SxhEpuWodBKRVR2h7rL2bv2DEOR5LYak+35rKTf2k9BqW6SxMGpZJIzv7dAGRPGudwJIlt7NWXAjBl7Qqt+qhUN2nCoFQSGVSxD4ACLdrUqVHHHMrWwtFa9VGpHtCEQakk4W9qZnB9BUGEoqnjnQ4n4e06YS6gVR+V6i5NGJRKEvs/34rbGA5k5ZGWlel0OAkvVPVxzHta9VGp7tCEQakkUfa5VbSpLL/I4Uj6h6lfO5O92QWMqtrD+udecTocpRJeSicMWodBJZO6TdsAqCnUok3d4fZ62TjnKwBU/u7/ORyNUn1D6zDEiNZhUMmkeZtVtKl52AiHI+k/ht98HQAz3nudxqpah6NRKva0DoNSqh0pLQXAjNKiTd014bTj+XzYJPKa61n92786HY5SCU0TBqWSxMDP1gCQM+sIhyPpXw5ccDEAniefcDgSpRKbxKKboj8SEZOq966ST115FWmFg3ARpH7PAXKLBjodUr9RVrKT3AljcRlDxWebGTxZi16p5CQiGGN6PZhBexiUSgKbF76B1wTYPGSCJgs9NGjsSFZNPx6PCfL5Q79zOhylEpYmDEolgerXFwOw//CjHY6kn7rymwAMW/ic1mRQqgOaMCiVBHI/WgFA2iknORxJ/zTzf66gPCOXiftL2PTK206Ho1RC0oRBqX7O39TMpJJ1AIy78CyHo+mf0rIyWXfSlwHY9/BjDkejVGJK6YRBCzepZLD5lbfI9jdRmj9MB+xFYfD/fAeAKW8t0hksVdLQwk0xooWbVDLY/8qbAOycdqTDkfRvk+fNZfPgMRQ2VPPxg486HY5SMaGFm5RSLdJXvAuAOUnHL0RDXC72XW1Vfiz83QJMIOBwREollrgkDCIySkSeF5EqEakWkRdEZHQ3j80QkfkisltEGkTkPRE5OUK7EhExEZbzY35DSiUIEwwyftMqAEbO+5KzwSSBo+66iT3ZA5m4fzsrH3nS6XCUSih9njCISBawGJgCfBP4BjAJWCIi2d04xR+Ba4C7gHOB3cBrIjIzQtvXgOPbLMuivAWlEtb2d1dR2FDN/sx8Rh93uNPh9Hvp2Zlsuvwa6+NfzHc4GqUSSzx6GK4BxgPnG2P+aYxZCMwDxgDXdnagiBwOXA58zxjzuDHmTeBioBS4N8IhB4wxK9osFTG9G6USyBcvvQbAtkMOR1z6hDEWZt7/AyrTs5lRuo5Pn37Z6XCUShjx+AkzD1hhjNkc2mCM2QYsB87rxrE+4O9hx/qBZ4AzRSQ99uEq1Y8sXw5A8/EnOBxI8sgdXMCaeV8HoPm++x2ORqnEEY+EYTqwNsL2dcC0bhy7zRhTH+HYNGBim+1fEZF6EWkSkRU6fkElu5HrPwag8OzTHY4kuUz72Z3Uu9M46vP32fTaO06Ho1RCiEfCMBCI9FigHCiI4tjQ/pCXgRuBM4ErgEbgRRH5ekcnD72bGr7oK5aqv9j3+VZGV+6h1pvBxDNPdDqcpFI4biQrT7sAgLIfR3r6qVTiCq+9EL5EK14PPSO9ANqd6KW7xxpjbjTG/M0Y87Yx5nngNOAj4KcdBmW/mxq+aMKg+ottL1rjFzaNnY4nPc3haJLPuAfvxidujv7oDXZ88KnT4SjVbeG1F8KXaMUjYaigdU9ASAGRew/ClXdybGh/RMaYAPAcMFJEhnUjTqX6Fd8S6wWg2lnHORxJchpxxFQ+PPZM3MbwxXU3OR2OUo6LR8KwDmssQlvTgPXdOHac/Wpm22Obgc3tD2kl1BMRfWqlVAIxwSDDP3kPgAFnzHE4muQ19ve/pN6TzrGfLGHVH/7P6XCUclQ8EoaXgONEZHxog4iMBWbb+7o61gtcFHasB7gEeN0Y02HBd7vdRUCpMWZPr6NXKgF9+sQ/GX+glAOZA5j8tbOdDidpDT98Mh9d8T8A5P/w+zTVth1/rVTqiEfC8DhQAiwUkfNEZB6wENgBtEwLJyJjRMQvIneFthljVmG9UvlrEfmOiJyG9UrlOODusGMvE5FnRORKEZkjIpcCS4CjgB/0+R0qFWfN838BwGfzriAjt20HnIql4x69n20DRzK2Yhfv//ftToejlGP6PGEwxtQBc4GNwBPAU8A2YK4xpjasqQDuCDFdDfwZ+AmwCBgFnGWMWRnWZhtQBMwHXsdKRJrsds/E+p6UclLJOyuZte5dGt1ept7/Q6fDSXppWZlU/fyXAMz6v9+za2VXT1KVSk4Si5GT/ZGImFS9d9W/vXPaRZy4+HmWnzSP2W8tdDqclPH+Uadx7MrFfHjoiRy95m2nw1Gqx0QEY0yv369M6VqyWntB9TcVpbs5cpk19Gfo3dq7EE9j/voYtd4Mjv70HT5++G9Oh6NUt4TXZIiW9jAo1Y+8deXNnPzEAlYecjRHbvjA6XBSztvX/ICT/t/P2Z+VT/DDjxgybYLTISnVbdrDoFSKaK5vYPIL1l+2csv3HI4mNR3/2/tYNf4IBtdXsv+seTTXNzgdklJxowmDUv3Exw/+niF1FWwpHM3May5xOpyU5ElPY+Tr/2R3ziBm7FjPBxdc7XRISsWNJgxK9QMmGGTg448AsOfq63QqawcVThhN+Z+fotnl5sTX/86Ke37jdEhKxYX+1FGqH1h+/Z1M3rOFA5l5HHXnd50OJ+VN/9qZfHDDnQAc9pPb2PLGuw5HpFTf04RBqQT3+UuLOeYPPwdga/HPyRiQ7XBECmD2r+7ivWPPIsvfRPrXLmT36s+dDkmpPqVvSSiVwKr3llE5ZQajK/dY9RfeeNbpkFSY+opqSmfMYsoXm9iZNwTXkiUMP2Kq02EpFZG+JREFrcOgEpkJBll/7qWMrtzDxiHjmfXCn50OSbWRVTCAoe+/zWfDD2Fk1V6Cp57Krk8+czospVpoHYYY0B4GleiW3/ZTZs//EXWedPYteZdxJx7pdEiqA1W79rHr2JOZtmsDOwcUweLFjDwq0iS9SjlHexiUSkLrnnuVI35ZDMCaHz6gyUKCyxtRxIgP32b9iCmMrN6Ha84cNv77LafDUiqmNGFQKsF8tOCvjLvsPLICzSw/4RyOv+8Wp0NS3ZA3bDAjPnqbtaOmMbxmP6Pmnc67t//c6bCUihlNGJRKIMtv+ykzv/ctsgLNvDv7XI5d/ILTIakeyBtayMS1H7D8pHlkBnyc8OAPePfk82isrnM6NKWipgmDUgnABIO8ffkNzJ7/IzwmyNtfvYbj31qIJz3N6dBUD2UMyGb2WwtZ/oMHaXB7OeHtlyidfDhbF69wOjSloqKDHpVy2L7Pt1Jy6bc4ZvUyggjvffduZi+42+mwVAxs+Pcysi6/lFFVe/CJmxXnXsERf/o1OYUFToemUpAOelSqnwr6Ayz/3n2kH34ox6xeRp0nnY9+9ntNFpLI5C+fwoB1q1k+50LcJshJL/+NmnGT+ODB32GCQafDU6pHUjph0DoMyimbXnuH9RMOZ/av7yKvuZ6Ppx5H1YerOOa2/3I6NBVjeSOKmL34H2x48TU+GzaJYbVlHHP7/7Bu3GGsfPRJTRxUn9I6DDGgjySUE9Y9+28a7r2fWeusuQf2Z+Wz9Y77OeaHOqFUKgj4fLz3/Z8y/ffzKWiqBWDD0IlU3Xwrs/73O7g8bocjVMks2kcSmjAo1cf8Tc2s+v3/kfbrX3BYyacANLi9fDz3Qmb8aQH5I4c4HKGKt5p95XzywweY+swfGdxQCUBp/jBKvnIxh9x2A0NnTHQ2QJWUNGHoJU0YVF8ywSAb/rWUA4/+P6a89W8KG6oAqErLYs05lzF1/l0UThjtcJTKaQ1VNXx853zG//X3DK/ZD0BAhFWTjyFw5TeZfu3lZA/MczhKlSw0YeglTRhUrPkamvjs2UVU/eMlRi5/k3HlO1v2lRSMYMf5l3L4T29nwJBBDkapEpG/2cfqx58h8PgfmfnpO6QFAwDUu9NYN/Voms49jynXXkHh2OEOR6r6M00YekkTBhWtgM/HlteXs++VN0l7+y2mfPYhA3wNLfsPZA7gs5POpvC/v82UeafpGAXVLQe27uCznz3CoEULmbbr4JTZfnGxdtRU9pwwh9wL53HYOaeQm6V1OlT3acLQS5owqJ4wwSC7Vm/gizeX0/T+h+SsXsnEknXkhiUIAFsLR7Pr2JPJvWAe0y+fhzcz3aGIVTLYt34zmx97kuxX/sW0zavwmkDLvp1ZA1k1aRZlx55I5tlnMmPWIUwePgC3JqaqA5ow9JImDCoSYwy7D9Sy871PqH7vQ1yrV5G/aT1jdm5iUGNNu/Y78oayc8pMgrNnM/brX2XEEVMdiFqlgvp9ZWx9+kV8Ly1i9IdvMai2vNX+NQWjWT7iULbPOBrf8Scw/pBRTB+Vz6RhAxhekBmT1+pU/6YJQy9pwpCajDFU1DWzs6yeHWV17Nm+F9+qVaStW8vALZ8xeudmplTsICvQ3O7YivQcto+eTM3UQ0k77hjGnvclhkyb4MBdqJRnDA0ffsze519G3niDYWs/Is138P9sQITVBWNZPmQKK4oms3rEFPLGjWbi0FzGFuUwZnAOYwdnM2ZwDiMHZpHu1dc5U4EmDL0kIi03fvfdd2vxpn6usTlAWW0TB6ob2VfdyL6qg+u9lQ3sOVBLWskWBm3fxKT925lRUcqMilLG1u2PeL49+UPYO3YyjdNmkH70UQydcwJDDj1ExyGoxNTYCMuX0/DaGzS/uZicNZ/g9vtaNdmcO4T3Bx/C+4Mn8VHhBNbnjyLgshKFwtx0Rg7KYnhBFsMKMhman8mQPGs9ND+TwQPSKczNICNNE4v+pri4mHvuuaflc00YekF7GBKLMYYmX5CaRh9V9c1U1/uoafRRWWd9XlnfTFVdMxWhpbaJ8tpmymubKKttorbRHzoRo+oOMK1yJ1OrdjK1chfTKncwpXIXGUFfu+v6PV7KRk+kceoM3EcdQf7xs8g5dhYUaK1/1Y/V1cF778Hbb8M772BWrEDq61s1afRmsLZoPCvyxrJy4Fg+GTSeLblDMNJxUpyb4WHwgAwG5qQzMCeNQbnpDMxJpyA7jfzwJSuNvKw08rK85GWlkZnm1kciCUB7GHoplROG4uLiXvWoGGNo9AVoaA7Q5AtQ3xygsTlAfbO/Zd3QFKCuyU9Ds7Wub/JT1+SnrtFeN/mpa/RR2+SnttFPbYOP6gYftY1+fIHul8j1BP2Mq9nHpOrdTK76gqnVu5hWs5uJlbvIbm6IeIxvxEg49DBW1FRx0g03wGGHwSGHgMfT43+L/qy3X/9kkZL37/PB6tW8cuednD1wILz/Pmzd2r5Zdi77x01mx8gJbBw8njX5o/gwcyhfNML+6kb8gd79zPS4hdwMLwMyveRmesnJ8JKb6SE73UNOhpecDA/ZGdbn2ekesjO8ZKe7yUzzkJXmISvdTVa6hwyvtc5Mc5OZ5ibD27NEJCW/9mH6RcIgIqOAXwFnAAK8AdxsjCntxrEZwH3A14F8YBXwA2PMW23auYAfANcCQ4ENwL3GmH90cN6ESxiCQYMvEMQXCOIPGHsdxGd/7PMHW68DQXx+Q3MggM9vtWn2B2j2W22a/EGaW5ZAy8e//PVvuOba/6bZH6DJZ7Vr8gVo8lsJQLM/SKPPSgoafUEam/3W2hfo+iai4HELAzKtv0oGZHoZkO5mnK+KiTV7GFO5mxHluxiydwcDd5WQs3sHLr8/8omKimDGDJg+3VpmzLCWPKsAjv1N06f3ksj0/lP3/lvd+/79VuLw8ccHly++aH+QywXjx2OmT6dx0hQqx07iwPAxfDF4JPtNGmU1TVTWNVtL/cF1Vb2Panvdlz87MrxuMrwuMtKsRCLd/txaW5+ne1xkeN08/eTfuPaab5PudZHmsbane914Pa6DH7tdpHmsxWuv09xWG69bSPO48boFj93O67baedxifWwvHnds5m+IpYRPGEQkC1gNNAF3Agb4CZAFHGaMqevi+KeAc4DvA1uB64GzgeONMavC2t0P3ArcAXwMXApcA5xrjPl3hPOany9cSzAYJBA01mJMy8fBoMEfsD722238AUPQGPwB+/PgwY9D+/1B65d90D7OF7DaWOcKSwSChkB4MhAI0h9+hqV7XfY3qNvO8q1v0ow0N9npHjLTPGSnu8lI85Blbwv9tZCV7iE3w9vyl0ROmpv8mnJy939B9t7deHeWIiUl1l8+27ZBSQk0tx98CIAIjB4NkyfDtGkwderBpbCw03tI5V8YoPefyvff5b3v2QOrVsHq1QeXDRsg0MEv/OHDrV66iRNh/HiYMMFajx0LgwZZ36dAsz9ATYOfmkYfNS29ij5qG/xWb2ODj/pmq9cx1CsZWod6KxuaAzQ2+1v1bDb5EnviLrcrlERYCYYn7GOvW3C7rMTC43Lh9bT+3O0SPG6x1/bnYR+HllBbt0twhR3jloNtXfax3zt3esInDDcBvwQmG2M229vGAZuA24wxv+zk2MOxehS+ZYz5s73NA6wDNhhj5tnbioAdwIPGmLvDjn8TGGyMOSzCuU3ON56KzU3GkAtDRpqn1X+ugxlsKMM9mNV63S62b9vKtCmHtGxP87rtrNhFmtfalu45uP3W793EY797lHSvi3SPmzQ7CUj3uK1tYZl5KFP/xc8f5L7iu3C5uvF/rbERysr4/b33ct0FF8DevdYPot27rb9gdu2yli++sLpKOzNkCEyaZC0TJ1rryZOtdWZmr7oYe/MLozfX6ekx8bgGxOf+43Uv8bj/RL6Xnh7Tm6/9fXfeyY8vuQTWrbOW9eth40bYtAmamjo+MDPTSupHj4ZRo6zkYtiwg+uiIhg8GLKzwZ41uKf/x+666+6Wx6QHe0WthKLBF6DZ7hlt9lvbv37l1fzuscftHtWDPa9NviC+gNXj2mz34DbbPa+ffb6RMePG02z37ja39PAafP5Aqx7gUI9wk8+PIbF6FwBqn7gi4ROGN4EMY8zsNtuXARhjTunk2B8DPwbyjTH1YdvvAX4IDDDGNInIN4C/AYcYYzaFtbsa+BMw3hizrc25zfzfvYYrLFNzibW0ZG9uwSNWdvaDH9zGr375i5bMLbQ/lPW5RPB67GxOrCzx3HO+zH9efxWPCO5Qhuh22VmidV6vy04EPNY5RowcyRe7dvXo33j4iBE9OmbEiBHs2rEDgkEwxlr7/dYv79DS1GT94m9ogMZGrrzoIv72yCNQW2stNTVQVQWVlQfXZWVw4IA14Kq7Bg8++ENl9GhuWrCABS+9BOPGWUt2dqeH9+YHYKIek6hx9eaYRI2rN8ckaly9OSam1wgEYMcOqwdi61bYsqVlXblmDfndvUBmJgwezCelpRwxZ4414LigwHqEmJt7cMnOttray7Fz5vD+xx+D13twcbutXg2Xy1raPBLo6c/KaI7ZtXOn1ets9yj7AsGWXmV/0OpxDti90qd/6UwWLXrF3n6w5zoYNPhNEL/fEDRYvdR2m+/d8r/87Gc/t9sYgkFajg0aqze8pWfcbvOj689K+IRhD7DQGHNtm+2PAhcZYwZ3cuwzwBHGmMlttl8M/B2YYYxZJyIPAjcDmeEDE0TkGOB9rMcSi9qcI0U7JePA64VBg1i9Zw+Hn3GG1UswZAgMHQojRhxchg+3vvnD6A/zxIurN8ckaly9OSZR4+rNMXGNq7LSSihKS6317t0Hexl377bGUOzbZ/1houJCiO61yngMDx8IVETYXg509e5aZ8eG9ofWlRFGMbZt10ridRglCZ/PegQB8J//9Pjwng4U6s3AokQ9JlHj6s0xiRpXb45J1Lh6c0zc4srP7/ExKrHF632ySOlpd/4HSjeP7W67gwFFkWUppZRSqSYeZesqiPwXfgGRew/ClXdybGh/aF0g7dPgtu2UUkop1QvxSBjWAdMjbJ8GrO/GsePsVzPbHtsMbA5rlw60Lew/zV53dR2llFJKdSIeCcNLwHEiMj60QUTGArPtfV0d6wUuCjvWA1wCvG6MCb3T8ypWAnFFm+O/DqwFtovI7SJSIiKNIrJaRL7aneBF5Csi8rSIbBSRoIgs7c5xThCRUSLyvIhUiUi1iLwgIqO7eWyGiMwXkd0i0iAi74nIyX0dc6xEee8PiMjrIlImIkZErurjcGOut/cvIrNE5A8i8rmI1ItIqYg8Jdarz/1GFPc/RkQWish2+//9ARFZKiJnxyPuWInm/3+b89xufw+80xdx9pUov/9NB8vMPg47JqL92ovIVBF5zv6/3yAiG8Qqh9CeMaZPFyAbqyfgU+A8YB5WIaetQE5YuzGAH7irzfHPYD26+A5wGvA80Agc2abdg/b2W4BTgd8BQeArwP1YhaNuBeYAj9n7vtyN+P+I1UPxN6AUWNrX/2a9/HfOwqptsRY43/63/hTYAmR34/ingEqsYlenAS8ADcBMp+8tDvdeA7wN/BVrLMxVTt9TvO4feAhYDvwPcApwOfAZUAaMcvre4nD/0+3v8W/YPxvOA/5l/z+40Ol76+v7b3Oe8UAtsBd4x+n7itf921/rPwPHtVmynL63ONz7LKAa64/z8+3vgf8CbonYPk43NRr4hx1YDfBPYGybNmPtL1xxm+2ZWIWf9mAlBO8Dp0a4hhurkuR2rORgDfA1oMj+/J427d8E1nQjdlfYx++QuAnDTUAAmBi2bRxWEhbxix/W7nD73/7qsG0erPLaLzl9b3157+FfY2Ai/TNhiOZrPzjCtjFYCfW9Tt9bPL7+Ec7nwSoE97LT9xbP+wdew/pjain9K2GI9vvfAD9x+j7ife9YTxjWAS9293pJP/mU9KKoUyfnegfwG2NO7YtYoyFxKJDVJ4HHQDT33qb9RKxs/WpjzF9iHWdfidX9tzl2L/AvY8y3YxNl3+mj+18LbDTGXBibKPtOLO5fRC4HFgCTsXoXPcaYE/sg3JiL9v5FxAD3G2Pu7Lso+0aUP/fnYv3hfLIx5u3uXC8eYxicNh2rh2Fzm+3r7PU0ksN0rG6pttbR9T1OB7aFJwthx6Zh/eWdyKK592QQ0/sXkalYPXOfRRlXvER9/yLiEhGPiAy1E+hDgEdiGGNfiur+RaQAa3LA24wx/fGNslj8//9vEWmyx/EsFpGTYhden4rm3kMJYYaIrBARn4jsE5HfiEhmpANSIWHoVVGnfigeBbISVTT3ngxidv9iDSr+PbAf69l+fxCL+/854AN2A7cBlxpj3oxNeH0u2vufD2wE/hLDmOIp2vt/EmsMz+lYz+8HAYtF5NQYxdeXorn34fb678DrWLNJ/xxrvODTkQ6IV+GmmBGR04HulA9cZj866HFRp36srwtkJbL+Hn+0YnX/vwVOAM4xxnRVJyWRRHv/v8YaYD0UuBJ4WkS+Zoz5Vwxii4de3b/9l/SVWIPI+/Pz6V5//Y0x3wj79G0RWYj1V/tPOPhXeCLr7b2HOgyeNMbcZX+8VETcwIMiMs0Y06okQb9LGIB3gandaBfqXm8p6tTmGyLZijpFWyAr0ms4/eXfKJp7TwYxuX8R+SnWX1jfNMa8HqPY4iHq+zfG7AR22p/+S6zXpx/CemMi0UVz/49h9STtFJF8e5sHcNufNyTy+CVbTL//jTE1IrIISPjxO0R372X2uu0f4K9jvXU4kzY1jPpdwmA/Z/+8B4eEF3UKH8eQbEWdoi2QdYGIZLUZx9C2QFaiiubek0HU9y8id2ANcP2uMeaJGMYWD33x9f8Ia0K7/iCa+59qL9dF2FcBfA+r9yWR9cXXv6Ne10QT7c99aH+fod6JYNsDUmEMQ6dFnbr7hkQ/EI8CWYkqmntPBlHdv4h8F6v79Q5jzMN9FWQfiunXX0RcWF3RW2IVYB+L5v7nRFhWY3XJz8Gqe5PoYv31HwCcg/UKf6KL5t5fwXoh4Kw228+01x+1O8Lp90jjsdBJUac27d4ENrfZNgarnsPXsEaNrwv7fIzT9xYWZ1wKZCXiEoN7P8X+et6AlW3/NvQ1dvre+vr+gUvt74VXaF+4ZprT9xaH+y8GfoOVHJ9ir1+3/00udfre+vr+OzjfUvpXHYZovv63Ao9jFSw7FfimfZ5m4CSn762vv/bA3fb2B7AGff4Qq2DfXyJez+kbjtM/asSiThHaLQVK2my7yv4lEmm5yul7axNrnxfIStQlyntf2tHX2On76uv7xxoZ39H/76VO31cc7n8esBjYZ/9s2I71l9lsp+8pHvffwbmW0o8Shii//l/BqnR6AOstmTL763+M0/cUj6891uOHW7CSjmb7//+9gDfStZK+cJNSSimlopcKYxiUUkopFSVNGJRSSinVJU0YlFJKKdUlTRiUUkop1SVNGJRSSinVJU0YlFJKKdUlTRiUUkop1SVNGJRKUiJiurGUiMhY++OrnI45RERGiEidiMzqg3MfISL1IhJpwjWlVAe0cJNSSUpEjmuz6UWssrHFYduasCapOQLYYozZH5/oOicifwKKjDHn9tH5FwKVxphv9sX5lUpGmjAolSJEpASr5O/XnY6lMyIyBNgBXGCMWdRH1/gysBBrPpgv+uIaSiUbfSShVIqL9EhCRP4iIjtFZJaIvCsiDSKyQUTOsfffYj/OqBaRhSIyuM05PSJyu4h8LiJNIvKFiPxCRDK6EdJVWDXxX2tzzqUi8o6InC4iK+3HCmtF5Pw27Q4RkRdFZJ+INIpIqYg8Z8/AGvI6Vu39q1BKdYsmDEqpjgwA/gb8P+ACrAma/iEiv8Ca+vh64Gb740faHPsk1oRvT2NNFfxT4NvAU9247lnAe8YYf4R9E4AFWBOlXQjsBp4XkYlhbf4FjAD+G2uq3h9iPXpp+Xlnn/s92k/tq5TqgKfrJkqpFJULXGeMeQtARL7AGgNxLtbU1wF7+wzgRhFxG2MCInIS1jTR3zTG/M0+1xsiUg48KSIzjTGrIl1QRAQ4FvhVBzEVAicbYzbZ7VdiJQ0XAw+ISCEwCTjPGPNS2HFPRzjXJ8D3RcRljAl25x9EqVSmPQxKqY7UhZIF2+f2+o1QshC23QMMsz8/C2uq3H/YjyY89uOA1+39J3dyzXysqdY7Gny5KZQsABhj9mH1fITeeCgDtgIPisg1IjKpk2vtB9KBgZ20UUrZNGFQSnWkMvwTY0yz/WFFm3ah7aHxCUVAGlAL+MKWffb+QZ1cM3SOpg72l0fY1hQ6zlijuM8APsJ6DLJRRLaKyH9HOK7BXmd2Eo9SyqaPJJRSsVYGNAIndbC/s7cSyux1QW8vbozZClxpP944HLgBeFRESowxr4Q1DfUsHOjttZRKJdrDoJSKtVex/uLPM8Z8FGHpMGGwezG2AeOjDcJYVgG32JtmtGkyDthhjGlAKdUl7WFQSsWUMWapiPwf1tsLvwQ+AILAWODLwA+MMRs7OcVbwDG9ubaIHIb1FsXfgc2AG+vVST+wuE3zY+1rKaW6QRMGpVRf+DpwI/At4A6scQYlWLUV9nZx7N+xHimMNcaU9PC6e4BSrF6FkViPRj4FzjXGfBxqJCKjsB5X/LiH51cqZWmlR6VUQhERF7AJ+LMx5id9dI0fYNVpmNDmjQ+lVAd0DINSKqHYNRHuwqrtkBXr89vVJm8C7tJkQanu00cSSqlE9DRWtcaxWJNjxdJYrHEOT8T4vEolNX0koZRSSqku6SMJpZRSSnXp/wM9dyWmV1IqXQAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Calculate time-domain response\n",
"t, s21t = czt.freq2time(f, s21f)\n",
"\n",
"# Apply window (not really needed in this case, but used as a demonstration)\n",
"t1, t2 = 0*sc.nano, 0.5*sc.nano\n",
"idx1, idx2 = np.abs(t - t1).argmin(), np.abs(t - t2).argmin()\n",
"window = np.r_[np.zeros(idx1), \n",
" tukey(idx2-idx1, 0.5),\n",
" np.zeros(len(t)-idx2)]\n",
"s21tw = s21t * window\n",
"\n",
"# Plot time-domain response\n",
"plt.figure()\n",
"plt.plot(t/sc.nano, np.abs(s21t*np.hanning(len(s21t))), label=r'$S_{21}$')\n",
"plt.plot(t/sc.nano, np.abs(s21tw), 'r', label=r'$S_{21}$: windowed')\n",
"plt.autoscale(enable=True, axis='x', tight=True)\n",
"plt.xlabel(\"Time (ns)\")\n",
"plt.ylabel(\"Magnitude\")\n",
"plt.xlim([-0.1, 0.6])\n",
"plt.ylim(ymin=0)\n",
"plt.legend();"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Recover frequency-domain using arbitrary frequency sweep\n",
"f_new = np.linspace(280, 380, 25) * sc.giga\n",
"f_new, s21f_twindow = czt.time2freq(t, s21tw, f_new)\n",
"\n",
"# Plot frequency-domain\n",
"plt.figure()\n",
"plt.plot(f/sc.giga, db20(s21f), label=r\"$S_{21}$: original\")\n",
"plt.plot(f_new/sc.giga, db20(s21f_twindow), 'ro--', label='$S_{21}$: windowed')\n",
"plt.autoscale(enable=True, axis='x', tight=True)\n",
"plt.xlabel(\"Frequency (GHz)\")\n",
"plt.ylabel(\"Magnitude (dB)\")\n",
"plt.xlim([250, 400])\n",
"plt.legend();"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
CZT-0.0.7/examples/results/ 0000775 0000000 0000000 00000000000 14131365315 0015477 5 ustar 00root root 0000000 0000000 CZT-0.0.7/examples/results/freq-domain.png 0000664 0000000 0000000 00001443270 14131365315 0020422 0 ustar 00root root 0000000 0000000 ‰PNG
IHDR c
V Õ#R@ 9tEXtSoftware Matplotlib version3.3.2, https://matplotlib.org//Š pHYs \F \F”CA IDATxœìÝw˜5wY?þ÷^h¡$t„Œ ]B„€€tAù R,((øµ "%”ÐEŠHoRHï½Bï$!!Éýûc6b’gç윳Ͼ^×µ—fîù¼Ÿ³gÎÌ&Ïç½ÕÝ Øîv™; À*PÆ e, I”± $QÆ D @e, I”± $QÆ D @e, I”± $QÆ D @e, I”± $QÆ D @e, I”± $QÆ D @e, I”± $QÆ D @e, I”± $QÆ D ÀʨªçTUøºçÜ™6SU5òsòFsg `kQÆ e, I”± $Iv›; ÀvRU_Lr©¹s,Kw×Ü `Q»Ì `(c ˆ2 €$ÊX ’(c H¢Œ ‰2 €$ÊX ’(c H¢Œ I²ÛÜ Ø¡w÷Qs‡ ˜[wßhî ìÜv™; À*PÆ e, I”± $QÆ D @e, I”± $QÆ D @e, I’Ýæ ËTUWNrH’Ë'¹B’ƒ’œ/ɹ־öIrB’c“|'É’|2É[»û¨ÍOœTUe½F’Ë&90Ée’dß™÷MR²ŸäÇI¾’!ÿ1I>’ä]Ý}ìfçŸKUíšäZk_WZûºh’ó$9w’Ý“ü(ÉqkÿûõßëO$ùx’÷w÷)›Ÿœí¬ª.’ä:I.—á:¿L’‹eø|Úwík÷×úé×û72\ç_Hò©$ïìî/ozø- ª.šá3á*k_—KrÞŸçÉðˬN]¿›áu=&ɇ3¼®ŸÛüÔ«¡ªöËðÚ]1É¥“\jíë|îC§%ÉIk_Çfx¿•áuü|’O'ùpwgóÒÃÆUÕžIMò+ùùsÅþùùsEåŸ+¾”Ÿ?W|4ÉG»»7?ùꫪ}3Üû~)?¿÷]*Ãk{ú³îùùçó >[¾ásåóIÞ›ä“^ã³VU{ex¯’äÊk_ûgxïžþ:ÿ4Ãëû?G|<Éû“ÕÝßœ!v’¤ªvÉð³ÛU“\-ÃÏrd¸ŸþuJ†Ÿ~˜á}ñ¹÷î·t÷Ñ›z“TÕnîËWÊϯ‹'¹P’fxmö\ûJ’Ÿ$9qíë»I¾šäk>¯>’äƒÝýíMü#0‘µ÷Â52\WIrp’ççϸûfx6;ýß|9É3\+ïJòžî>~Óƒ l!å¿C lžªúb††cÜx®R¨ªöNòÛIn¶öu±OõÖî¾ÑT¹v¤ª.–ävI~-Éõ’\`‚Óv†MÁoLòÂî~×ç\)k,·LrÇ$7Mrþ
œîØ$¯MòŠ$¯èî7ž~QU+É“üf†kýÀ‰NýÕ$oMòâ$¯ëî“&:ï–SUWÈðyzë›Tk§ûf’ÿJòÂ$ÿ»3oú¯ªs'¹E’ßÊÏ‚6òÚÙ×’¼#ÃûôÍÝýé Ï
“X+°¸C~þL¶ïN÷õ$¯Ìð\ñúî>uDŽç$¹Çˆµ~¯»Ÿ3*Ý&«ªk$ùÝ$7ÊP²1Å/ü~†Ï•×&yqww‚snYUu¾$¿“ág¡ßÈϳñž$ÏOòoÝ}ÜÆÓ³µ2Ê_Íð¹}†R‰E}1Éó’<»»ÙxºùTÕå3¼.×ËðLsåEESúZ’7%yu’7t÷&>ÿRTÕQIn8bdËÿ{•µ’°[fxƽE6ö³ï)>?ÿ3ÉK¶ûç' ÀYQÆ °‰”±,ô\i=¶«êRIþ É}²±MI§[zKUí“äîIî”äú™vÓûYùR’g'ybwÉk-ÕZ¡Å’Ü?É%—°Äw“<)É“ºû{ëÈóÐ$ÿ0âüîîG-˜m‡ªjÔ_éîe¿÷F[à³âÀîþârÒlÌÚãßÎp½ß<ÉÞK^ò‡I^”äñÝý™%¯5Ê÷ïî§®óÜ7Hò'^ãe¼§?žäqI^4¦Ta•UÕîJ'îœaãþž›¸üç2Uügw¿o#'Zà}õÓ$—èîomdÝÍVUÿ›aCþz}'ÉÅ»ûä%EÚiTÕþIœäÞI.¸„%¾äŸ’