From 9327a231a94329062955f837d9ab14842f026605 Mon Sep 17 00:00:00 2001 From: friederichwo Date: Tue, 27 May 2025 13:52:58 +0200 Subject: [PATCH] solutions for assignments 4 and 5 added --- assignment_04/fft_sampling_interpol.ipynb | 439 ++++++++++++++++++++ assignment_05/acausalFilters.py | 34 ++ assignment_05/spectral-estimation.ipynb | 466 ++++++++++++++++++++++ 3 files changed, 939 insertions(+) create mode 100644 assignment_04/fft_sampling_interpol.ipynb create mode 100644 assignment_05/acausalFilters.py create mode 100644 assignment_05/spectral-estimation.ipynb diff --git a/assignment_04/fft_sampling_interpol.ipynb b/assignment_04/fft_sampling_interpol.ipynb new file mode 100644 index 0000000..53bd33f --- /dev/null +++ b/assignment_04/fft_sampling_interpol.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1559cf77-eb5b-4e56-8bd9-ae61a108fe92", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from setupFigure import SetupFigure\n", + "from dftSlow import dft_coeff, dft_synthesis" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b101d00c-d9a2-4222-879b-ac340f89f576", + "metadata": {}, + "outputs": [], + "source": [ + "def dft_fast_coeff(x):\n", + " \"\"\"\n", + " Evaluate Fourier coefficients using Numpy's fast Fourier transform.\n", + " This routine only returns the coefficients for the positive frequencies.\n", + " If N is even, it goes up to n=N/2.\n", + " If N is odd, it goes up to n=(N-1)/2.\n", + " :param x: array of function samples\n", + " \"\"\"\n", + " return np.fft.rfft(x, norm='forward')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "14467eda-e7f2-423d-9b78-b7cc9672f22c", + "metadata": {}, + "outputs": [], + "source": [ + "def dft_fast_synthesis(fc, outnum='even'):\n", + " \"\"\"\n", + " Use numpy's fast Fourier synthesis taking only Fourier coefficients for positive frequencies\n", + " :param fc: aray of coefficients for positive frequencies only.\n", + " :param outnum: specifies if output time series has an even or odd number of samples (default: 'even')\n", + " \"\"\"\n", + " ns = 2*fc.size-2\n", + " if outnum == 'odd': ns = 2*fc.size-1\n", + " return np.fft.irfft(fc, ns, norm='forward')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "18ffbc73-5210-4b9a-b3e2-28d5aafd33d9", + "metadata": {}, + "outputs": [], + "source": [ + "def boxcar(dt, period, tup, tdown):\n", + " \"\"\"\n", + " Calculate samples of a boxcar function\n", + " :param dt: sampling interval\n", + " :param period: time range is 0 <= t < period (multiple of dt)\n", + " :param tup: time where boxcar goes from 0 to 1\n", + " :param tdown: time where boxcar goes from 1 to 0\n", + " \"\"\"\n", + " ns = int(period/dt)\n", + " t = dt*np.arange(0, ns)\n", + " return t, np.where(t < tup, 0, 1)*np.where(t > tdown, 0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3435e191-57a4-425a-9618-a7597b11916d", + "metadata": {}, + "outputs": [], + "source": [ + "def gaussian(dt, period, tmax, hwidth):\n", + " \"\"\"\n", + " Calculate samples of a Gaussian function\n", + " :param dt: sampling interval\n", + " :param period: time range is 0 <= t < period (multiple of dt)\n", + " :param tmax: time of maximum of Gaussian\n", + " :param hwidth: half width of Gaussian\n", + " \"\"\"\n", + " ns = int(period/dt)\n", + " t = dt*np.arange(0, ns)\n", + " return t, np.exp(-(t-tmax)**2/hwidth**2)" + ] + }, + { + "cell_type": "markdown", + "id": "8a7e3fe9-484a-49cc-af35-03b532eb62cd", + "metadata": {}, + "source": [ + "## Task 1: Compare \"slow\" Fourier transform with the fast version of numpy" + ] + }, + { + "cell_type": "markdown", + "id": "971cc8b7-7ade-4755-b5ad-9cc83e66fed5", + "metadata": {}, + "source": [ + "Again set up the boxcar function as in the previous assignment and use the provided functions to compute the Fourier coefficients by both methods. Verify that both methods yield the same results by printing the first 20 coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f5da468c-fded-40b4-a691-6adc93fbf110", + "metadata": {}, + "outputs": [], + "source": [ + "t, bx = boxcar(1, 1000, 300, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fe9a16bd-1f5c-4a28-9b4b-ef7274c5f529", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000 1000 501\n", + " 0 2.010000e-01+0.000000e+00j 2.010000e-01+0.000000e+00j\n", + " 1 -1.520194e-01-1.104485e-01j -1.520194e-01-1.104485e-01j\n", + " 2 4.686934e-02+1.442490e-01j 4.686934e-02+1.442490e-01j\n", + " 3 3.108655e-02-9.567460e-02j 3.108656e-02-9.567460e-02j\n", + " 4 -3.718483e-02+2.701637e-02j -3.718484e-02+2.701636e-02j\n", + " 5 -9.999970e-04+9.855762e-10j -1.000000e-03+4.012337e-20j\n", + " 6 2.587908e-02+1.880226e-02j 2.587908e-02+1.880225e-02j\n", + " 7 -1.345747e-02-4.141783e-02j -1.345747e-02-4.141783e-02j\n", + " 8 -1.159567e-02+3.568779e-02j -1.159566e-02+3.568778e-02j\n", + " 9 1.615938e-02-1.174048e-02j 1.615938e-02-1.174048e-02j\n", + " 10 1.000003e-03-1.096195e-09j 1.000000e-03-5.552491e-20j\n", + " 11 -1.440952e-02-1.046912e-02j -1.440952e-02-1.046913e-02j\n", + " 12 7.887543e-03+2.427536e-02j 7.887542e-03+2.427536e-02j\n", + " 13 7.096590e-03-2.184102e-02j 7.096579e-03-2.184102e-02j\n", + " 14 -1.015033e-02+7.374651e-03j -1.015033e-02+7.374646e-03j\n", + " 15 -9.999993e-04-1.489762e-11j -1.000000e-03-1.916335e-20j\n", + " 16 1.010687e-02+7.343075e-03j 1.010687e-02+7.343074e-03j\n", + " 17 -5.593138e-03-1.721391e-02j -5.593137e-03-1.721390e-02j\n", + " 18 -5.096129e-03+1.568428e-02j -5.096130e-03+1.568428e-02j\n", + " 19 7.302622e-03-5.305668e-03j 7.302625e-03-5.305668e-03j\n" + ] + } + ], + "source": [ + "c = dft_coeff(bx) # slow DFT\n", + "fc = dft_fast_coeff(bx) # fast DFT\n", + "print(t.size, c.size, fc.size)\n", + "for n in range(t.size//50):\n", + " print(\"{:6d} {:15.6e} {:15.6e}\".format(n, c[n], fc[n]))" + ] + }, + { + "cell_type": "markdown", + "id": "bc4a9050-a171-479e-90a5-df7b924143a9", + "metadata": {}, + "source": [ + "Also compare the slow and fast versions of Fourier synthesis by calling the provided functions. Print values at times around the discontinuities." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a8abee97-2424-445d-81c3-98353d5ac270", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000 1000\n", + " 290 -1.053945e-07 -6.280549e-17\n", + " 291 -8.330658e-08 1.449411e-17\n", + " 292 -5.615582e-08 -1.440881e-16\n", + " 293 -5.668051e-08 -1.612420e-16\n", + " 294 -7.121410e-08 3.892420e-18\n", + " 295 -8.654331e-08 -5.549463e-17\n", + " 296 -1.116903e-07 4.558707e-18\n", + " 297 -9.428106e-08 1.432295e-16\n", + " 298 -1.238188e-07 3.231428e-17\n", + " 299 -1.090360e-07 1.056715e-16\n", + " 300 9.999999e-01 1.000000e+00\n", + " 301 9.999999e-01 1.000000e+00\n", + " 302 9.999999e-01 1.000000e+00\n", + " 303 9.999999e-01 1.000000e+00\n", + " 304 9.999999e-01 1.000000e+00\n", + " 305 9.999999e-01 1.000000e+00\n", + " 306 9.999999e-01 1.000000e+00\n", + " 307 9.999999e-01 1.000000e+00\n", + " 308 9.999999e-01 1.000000e+00\n", + " 309 9.999999e-01 1.000000e+00\n", + " 310 9.999999e-01 1.000000e+00\n" + ] + } + ], + "source": [ + "xr = dft_synthesis(c)\n", + "if t.size%2 == 0:\n", + " xrf = dft_fast_synthesis(fc, outnum='even')\n", + "else:\n", + " xrf = dft_fast_synthesis(fc, outnum='odd')\n", + "print(xr.size, xrf.size)\n", + "for k in range(290,311):\n", + " print(\"{:6d} {:15.6e} {:15.6e}\".format(k, xr[k], xrf[k]))" + ] + }, + { + "cell_type": "markdown", + "id": "1204f35f-7933-490e-94a7-af77edaca83c", + "metadata": {}, + "source": [ + "## Task 2: Interpolation by appending zeros to the Fourier coefficients" + ] + }, + { + "cell_type": "markdown", + "id": "accff2d0-77ce-4048-bad0-8396c62ef675", + "metadata": {}, + "source": [ + "A band limited time series can be interpolated using a simple trick: First, the Fourier coefficients are computed up to the Nyquist frequency, $f_{Ny} = \\frac{N}{2}\\Delta f = \\frac{N}{2T}$. Then, $L$ zero coefficents are appended to increase the Nyquist frequency to $f'_{Ny} = (\\frac{N}{2}+L)\\Delta f$ and to decrease the sampling interval to $\\Delta t' = \\frac{1}{2f'_{Ny}}$. Subsequent Fourier synthesis produces an interpolated version of the original time series. These relations hold for even and odd number of samples.\n", + "When doing the Fourier synthesis, the routine should be called with outnum='odd' for odd N and with outnum='even' for even N, respectively.\n", + "\n", + "First set up a Gaussian using the provided function. Then compute the Fourier coefficients. Print out the number of samples, the Nyquist frequency and the number of Fourier coefficients. For example, choose dt=5, period=100, tmax=50, hw=20. \n", + "\n", + "Second, append some zeros (20) to the array of coefficients and compute the new Nyquist frequency and the new sampling interval. Do the Fourier synthesis and print the new number of samples, the new Nyquist frequency and the new sampling interval.\n", + "\n", + "Third, plot the new and old time series into one graph." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7c5663c1-5605-45df-8342-2dcefb2ec4b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N = 20 Nyquist frequency = 0.1 Ncoeff = 11\n" + ] + } + ], + "source": [ + "dt = 5; period = 100; tmax = 50; hw = 20; nz = 20\n", + "t, g = gaussian(dt, period, tmax, hw)\n", + "c = dft_fast_coeff(g)\n", + "print(\"N = \", t.size,\" Nyquist frequency = \", t.size/(2*period),\" Ncoeff = \", c.size)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2ad7ff56-8713-4386-9b4a-9228fb63fde0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N = 60 Nyquist frequency = 0.3\n" + ] + } + ], + "source": [ + "cz = np.append(c, np.zeros(nz))\n", + "fny = (t.size/2+nz)/period\n", + "dtnew = 1./(2*fny)\n", + "if t.size%2 != 0:\n", + " xr = dft_fast_synthesis(cz, outnum='odd')\n", + "else:\n", + " xr = dft_fast_synthesis(cz, outnum='even')\n", + "tz = dtnew*np.arange(0, xr.size)\n", + "print(\"N = \", tz.size,\" Nyquist frequency = \", fny)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2755badf-b7d1-47f0-ab3b-1a057faaf921", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig1, ax1 = SetupFigure(10, 5, \"Time [s]\", \"xr(t)\", \"Interpolated Gaussian\", 14)\n", + "ax1.plot(tz, xr, color='blue', ls='-', lw=0.25, marker='d', markersize=4, zorder=10)\n", + "ax1.plot(t, g, color='red', ls='', marker='o', markersize=6, zorder=5)" + ] + }, + { + "cell_type": "markdown", + "id": "fc9fd425-811c-49d1-8372-1fb2963a8310", + "metadata": {}, + "source": [ + "## Task 3: Aliasing and the sampling theorem" + ] + }, + { + "cell_type": "markdown", + "id": "a1cf5112-c521-46d9-b642-4c3fbe3fa0ee", + "metadata": {}, + "source": [ + "First, calculate values for a Gaussian with dt=0.25, period=100, tmax=50 and hwidth=1. Plot the Gaussian.\n", + "\n", + "Second, in a loop, calculate sme Gaussian with dt = 0.5, 1.0, 1.5 and 2.0. Compute the fast Fourier coefficients and the frequencies associated with them. Plot the absolute value of the coefficients into one graph. Set the upper frequency axis limit to 1.0 and use different colors for the curves. Compare the spectra, what do you observe?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9e8596d7-1eb5-4248-85c5-e90ed8beaeb8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t, g = gaussian(0.25, 100, 50, 1)\n", + "fig3, ax3 = SetupFigure(10, 3, \"Time [s]\", \"g(t)\", \"Sharp Gaussian\", 14)\n", + "ax3.plot(t, g, color='blue', ls='-', lw=1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "83511cfe-45e9-4216-96c7-f932d6199034", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig2, ax2 = SetupFigure(10, 5, \"Frequency [s]\", \"G(f)\", \"Fourier coefficients\", 14)\n", + "ax2.set_xlim(0, 1.0)\n", + "col = ['grey', 'orange', 'red', 'magenta', 'blue']\n", + "lw = [4, 1, 1, 1, 1]\n", + "for i, dt in enumerate([0.25, 0.5, 1.0, 1.5, 2.0]):\n", + " t, g = gaussian(dt, 100, 50, 1)\n", + " c = dft_fast_coeff(g)\n", + " f = 1./period*np.arange(0, c.size)\n", + " ax2.plot(f, np.absolute(c), color=col[i], ls='-', lw=lw[i], label=\"DT = {:5.2f}\".format(dt))\n", + "ax2.legend() " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8b80cd5-d9b7-40e3-858c-ed2086167c37", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/assignment_05/acausalFilters.py b/assignment_05/acausalFilters.py new file mode 100644 index 0000000..922807f --- /dev/null +++ b/assignment_05/acausalFilters.py @@ -0,0 +1,34 @@ +# ------------------------------------------------------------- +# Functions for acausal filtering +# ------------------------------------------------------------- +import numpy as np + +def boxcar_lowpass_filter(fc, df, nf): + """ + Calculates samples of the boxcar lowpass filter transfer function (positive frequencies only) + :param fc: corner frequency in Hz + :param df: frequency stepping + :param nf: number of frequencies + """ + return np.where(df*np.arange(0, nf) > fc, 0, 1) + + +def boxcar_highpass_filter(fc, df, nf): + """ + Calculates samples of the boxcar highpass filter transfer function (positive frequencies only) + :param fc: corner frequency in Hz + :param df: frequency stepping + :param nf: number of frequencies + """ + return np.where(df*np.arange(0, nf) < fc, 0, 1) + + +def hann_lowpass_filter(fc, df, nf): + """ + Calculates samples of the Hann filter transfer function (positive frequencies only) + :param fc: corner frequency in Hz + :param df: frequency stepping + :param nf: number of frequencies + """ + f = df*np.arange(0, nf) + return np.where(f < fc, np.cos(np.pi*f/fc)**2, 0) \ No newline at end of file diff --git a/assignment_05/spectral-estimation.ipynb b/assignment_05/spectral-estimation.ipynb new file mode 100644 index 0000000..cab262c --- /dev/null +++ b/assignment_05/spectral-estimation.ipynb @@ -0,0 +1,466 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0ff7abb1-c698-480b-a894-bdbb5d151fe6", + "metadata": {}, + "source": [ + "## Assignment 5\n", + "In this assignment, we look at spectral estimation and study the effects of acausal filters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "156c8712-11be-4721-9d39-ff2c47a66bcb", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from setupFigure import SetupFigure\n", + "from dftFast import dft_fast_coeff, dft_fast_synthesis\n", + "from seismicTrace import SeismicTrace" + ] + }, + { + "cell_type": "markdown", + "id": "f98951f5-96dc-4ef5-b365-85bffa21f700", + "metadata": {}, + "source": [ + "### Task 1: Functions for Hann window and filter transfer functions\n", + "Write a function that calculates samples of a Hann window for given sampling interval and window length." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c36eb15e-26e7-4e6e-bef9-8d566dc07411", + "metadata": {}, + "outputs": [], + "source": [ + "def hann_window(dt, tlen):\n", + " \"\"\"\n", + " Calculate samples of the Hann window for given DT and TLEN.\n", + " Number of samples is assumed to be int(tlen/dt)\n", + " :param dt: sampling interval\n", + " :param tlen: length of window\n", + " \"\"\"\n", + " ns = int(tlen/dt)\n", + " return 2*np.sin(np.pi*dt*np.arange(0, ns)/tlen)**2" + ] + }, + { + "cell_type": "markdown", + "id": "60dffc7b-17a1-40aa-8a6f-918504e06af2", + "metadata": {}, + "source": [ + "Write a function that calculates samples of the boxcar lowpass filter transfer function for positive frequencies only." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be77830b-6b2f-4371-9711-e83a1598c363", + "metadata": {}, + "outputs": [], + "source": [ + "def boxcar_lowpass_filter(fc, df, nf):\n", + " \"\"\"\n", + " Calculates samples of the boxcar lowpass filter transfer function (positive frequencies only)\n", + " :param fc: corner frequency in Hz\n", + " :param df: frequency stepping\n", + " :param nf: number of frequencies\n", + " \"\"\"\n", + " return np.where(df*np.arange(0, nf) > fc, 0, 1)" + ] + }, + { + "cell_type": "markdown", + "id": "33eb7b1d-4abd-42a2-99ec-cdd1765fbfde", + "metadata": {}, + "source": [ + "Write a function that calculates samples of the boxcar highpass filter transfer function for positive frequencies only." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29c56269-025a-43e9-8748-c0514a72f70d", + "metadata": {}, + "outputs": [], + "source": [ + "def boxcar_highpass_filter(fc, df, nf):\n", + " \"\"\"\n", + " Calculates samples of the boxcar highpass filter transfer function (positive frequencies only)\n", + " :param fc: corner frequency in Hz\n", + " :param df: frequency stepping\n", + " :param nf: number of frequencies\n", + " \"\"\"\n", + " return np.where(df*np.arange(0, nf) < fc, 0, 1)" + ] + }, + { + "cell_type": "markdown", + "id": "937b6b14-4d8f-40ed-bc71-86888d6e726c", + "metadata": {}, + "source": [ + "Write a function that calculates samples of the Hann filter transfer function for positive frequencies only." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0101ff10-d14d-4b96-83f8-b26f96e5ec8d", + "metadata": {}, + "outputs": [], + "source": [ + "def hann_lowpass_filter(fc, df, nf):\n", + " \"\"\"\n", + " Calculates samples of the Hann filter transfer function (positive frequencies only)\n", + " :param fc: corner frequency in Hz\n", + " :param df: frequency stepping\n", + " :param nf: number of frequencies\n", + " \"\"\"\n", + " f = df*np.arange(0, nf)\n", + " return np.where(f < fc, np.cos(np.pi*f/fc)**2, 0) " + ] + }, + { + "cell_type": "markdown", + "id": "d641182d-5526-45a9-a69a-0a6965fd942b", + "metadata": {}, + "source": [ + "### Task 2: Spectral estimation and windowing\n", + "Here, we first setup a time series that consists of a superposition of different exponentially damped sine functions simulating a series of free oscillations:\n", + "\\begin{align}\n", + "s(t) = \\sum_{k=0}^N A_k\\sin(2\\pi f_k t)\\,\\exp(-\\pi f_k t/Q_k) \\,.\n", + "\\end{align}\n", + "The aim is to find the frequencies by Fourier analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eba91f73-1651-4fd7-ad90-70980b1c5d4d", + "metadata": {}, + "outputs": [], + "source": [ + "feig = np.array([0.3, 0.48, 0.64, 0.68, 0.82, 0.85, 0.93, 0.94])*1.e-3 # eigenfreqeuncies in Hz\n", + "amp = np.array([1.0, 0.30, 2.00, 0.61, 4.00, 0.53, 3.00, 0.24]) # amplitudes\n", + "phi = np.array([ 11, 46, 271, 123, 337, 173, 65, 221])*np.pi/180. # phases\n", + "q = np.array([600, 200, 2000, 1000, 600, 100, 800, 900]) # quality factors" + ] + }, + { + "cell_type": "markdown", + "id": "e455172a-50ad-4aa4-a1b3-d29d50a52b49", + "metadata": {}, + "source": [ + "Write code that impements the above equation using the provided frequencies, amplitudes, phases and Q values. Choose dt=100 s and allow a varaible time series length of tens of hours. Plot the resulting time series." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c808e6c4-8e39-4e7c-a689-860230ff775a", + "metadata": {}, + "outputs": [], + "source": [ + "nhour = 100\n", + "dt = 100.0\n", + "tlen = 3600*nhour\n", + "ns = int(tlen/dt)\n", + "print(\"Number of samples: \", ns)\n", + "t = dt*np.arange(0, ns)\n", + "seis = np.zeros(ns)\n", + "for j, f in enumerate(feig):\n", + " seis = seis + amp[j]*np.sin(2*np.pi*f*t+phi[j])*np.exp(-np.pi*f*t/q[j])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d0dbe36-34e8-486d-bc63-f5be4aff2d0c", + "metadata": {}, + "outputs": [], + "source": [ + "fig1, ax1 = SetupFigure(12, 5, \"Time [h|\", \"s(t)\", \"Ground motion\", 14)\n", + "ax1.plot(t/3600, seis, color='blue', ls='-')" + ] + }, + { + "cell_type": "markdown", + "id": "7ae65e6e-0f73-42fc-b251-878f0ef7f36c", + "metadata": {}, + "source": [ + "Produce a second time series by multiplying the original one with a Hann window and also plot it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b62c1a43-f57e-4397-a8f9-7ec813db1e9d", + "metadata": {}, + "outputs": [], + "source": [ + "win = hann_window(dt, tlen)\n", + "seisw = seis*win" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41193b3d-110b-42a4-b2ee-9ee0dbd759af", + "metadata": {}, + "outputs": [], + "source": [ + "fig2, ax2 = SetupFigure(12, 5, \"Time [h|\", \"swin(t)\", \"Windowed ground motion\", 14)\n", + "ax2.plot(t/3600, seisw, color='blue', ls='-')" + ] + }, + { + "cell_type": "markdown", + "id": "26feab1b-41a6-464f-b578-95814286b915", + "metadata": {}, + "source": [ + "Perform a fast Fourier analysis, calculate the associated frequencies and plot the resulting amplitude spectra of both the original and the windowed time series. Compare the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "164cd4c2-72ea-44e8-a236-95475118aad1", + "metadata": {}, + "outputs": [], + "source": [ + "spec = dft_fast_coeff(seis)\n", + "f = 1./tlen*np.arange(0, spec.size)\n", + "print(\"Number of frequencies: \", spec.size, \" fmax = \", f[-1]*1000, \"mHz\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c88a619-8b9c-44ed-bc5f-f6ecce938af3", + "metadata": {}, + "outputs": [], + "source": [ + "specw = dft_fast_coeff(seisw)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73b8fae2-e712-47d7-99a5-ebe5375084cf", + "metadata": {}, + "outputs": [], + "source": [ + "fig3, ax3 = SetupFigure(12, 5, \"Frequency [mHz]\", \"S(f)\", \"Amplitude spectrum of ground motion\", 14)\n", + "ax3.set_xlim(0,1.2)\n", + "ax3.plot(f*1000, np.absolute(spec), color='blue', ls='-', label='boxcar')\n", + "ax3.plot(f*1000, np.absolute(specw), color='red', ls='-', label='hann')\n", + "ax3.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "689b3af4-1146-4041-9f4e-baed098d2a23", + "metadata": {}, + "source": [ + "### Task 2: Read a seismogram from file and compute spectrum\n", + "Here, we first read a recorded seismogram form a file, do a Fourier analysis and later apply diverse acausal filters. We make use of the class \"SeismicTrace\" that defines a data structure for a seismic trace and also some useful functions related to traces. You may want to look at the provided code in \"seismicTrace.py\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "912ae1f7-8cbc-4446-9ef0-b446b57d789d", + "metadata": {}, + "outputs": [], + "source": [ + "seisfile = \"CH.PANIX.HHZ\"\n", + "with open(seisfile, 'r') as fd:\n", + " seistrace = SeismicTrace.readFromAscii(fd)\n", + "t = seistrace.tanf+seistrace.dt*np.arange(0, seistrace.nsamp)\n", + "seistrace.printInfo()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eaee9262-f577-49a1-acee-9b9c27f996be", + "metadata": {}, + "outputs": [], + "source": [ + "fig4, ax4 = SetupFigure(12, 5, \"Time [s]\", \"s(t)\", \"Unfiltered seismic data\", 14)\n", + "ax4.plot(t, seistrace.vals, color='blue', ls='-')" + ] + }, + { + "cell_type": "markdown", + "id": "934a4fa1-7f8d-4977-bf86-bfe094abc5e5", + "metadata": {}, + "source": [ + "Perform a fast Fourier analysis, calculate the associated frequencies and plot the resulting amplitude spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4a0c8c9-b51a-4116-9988-73d75b2f6704", + "metadata": {}, + "outputs": [], + "source": [ + "spec = dft_fast_coeff(seistrace.vals)\n", + "f = 1./seistrace.tlen*np.arange(0, spec.size)\n", + "print(\"Number of frequencies: \", spec.size, \" fmax = \", f[-1], \"Hz\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82fb96d5-39ac-4c6a-a360-3544167ec26b", + "metadata": {}, + "outputs": [], + "source": [ + "fig5, ax5 = SetupFigure(12, 5, \"Frequency [Hz]\", \"S(f)\", \"Amplitude spectrum of seismogram\", 14)\n", + "ax5.set_xlim(0, 1)\n", + "ax5.plot(f, np.absolute(spec), color='blue', ls='-', label='boxcar')" + ] + }, + { + "cell_type": "markdown", + "id": "8d36d0c3-6faf-4e0b-b934-8822100b2b2f", + "metadata": {}, + "source": [ + "### Task 3: Acausal low pass filtering" + ] + }, + { + "cell_type": "markdown", + "id": "36b37ff1-3080-4651-a344-9cb4ede9109d", + "metadata": {}, + "source": [ + "Apply the boxcar lowpass filter to the data and plot the result." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1e59a76-d251-4d66-b6ba-7c29a0626b3e", + "metadata": {}, + "outputs": [], + "source": [ + "fc = 0.1\n", + "df = 1./seistrace.tlen\n", + "specfil = spec*boxcar_lowpass_filter(fc, df, spec.size)\n", + "seisfil = dft_fast_synthesis(specfil)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "532ad374-2728-435d-8dca-afd7fcf9c475", + "metadata": {}, + "outputs": [], + "source": [ + "fig6, ax6 = SetupFigure(12, 5, \"Time [s]\", \"sf(t)\", \"Boxcar lowpass filtered seismic data, FC = {:5.2f} Hz\".format(fc), 14)\n", + "#ax6.set_xlim(64000, 64500)\n", + "ax6.plot(t, seisfil, color='blue', ls='-')" + ] + }, + { + "cell_type": "markdown", + "id": "e1097e6d-c459-489d-aecd-75911419a319", + "metadata": {}, + "source": [ + "Apply the Hann low pass filter to the data and plot the result." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be2e1d6d-0c4e-4bfa-8612-ce626393bdff", + "metadata": {}, + "outputs": [], + "source": [ + "specfil2 = spec*hann_lowpass_filter(fc, df, spec.size)\n", + "seisfil2 = dft_fast_synthesis(specfil2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5d4bf72-9bc2-4679-9178-4f7bc650e4ee", + "metadata": {}, + "outputs": [], + "source": [ + "fig7, ax7 = SetupFigure(12, 5, \"Time [s]\", \"sf(t)\", \"Hann lowpass filtered seismic data, FC = {:5.2f}\".format(fc), 14)\n", + "#ax7.set_xlim(64000, 64500)\n", + "ax7.plot(t, seisfil2, color='blue', ls='-')" + ] + }, + { + "cell_type": "markdown", + "id": "3bbec473-2bf7-41d0-828d-9413dff147e8", + "metadata": {}, + "source": [ + "Apply the boxcar highpass filter to the data and plot the result." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9ec91f3-cc1c-48e5-ac53-882002fc74f6", + "metadata": {}, + "outputs": [], + "source": [ + "specfil3 = spec*boxcar_highpass_filter(fc, df, spec.size)\n", + "seisfil3 = dft_fast_synthesis(specfil3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a24950e-8438-4e3b-903e-75f2f4408105", + "metadata": {}, + "outputs": [], + "source": [ + "fig8, ax8 = SetupFigure(12, 5, \"Time [s]\", \"sf(t)\", \"Boxcar highpass filtered seismic data, FC = {:5.2f}\".format(fc), 14)\n", + "#ax7.set_xlim(64000, 64500)\n", + "ax8.plot(t, seisfil3, color='blue', ls='-')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92e0ebc5-9f7d-4302-8ad1-9aed6c7f2d6a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}